module ti.sysbios.hal.Timer
index URL

Timer Manager Proxy

This module behaves as a proxy to the generic Timer module functions as defined in ITimer.xdc. [ more ... ]
XDCspec summary sourced in ti/sysbios/hal/Timer.xdc
@ModuleStartup
module Timer {  ...
// inherits ti.sysbios.interfaces.ITimer
    // inherits xdc.runtime.IModule
instance:  ...
C synopsis target-domain
#include <ti/sysbios/hal/Timer.h>
module-wide constants & types
    #define Timer_ANY// Const used to specify any timer (UInt)~0
 
    typedef enum Timer_PeriodType// PeriodType {
        Timer_PeriodType_MICROSECS// period in microsecs,
        Timer_PeriodType_COUNTS// period in counts
    } Timer_PeriodType;
 
    typedef enum Timer_RunMode// Timer Run Modes {
        Timer_RunMode_CONTINUOUS// periodic and continuous,
        Timer_RunMode_ONESHOT// one-shot
    } Timer_RunMode;
 
    typedef enum Timer_StartMode// Timer Start Modes {
        Timer_StartMode_AUTO// timer starts automatically,
        Timer_StartMode_USER// timer will be started by user
    } Timer_StartMode;
 
    typedef enum Timer_Status// Timer Status {
        Timer_Status_INUSE// timer in use,
        Timer_Status_FREE// timer is free
    } Timer_Status;
 
    typedef Void (*Timer_FuncPtr// Timer tick function prototype)(UArg);
module-wide functions
    UInt Timer_getNumTimers// Returns number of timer peripherals on the platform( );
    ITimer_Status Timer_getStatus// Returns timer status (free or in use)( UInt id );
module-wide built-ins
    Types_ModuleId Timer_Module_id// Get this module's unique id( );
    Bool Timer_Module_startupDone// Test if this module has completed startup( );
    IHeap_Handle Timer_Module_heap// The heap from which this module allocates memory( );
    Bool Timer_Module_hasMask// Test whether this module has a diagnostics mask( );
    Bits16 Timer_Module_getMask// Returns the diagnostics mask for this module( );
    Void Timer_Module_setMask// Set the diagnostics mask for this module( Bits16 mask );
per-instance object types
    typedef struct Timer_Object// Opaque internal representation of an instance object Timer_Object;
    typedef Timer_Object *Timer_Handle// Client reference to an instance object;
    typedef struct Timer_Struct// Opaque client structure large enough to hold an instance object Timer_Struct;
 
    Timer_Handle Timer_handle// Convert this instance structure pointer into an instance handle( Timer_Struct *structP );
    Timer_Struct *Timer_struct// Convert this instance handle into an instance structure pointer( Timer_Handle handle );
per-instance config parameters
    typedef struct Timer_Params// Instance config-params structure {
        IInstance_Params *instance;
        UArg arg// Argument for tick function. Default is null;
        Types_FreqHz extFreq// Timer frequency;
        UInt32 period// Period of tick. Can be specified in timer counts or microseconds. Default is 0;
        ITimer_PeriodType periodType// Period Type. Default is PeriodType_MICROSECS;
        ITimer_RunMode runMode// Timer run mode. Default is {@link #RunMode_CONTINUOUS};
        ITimer_StartMode startMode// Start mode. Default is {@link #StartMode_AUTO};
    } Timer_Params;
 
    Void Timer_Params_init// Initialize this config-params structure with supplier-specified defaults before instance creation( Timer_Params *params );
per-instance creation
    Timer_Handle Timer_create// Allocate and initialize a new instance object and return its handle( Int id, ITimer_FuncPtr tickFxn, const Timer_Params *params, Error_Block *eb );
    Void Timer_construct// Initialize a new instance object inside the provided structure( Timer_Struct *structP, Int id, ITimer_FuncPtr tickFxn, const Timer_Params *params, Error_Block *eb );
per-instance deletion
    Void Timer_delete// Finalize and free this previously allocated instance object, setting the referenced handle to NULL( Timer_Handle *handleP );
    Void Timer_destruct// Finalize the instance object inside the provided structure( Timer_Struct *structP );
per-instance functions
    Void Timer_getFreq// Returns timer frequency in Hz( Timer_Handle handle, Types_FreqHz *freq );
    ITimer_FuncPtr Timer_getFunc// Get Timer function and arg( Timer_Handle handle, UArg *arg );
    UInt32 Timer_getPeriod// Gets timer period in timer counts( Timer_Handle handle );
    Void Timer_setFunc// Overwrite Timer function and arg( Timer_Handle handle, ITimer_FuncPtr fxn, UArg arg );
    Void Timer_setPeriod// Sets timer period specified in timer counts( Timer_Handle handle, UInt32 period );
    Bool Timer_setPeriodMicroSecs// Sets timer period specified in microseconds( Timer_Handle handle, UInt32 microsecs );
    Void Timer_start// Reloads and starts the timer( Timer_Handle handle );
    Void Timer_stop// Stop the timer( Timer_Handle handle );
per-instance convertors
    ITimer_Handle Timer_Handle_upCast// unconditionally move one level up the inheritance hierarchy( Timer_Handle handle );
    Timer_Handle Timer_Handle_downCast// conditionally move one level down the inheritance hierarchy; NULL upon failure( ITimer_Handle handle );
per-instance built-ins
    Int Timer_Object_count// The number of statically-created instance objects( );
    Timer_Handle Timer_Object_get// The handle of the i-th statically-created instance object (array == NULL)( Timer_Object *array, Int i );
    Timer_Handle Timer_Object_first// The handle of the first dynamically-created instance object, or NULL( );
    Timer_Handle Timer_Object_next// The handle of the next dynamically-created instance object, or NULL( Timer_Handle handle );
    IHeap_Handle Timer_Object_heap// The heap used to allocate dynamically-created instance objects( );
    Types_Label *Timer_Handle_label// The label associated with this instance object( Timer_Handle handle, Types_Label *buf );
    String Timer_Handle_name// The name of this instance object( Timer_Handle handle );
 
XDCscript usage meta-domain
var Timer = xdc.useModule('ti.sysbios.hal.Timer');
module-wide constants & types
    const Timer.ANY// Const used to specify any timer = ~0;
 
    values of type Timer.PeriodType// PeriodType
        const Timer.PeriodType_MICROSECS// period in microsecs;
        const Timer.PeriodType_COUNTS// period in counts;
 
    values of type Timer.RunMode// Timer Run Modes
        const Timer.RunMode_CONTINUOUS// periodic and continuous;
        const Timer.RunMode_ONESHOT// one-shot;
 
    values of type Timer.StartMode// Timer Start Modes
        const Timer.StartMode_AUTO// timer starts automatically;
        const Timer.StartMode_USER// timer will be started by user;
 
    values of type Timer.Status// Timer Status
        const Timer.Status_INUSE// timer in use;
        const Timer.Status_FREE// timer is free;
 
    var obj = new Timer.BasicView// ;
        obj.label = String  ...
        obj.delegateTimerHandle = String  ...
        obj.id = UInt  ...
        obj.startMode = String  ...
        obj.runMode = String  ...
        obj.period = UInt  ...
        obj.periodType = String  ...
        obj.intNum = UInt  ...
        obj.tickFxn = String  ...
        obj.arg = UArg  ...
        obj.HwiHandle = String  ...
 
    var obj = new Timer.ModuleView// ;
        obj.delegateTimerModule = String  ...
module-wide config parameters
    Timer.common$// Common module configuration parameters = Types.Common$ undefined;
    Timer.rovViewInfo//  = ViewInfo.Instance ViewInfo.create;
per-instance config parameters
    var params = new Timer.Params// Instance config-params object;
        params.arg// Argument for tick function. Default is null = UArg null;
        params.extFreq// Timer frequency = Types.FreqHz {
        lo: 0,
        hi: 0
    };
        params.period// Period of tick. Can be specified in timer counts or microseconds. Default is 0 = UInt32 0;
        params.periodType// Period Type. Default is PeriodType_MICROSECS = ITimer.PeriodType ITimer.PeriodType_MICROSECS;
        params.runMode// Timer run mode. Default is {@link #RunMode_CONTINUOUS} = ITimer.RunMode ITimer.RunMode_CONTINUOUS;
        params.startMode// Start mode. Default is {@link #StartMode_AUTO} = ITimer.StartMode ITimer.StartMode_AUTO;
per-instance creation
    var inst = Timer.create// Create an instance-object( Int id, Void(*)(UArg) tickFxn, params );
 
XDCspec declarations sourced in ti/sysbios/hal/Timer.xdc
package ti.sysbios.hal;
 
@ModuleStartup
module Timer inherits ITimer {
module-wide constants & types
    const UInt ANY// Const used to specify any timer = ~0;
 
    enum PeriodType// PeriodType {
        PeriodType_MICROSECS// period in microsecs,
        PeriodType_COUNTS// period in counts
    };
 
    enum RunMode// Timer Run Modes {
        RunMode_CONTINUOUS// periodic and continuous,
        RunMode_ONESHOT// one-shot
    };
 
    enum StartMode// Timer Start Modes {
        StartMode_AUTO// timer starts automatically,
        StartMode_USER// timer will be started by user
    };
 
    enum Status// Timer Status {
        Status_INUSE// timer in use,
        Status_FREE// timer is free
    };
 
    typedef Void (*FuncPtr// Timer tick function prototype)(UArg);
 
    metaonly struct BasicView//  {
        String label;
        String delegateTimerHandle;
        UInt id;
        String startMode;
        String runMode;
        UInt period;
        String periodType;
        UInt intNum;
        String tickFxn;
        UArg arg;
        String HwiHandle;
    };
 
    metaonly struct ModuleView//  {
        String delegateTimerModule;
    };
module-wide config parameters
    metaonly config Types.Common$ common$// Common module configuration parameters;
    metaonly config ViewInfo.Instance rovViewInfo//  = ViewInfo.create;
module-wide functions
    UInt getNumTimers// Returns number of timer peripherals on the platform( );
    ITimer.Status getStatus// Returns timer status (free or in use)( UInt id );
 
 
instance:
per-instance config parameters
    config UArg arg// Argument for tick function. Default is null = null;
    config Types.FreqHz extFreq// Timer frequency = {
        lo: 0,
        hi: 0
    };
    config UInt32 period// Period of tick. Can be specified in timer counts or microseconds. Default is 0 = 0;
    config ITimer.PeriodType periodType// Period Type. Default is PeriodType_MICROSECS = ITimer.PeriodType_MICROSECS;
    config ITimer.RunMode runMode// Timer run mode. Default is RunMode_CONTINUOUS = ITimer.RunMode_CONTINUOUS;
    config ITimer.StartMode startMode// Start mode. Default is StartMode_AUTO = ITimer.StartMode_AUTO;
per-instance creation
    create// Create an instance-object( Int id, ITimer.FuncPtr tickFxn );
per-instance functions
    Void getFreq// Returns timer frequency in Hz( Types.FreqHz *freq );
    ITimer.FuncPtr getFunc// Get Timer function and arg( UArg *arg );
    UInt32 getPeriod// Gets timer period in timer counts( );
    Void setFunc// Overwrite Timer function and arg( ITimer.FuncPtr fxn, UArg arg );
    Void setPeriod// Sets timer period specified in timer counts( UInt32 period );
    Bool setPeriodMicroSecs// Sets timer period specified in microseconds( UInt32 microsecs );
    Void start// Reloads and starts the timer( );
    Void stop// Stop the timer( );
}
DETAILS
This module behaves as a proxy to the generic Timer module functions as defined in ITimer.xdc.
The actual implementations of the Timer module functions are provided by the Timer module delegates.
Additional, family specific Timer module APIs may also be provided by the Timer module delegates.
Follow the link below to determine which Timer delegate is used for your Target/Device:
Delegate Mappings

Calling Context

Function Hwi Swi Task Main Startup
getNumTimers Y Y Y Y N
getStatus Y Y Y Y N
Params_init Y Y Y Y N
construct Y Y Y Y N
create N N Y Y N
delete N N Y Y N
destruct Y Y Y Y N
getFreq Y Y Y Y N
getPeriod Y Y Y Y N
setPeriod Y Y Y Y N
setPeriodMicroSecs Y Y Y Y N
start Y Y Y N N
stop Y Y Y N N
Definitions:
  • Hwi: API is callable from a Hwi thread.
  • Swi: API is callable from a Swi thread.
  • Task: API is callable from a Task thread.
  • Main: API is callable during any of these phases:
    • In your module startup after this module is started (e.g. Timer_Module_startupDone() returns TRUE).
    • During xdc.runtime.Startup.lastFxns.
    • During main().
    • During BIOS.startupFxns.
  • Startup: API is callable during any of these phases:
    • During xdc.runtime.Startup.firstFxns.
    • In your module startup before this module is started (e.g. Timer_Module_startupDone() returns FALSE).
 
const Timer.ANY
index URL

Const used to specify any timer

XDCscript usage meta-domain
const Timer.ANY = ~0;
C synopsis target-domain
#define Timer_ANY (UInt)~0
 
 
enum Timer.PeriodType
index URL

PeriodType

XDCscript usage meta-domain
values of type Timer.PeriodType
    const Timer.PeriodType_MICROSECS;
    // period in microsecs
    const Timer.PeriodType_COUNTS;
    // period in counts
C synopsis target-domain
typedef enum Timer_PeriodType {
    Timer_PeriodType_MICROSECS,
    // period in microsecs
    Timer_PeriodType_COUNTS
    // period in counts
} Timer_PeriodType;
 
VALUES
PeriodType_MICROSECS — Period value is in microseconds.
PeriodType_COUNTS — Period value is in counts.
 
enum Timer.RunMode
index URL

Timer Run Modes

XDCscript usage meta-domain
values of type Timer.RunMode
    const Timer.RunMode_CONTINUOUS;
    // periodic and continuous
    const Timer.RunMode_ONESHOT;
    // one-shot
C synopsis target-domain
typedef enum Timer_RunMode {
    Timer_RunMode_CONTINUOUS,
    // periodic and continuous
    Timer_RunMode_ONESHOT
    // one-shot
} Timer_RunMode;
 
VALUES
RunMode_CONTINUOUS — Timer is periodic and runs continuously.
RunMode_ONESHOT — Timer runs for a single period value and stops
 
enum Timer.StartMode
index URL

Timer Start Modes

XDCscript usage meta-domain
values of type Timer.StartMode
    const Timer.StartMode_AUTO;
    // timer starts automatically
    const Timer.StartMode_USER;
    // timer will be started by user
C synopsis target-domain
typedef enum Timer_StartMode {
    Timer_StartMode_AUTO,
    // timer starts automatically
    Timer_StartMode_USER
    // timer will be started by user
} Timer_StartMode;
 
VALUES
StartMode_AUTO — Statically created/consructed Timers will be started in BIOS_start(). Dynamically created Timers will start at create() time. This includes timers created before BIOS_start().
StartMode_USER — Timer will be started by the user using start().
 
enum Timer.Status
index URL

Timer Status

XDCscript usage meta-domain
values of type Timer.Status
    const Timer.Status_INUSE;
    // timer in use
    const Timer.Status_FREE;
    // timer is free
C synopsis target-domain
typedef enum Timer_Status {
    Timer_Status_INUSE,
    // timer in use
    Timer_Status_FREE
    // timer is free
} Timer_Status;
 
VALUES
Status_INUSE — Timer is in use. A timer is marked in use from the time it gets created to the time it gets deleted.
Status_FREE — Timer is free and can be acquired using create.
 
typedef Timer.FuncPtr
index URL

Timer tick function prototype

C synopsis target-domain
typedef Void (*Timer_FuncPtr)(UArg);
 
 
metaonly struct Timer.BasicView
index URL
XDCscript usage meta-domain
var obj = new Timer.BasicView;
 
    obj.label = String  ...
    obj.delegateTimerHandle = String  ...
    obj.id = UInt  ...
    obj.startMode = String  ...
    obj.runMode = String  ...
    obj.period = UInt  ...
    obj.periodType = String  ...
    obj.intNum = UInt  ...
    obj.tickFxn = String  ...
    obj.arg = UArg  ...
    obj.HwiHandle = String  ...
 
 
metaonly struct Timer.ModuleView
index URL
XDCscript usage meta-domain
var obj = new Timer.ModuleView;
 
    obj.delegateTimerModule = String  ...
 
 
metaonly config Timer.common$  // module-wide
index URL

Common module configuration parameters

XDCscript usage meta-domain
Timer.common$ = Types.Common$ undefined;
 
DETAILS
All modules have this configuration parameter. Its name contains the '$' character to ensure it does not conflict with configuration parameters declared by the module. This allows new configuration parameters to be added in the future without any chance of breaking existing modules.
 
metaonly config Timer.rovViewInfo  // module-wide
index URL
XDCscript usage meta-domain
Timer.rovViewInfo = ViewInfo.Instance ViewInfo.create;
 
 
Timer.getNumTimers( )  // module-wide
index URL

Returns number of timer peripherals on the platform

C synopsis target-domain
UInt Timer_getNumTimers( );
 
RETURNS
Number of timer peripherals.
 
Timer.getStatus( )  // module-wide
index URL

Returns timer status (free or in use)

C synopsis target-domain
ITimer_Status Timer_getStatus( UInt id );
 
RETURNS
timer status
 
module-wide built-ins
index URL

C synopsis target-domain
Types_ModuleId Timer_Module_id( );
// Get this module's unique id
 
Bool Timer_Module_startupDone( );
// Test if this module has completed startup
 
IHeap_Handle Timer_Module_heap( );
// The heap from which this module allocates memory
 
Bool Timer_Module_hasMask( );
// Test whether this module has a diagnostics mask
 
Bits16 Timer_Module_getMask( );
// Returns the diagnostics mask for this module
 
Void Timer_Module_setMask( Bits16 mask );
// Set the diagnostics mask for this module
 
per-instance object types
index URL

C synopsis target-domain
typedef struct Timer_Object Timer_Object;
// Opaque internal representation of an instance object
 
typedef Timer_Object *Timer_Handle;
// Client reference to an instance object
 
typedef struct Timer_Struct Timer_Struct;
// Opaque client structure large enough to hold an instance object
 
Timer_Handle Timer_handle( Timer_Struct *structP );
// Convert this instance structure pointer into an instance handle
 
Timer_Struct *Timer_struct( Timer_Handle handle );
// Convert this instance handle into an instance structure pointer
 
per-instance config parameters
index URL

XDCscript usage meta-domain
var params = new Timer.Params;
// Instance config-params object
    params.arg = UArg null;
    // Argument for tick function. Default is null
    params.extFreq = Types.FreqHz {
    // Timer frequency
    lo: 0,
    hi: 0
};
    params.period = UInt32 0;
    // Period of tick. Can be specified in timer counts or microseconds. Default is 0
    params.periodType = ITimer.PeriodType ITimer.PeriodType_MICROSECS;
    // Period Type. Default is PeriodType_MICROSECS
    params.runMode = ITimer.RunMode ITimer.RunMode_CONTINUOUS;
    // Timer run mode. Default is {@link #RunMode_CONTINUOUS}
    params.startMode = ITimer.StartMode ITimer.StartMode_AUTO;
    // Start mode. Default is {@link #StartMode_AUTO}
C synopsis target-domain
typedef struct Timer_Params {
// Instance config-params structure
    IInstance_Params *instance;
    // Common per-instance configs
    UArg arg;
    // Argument for tick function. Default is null
    Types_FreqHz extFreq;
    // Timer frequency
    UInt32 period;
    // Period of tick. Can be specified in timer counts or microseconds. Default is 0
    ITimer_PeriodType periodType;
    // Period Type. Default is PeriodType_MICROSECS
    ITimer_RunMode runMode;
    // Timer run mode. Default is {@link #RunMode_CONTINUOUS}
    ITimer_StartMode startMode;
    // Start mode. Default is {@link #StartMode_AUTO}
} Timer_Params;
 
Void Timer_Params_init( Timer_Params *params );
// Initialize this config-params structure with supplier-specified defaults before instance creation
 
config Timer.arg  // per-instance
index URL

Argument for tick function. Default is null

XDCscript usage meta-domain
var params = new Timer.Params;
  ...
params.arg = UArg null;
C synopsis target-domain
struct Timer_Params {
      ...
    UArg arg;
 
 
config Timer.extFreq  // per-instance
index URL

Timer frequency

XDCscript usage meta-domain
var params = new Timer.Params;
  ...
params.extFreq = Types.FreqHz {
    lo: 0,
    hi: 0
};
C synopsis target-domain
struct Timer_Params {
      ...
    Types_FreqHz extFreq;
 
DETAILS
This parameter is meaningfull only on platforms where the timer clock can be changed. If value is left at zero, then default hookup of timer clock is assumed.
 
config Timer.period  // per-instance
index URL

Period of tick. Can be specified in timer counts or microseconds. Default is 0

XDCscript usage meta-domain
var params = new Timer.Params;
  ...
params.period = UInt32 0;
C synopsis target-domain
struct Timer_Params {
      ...
    UInt32 period;
 
DETAILS
The implementation of ITimer will support a period of UInt32 timer counts and use pre-scalars if necessary.
 
config Timer.periodType  // per-instance
index URL

Period Type. Default is PeriodType_MICROSECS

XDCscript usage meta-domain
var params = new Timer.Params;
  ...
params.periodType = ITimer.PeriodType ITimer.PeriodType_MICROSECS;
C synopsis target-domain
struct Timer_Params {
      ...
    ITimer_PeriodType periodType;
 
 
config Timer.runMode  // per-instance
index URL

Timer run mode. Default is RunMode_CONTINUOUS

XDCscript usage meta-domain
var params = new Timer.Params;
  ...
params.runMode = ITimer.RunMode ITimer.RunMode_CONTINUOUS;
C synopsis target-domain
struct Timer_Params {
      ...
    ITimer_RunMode runMode;
 
 
config Timer.startMode  // per-instance
index URL

Start mode. Default is StartMode_AUTO

XDCscript usage meta-domain
var params = new Timer.Params;
  ...
params.startMode = ITimer.StartMode ITimer.StartMode_AUTO;
C synopsis target-domain
struct Timer_Params {
      ...
    ITimer_StartMode startMode;
 
 
per-instance creation
index URL

XDCscript usage meta-domain
var params = new Timer.Params;
// Allocate instance config-params
params.config =   ...
// Assign individual configs
 
var inst = Timer.create( Int id, Void(*)(UArg) tickFxn, params );
// Create an instance-object
C synopsis target-domain
Timer_Handle Timer_create( Int id, ITimer_FuncPtr tickFxn, const Timer_Params *params, Error_Block *eb );
// Allocate and initialize a new instance object and return its handle
 
Void Timer_construct( Timer_Struct *structP, Int id, ITimer_FuncPtr tickFxn, const Timer_Params *params, Error_Block *eb );
// Initialize a new instance object inside the provided structure
ARGUMENTS
id — Timer id ranging from 0 to a platform specific value
tickFxn — function that runs upon timer expiry.
params — per-instance config params, or NULL to select default values (target-domain only)
eb — active error-handling block, or NULL to select default policy (target-domain only)
DETAILS
Create could fail if timer peripheral is unavailable. To request any available timer use ANY as the id. TimerId's are logical ids. The family specific implementations map the ids to physical peripherals.
 
per-instance deletion
index URL

C synopsis target-domain
Void Timer_delete( Timer_Handle *handleP );
// Finalize and free this previously allocated instance object, setting the referenced handle to NULL
 
Void Timer_destruct( Timer_Struct *structP );
// Finalize the instance object inside the provided structure
 
Timer.getFreq( )  // per-instance
index URL

Returns timer frequency in Hz

C synopsis target-domain
Void Timer_getFreq( Timer_Handle handle, Types_FreqHz *freq );
 
ARGUMENTS
handle — handle of a previously-created Timer instance object
freq — frequency in Hz
DETAILS
This is the effective frequency of the clock incrementing the timer counter register after all scaling factors are taken into account. (including pre-scalars).
 
Timer.getFunc( )  // per-instance
index URL

Get Timer function and arg

C synopsis target-domain
ITimer_FuncPtr Timer_getFunc( Timer_Handle handle, UArg *arg );
 
ARGUMENTS
handle — handle of a previously-created Timer instance object
arg — pointer for returning Timer's function argument
RETURNS
Timer's function
 
Timer.getPeriod( )  // per-instance
index URL

Gets timer period in timer counts

C synopsis target-domain
UInt32 Timer_getPeriod( Timer_Handle handle );
 
ARGUMENTS
handle — handle of a previously-created Timer instance object
RETURNS
period in timer counts
 
Timer.setFunc( )  // per-instance
index URL

Overwrite Timer function and arg

C synopsis target-domain
Void Timer_setFunc( Timer_Handle handle, ITimer_FuncPtr fxn, UArg arg );
 
ARGUMENTS
handle — handle of a previously-created Timer instance object
fxn — pointer to function
arg — argument to function
DETAILS
Replaces a Timer object's tickFxn function originally provided in create.
 
Timer.setPeriod( )  // per-instance
index URL

Sets timer period specified in timer counts

C synopsis target-domain
Void Timer_setPeriod( Timer_Handle handle, UInt32 period );
 
ARGUMENTS
handle — handle of a previously-created Timer instance object
period — period in timer counts
DETAILS
Timer_setPeriod() invokes Timer_stop() prior to setting the period and leaves the timer in the stopped state.
To dynamically change the period of a timer you must protect against re-entrancy by disabling interrupts. Use the following call sequence to guarantee proper results:
  // disable interrupts if an interrupt could lead to
  // another call to Timer_start().
  key = Hwi_disable();
  Timer_setPeriod(period);
  Timer_start();
  Hwi_restore(key);
ITimer implementation must support UInt32 and use pre-scalars whenever necessary
SIDE EFFECTS
Calls Timer_stop(), and disables the timer's interrupt.
 
Timer.setPeriodMicroSecs( )  // per-instance
index URL

Sets timer period specified in microseconds

C synopsis target-domain
Bool Timer_setPeriodMicroSecs( Timer_Handle handle, UInt32 microsecs );
 
ARGUMENTS
handle — handle of a previously-created Timer instance object
period — period in microseconds
DETAILS
A best-effort method will be used to set the period register. There might be a slight rounding error based on resolution of timer period register. If the timer frequency cannot support the requested period, ie the timer period register cannot support the requested period, then this function returns false.
Timer_setPeriodMicroSecs() invokes Timer_stop() prior to setting the period and leaves the timer in the stopped state.
To dynamically change the period of a timer you must protect against re-entrancy by disabling interrupts. Use the following call sequence to guarantee proper results:
  // disable interrupts if an interrupt could lead to
  // another call to Timer_start().
  key = Hwi_disable();
  Timer_setPeriodMicroSecs(period);
  Timer_start();
  Hwi_restore(key);
 
Timer.start( )  // per-instance
index URL

Reloads and starts the timer

C synopsis target-domain
Void Timer_start( Timer_Handle handle );
 
ARGUMENTS
handle — handle of a previously-created Timer instance object
DETAILS
Thread safety must be observed when using the start and stop APIs to avoid possible miss- configuration of the timers and unintended behaviors. To protect against re-entrancy, surround the start/stop invocations with Hwi_disable() and Hwi_restore() calls:
  // disable interrupts if an interrupt could lead to
  // another call to Timer_start().
  key = Hwi_disable();
  Timer_stop();
  ...
  Timer_start();
  Hwi_restore(key);
SIDE EFFECTS
Enables the timer's interrupt.
 
Timer.stop( )  // per-instance
index URL

Stop the timer

C synopsis target-domain
Void Timer_stop( Timer_Handle handle );
 
ARGUMENTS
handle — handle of a previously-created Timer instance object
DETAILS
Thread safety must be observed when using the start and stop APIs to avoid possible miss- configuration of the timers and unintended behaviors. To protect against re-entrancy, surround the start/stop invocations with Hwi_disable() and Hwi_restore() calls:
  // disable interrupts if an interrupt could lead to
  // another call to Timer_start().
  key = Hwi_disable();
  Timer_stop();
  ...
  Timer_start();
  Hwi_restore(key);
SIDE EFFECTS
Disables the timer's interrupt.
 
per-instance convertors
index URL

C synopsis target-domain
ITimer_Handle Timer_Handle_upCast( Timer_Handle handle );
// unconditionally move one level up the inheritance hierarchy
 
Timer_Handle Timer_Handle_downCast( ITimer_Handle handle );
// conditionally move one level down the inheritance hierarchy; NULL upon failure
 
per-instance built-ins
index URL

C synopsis target-domain
Int Timer_Object_count( );
// The number of statically-created instance objects
 
Timer_Handle Timer_Object_get( Timer_Object *array, Int i );
// The handle of the i-th statically-created instance object (array == NULL)
 
Timer_Handle Timer_Object_first( );
// The handle of the first dynamically-created instance object, or NULL
 
Timer_Handle Timer_Object_next( Timer_Handle handle );
// The handle of the next dynamically-created instance object, or NULL
 
IHeap_Handle Timer_Object_heap( );
// The heap used to allocate dynamically-created instance objects
 
Types_Label *Timer_Handle_label( Timer_Handle handle, Types_Label *buf );
// The label associated with this instance object
 
String Timer_Handle_name( Timer_Handle handle );
// The name of this instance object
generated on Mon, 21 Dec 2009 19:43:16 GMT