BIOS Configuration Synopsis

BIOS.cpuFrequency = 48000000;// CPU Frequency (Hz)
BIOS.assertsEnabled = true;// Enable Asserts
BIOS.psaEnabled = false;// Enable PSA Extensions
BIOS.rtsGateType = 'BIOS_GateMutex';// Runtime Support Library Lock Type
BIOS.heapType = 'HeapMem';// Default Memory Heap Type
BIOS.heapSize = 4096;// Heap Size
BIOS.heapBaseAddr = '';// Base address of the 'Primary Heap' buffer
BIOS.heapEndAddr = '';// End address of the 'Primary Heap' buffer, plus one
BIOS.heapTrackEnabled = false;// Use HeapTrack with system default heap
BIOS.disableTask = false;// Disable Task
BIOS.disableSwi = false;// Disable Swi
BIOS.disableClock = false;// Disable Clock
BIOS.logsEnabled = false;// Enable Logs
BIOS.runtimeCreatesEnabled = true;// Enable Runtime Creates
BIOS.compileFiles = true;// Compile Source Files

BIOS Module Configuration Options

SYS/BIOS Assert checking in Custom SYS/BIOS library enable flag

When set to false, Assert checking code is removed from the final compiled kernel. This option can considerably improve runtime performance as well as significantly reduce the application's code size.

Enable PSA Extensions [BIOS.psaEnabled = false]
Enables ARM's Platform Security Architecture (PSA) extensions

This functionality is available on only select devices.

Runtime Support Library Lock Type [BIOS.rtsGateType = 'BIOS_GateMutex']
Gate to make sure TI RTS library APIs are re- entrant

The application gets to determine the type of gate (lock) that is used in the TI RTS library. The gate will be used to guarantee re-entrancy of the RTS APIs.

The type of gate depends on the type of threads that are going to be calling into the RTS library. For example, if both Swi and Task threads are going to be calling the RTS library's printf, GateSwi should be used. In this case, Hwi threads are not impacted (i.e. disabled) during the printf calls from the Swi or Task threads.

If NoLocking is used, the RTS lock is not plugged and re-entrancy for the TI RTS library calls are not guaranteed. The application can plug the RTS locks directly if it wants.

Numerous gate types are provided by SYS/BIOS. Each has its advantages and disadvantages. The following list summarizes when each type is appropriate for protecting an underlying non-reentrant RTS library.

  • GateHwi: Interrupts are disabled and restored to maintain re-entrancy. Use if only making RTS calls from a Hwi, Swi and/or Task.

  • GateSwi: Swis are disabled and restored to maintain re-entrancy. Use if only making RTS calls from a Swi and/or Task.

  • GateMutex: A single mutex is used to maintain re-entrancy. Use if only making RTS calls from a Task. Blocks only Tasks that are also trying to execute critical regions of RTS library.

  • GateMutexPri: A priority inheriting mutex is used to maintain re-entrancy. Blocks only Tasks that are also trying to execute critical regions of RTS library. Raises the priority of the Task that is executing the critical region in the RTS library to the level of the highest priority Task that is block by the mutex.

The default value of rtsGateType depends on the type of threading model enabled by other configuration parameters. If taskEnabled is true, GateMutex is used. If swiEnabled is true and taskEnabled is false: GateSwi is used. If both swiEnabled and taskEnabled are false: xdc.runtime#GateNull is used.

If taskEnabled is false, the user should not select GateMutex (or other Task level gates). Similarly, if taskEnabled and swiEnabledare false, the user should not select GateSwi or the Task level gates.

Valid options include the following:

'BIOS_NoLocking'No lock
'BIOS_GateHwi'GateHwi
'BIOS_GateSwi'GateSwi
'BIOS_GateMutex'GateMutex
'BIOS_GateMutexPri'GateMutexPri

Default Memory Heap Type [BIOS.heapType = 'HeapMem']

Specifies the type of heap to use for the system heap. The system heap is used to allocate instance object state structures, such as Task objects and their stacks, Semaphore objects, etc.

If set to "HeapCallback" the user must also configure the HeapCallback module with the necessary callback functions. HeapCallback_create() will be called at initialization time with a NULL HeapCallback_Params argument.

If set to "HeapUser", no system heap will not be created at startup. The user can create a heap at runtime and use the Memory_setDefaultHeap() API to register the heap with the Memory module. Or, you can use this option for applications that do not require a heap.

Valid options include the following:

'HeapMem'
'HeapMin'
'HeapCallback'
'HeapUser'HeapUser (None)

Size of system heap, units are in MAUs

If the BIOS.heapType configuration parameter is set to "HeapMin" or "HeapMem", and the BIOS.heapBaseAddr and BIOS.heapEndAddr are not set, then the system heap will be created with this size.

Base address of the 'Primary Heap' buffer [BIOS.heapBaseAddr = '']
Base address of system heap buffer

The BIOS.heapBaseAddr configuration parameter defines the base address of the system heap. A symbol from the linker command file is often used for this parameter.

End address of the 'Primary Heap' buffer, plus one [BIOS.heapEndAddr = '']
End address of system heap buffer, plus one

The BIOS.heapEndAddr configuration parameter defines the end address of the system heap. A symbol from the linker command file is often used for this parameter.

Use HeapTrack with system default heap [BIOS.heapTrackEnabled = false]
Use HeapTrack with system default heap

This configuration parameter will add a HeapTrack instance on top of the system heap. HeapTrack adds a tracker packet to every allocated buffer and displays the information in RTOS Object Viewer (ROV). An assert will be raised on a free if there was a buffer overflow.

Disable SYS/BIOS Task services

The following behaviors occur when taskEnabled is set to false:

  • Static Task creation will result in a fatal build error.
  • The Idle task object is not created. (The Idle functions are invoked within the start() thread.)
  • Runtime calls to Task_create will trigger an assertion violation via xdc.runtime.Assert#isTrue.
Disable SYS/BIOS Swi services

The following behaviors occur when swiEnabled is set to false:

  • Static Swi creation will result in a fatal build error.
  • Runtime calls to Swi_create will trigger an assertion violation via xdc.runtime.Assert#isTrue.
  • See other effects as noted for clockEnabled = false;
Disable SYS/BIOS Clock services

The following behaviors occur when clockEnabled is set to false:

  • Static Clock creation will result in a fatal build error.
  • No Clock Swi is created.
  • The Clock_tickSource is set to Clock_TickSource_NULL to prevent a Timer object from being created.
  • For APIs that take a timeout, values other than NO_WAIT will be equivalent to WAIT_FOREVER.
SYS/BIOS Log support in Custom SYS/BIOS library enable flag

When set to false, all Log code is removed from the final compiled kernel. This option can considerably improve runtime performance as well as significantly reduce the application's code size.

Warning: When logs are generated, this setting will have the side effect of requiring task stacks to be sized large enough to absorb two interrupt contexts rather than one. See the discussion on task stacks in Task for more information.

Runtime instance creation enable flag.

If set to true, Module_create() and Module_delete() are callable at runtime. Resources for these will be allocated on the heap. If false, Module_create() and Module_delete() are not callable at runtime

Compile Source Files [BIOS.compileFiles = true]


Clock Configuration Synopsis

Clock.tickPeriod = 1000;// Clock Tick Period in microseconds
Clock.tickSource = 'Clock_TickSource_TIMER';// Clock Tick Source
Clock.tickMode = 'Clock_TickMode_DYNAMIC';// Clock Tick Mode
Clock.swiPriority = 15;// Clock Swi Priority

Clock Module Configuration Options

Clock Tick Period in microseconds [Clock.tickPeriod = 1000]
Tick period specified in microseconds

Default value is family dependent. For example, Linux systems often only support a minimum period of 10000 us and multiples of 10000 us. TI platforms have a default of 1000 us.

Like most other module configuration parameters, the Clock.tickPeriod config parameter value is accessible in runtime C code as "Clock_tickPeriod".

Source of clock ticks

"Clock_TickSource_TIMER": The Clock module automatically configures a a Timer instance to drive the Clock tick.

"Clock_TickSource_USER": The Application is responsible for calling "Clock_tick()" periodically.

"Clock_TickSource_NULL": The Clock module is disabled. In this case, it is an error for the application to ever call Clock_tick().

If this parameter is not set to "Clock_TickSource_TIMER", Clock_tickStart(), Clock_tickStop(), and Clock_tickReconfig(), have no effect.

The default is "Clock_TickSource_TIMER".

Valid options include the following:

'Clock_TickSource_TIMER' - Timer
'Clock_TickSource_USER' - User
'Clock_TickSource_NULL' - None

Timer tick mode

This parameter specifies the tick mode to be used by the underlying Timer.

With "Clock_TickMode_PERIODIC" the timer will interrupt the CPU at a fixed rate, defined by the tickPeriod.

With "Clock_TickMode_DYNAMIC" the timer can be dynamically reprogrammed by Clock, to interrupt the CPU when the next tick is actually needed for a scheduled timeout. "Clock_TickMode_DYNAMIC" is not supported on all devices, and may have some application constraints.

Valid options include the following:

'Clock_TickMode_PERIODIC' - Periodic
'Clock_TickMode_DYNAMIC' - Dynamic

Clock Swi Priority [Clock.swiPriority = 15]
The priority of Swi used by Clock to process its instances

All Clock instances are executed in the context of a single Swi. This parameter allows you to control the priority of that Swi.

The default value of this parameter is Swi.numPriorities - 1; i.e., the maximum Swi priority.


Idle Configuration Synopsis

inst.idleFxn = '';// Idle Function

Idle Instance Configuration Options

Idle Function [inst.idleFxn = '']


Semaphore Configuration Synopsis

Semaphore.supportsPriority = true;// Supports Priority
Semaphore.supportsEvents = false;// Supports Events

Semaphore Module Configuration Options

Support Task priority pend queuing?

When set to 'true', a Semaphore can be configured to support task priority-based queueing.

When set to 'false', all Semaphores support only first-in, first-out task queueing.

The default for this parameter is true.

Support Semaphores with Events?

When set to 'true', a Semaphore can be configuered with an embedded Event object which will get 'posted' whenever Semaphore_post() is called.

When set to 'false' no Semaphores can be configured with embedded Event objects.

The default for this parameter is false.


Swi Configuration Synopsis

Swi.numPriorities = 16;// Number of Swi Priorities

Swi Module Configuration Options

Number of Swi Priorities [Swi.numPriorities = 16]
Number of Swi priorities supported

The maximum number of priorities supported is target-specific and depends on the number of bits in a UInt data type. For 6x and ARM devices the maximum number of priorities is therefore 32. For the C28x, the maximum number of priorities is 16.


Task Configuration Synopsis

Task.numPriorities = 16;// Number of Task Priorities
Task.defaultStackSize = 1024;// Default Stack Size
Task.idleTaskStackSize = 1024;// Idle Task's Stack Size
Task.idleTaskVitalTaskFlag = true;// Idle Task's "Vital Task" flag
Task.allBlockedFunc = 'NULL';// All Blocked Function
Task.initStackFlag = true;// Initialize Stack Flag
Task.checkStackFlag = true;// Check Stack Flag
Task.enableIdleTask = true;// Enable Idle Task
Task.minimizeLatency = false;// Minimize Latency
Task.deleteTerminatedTasks = false;// Delete Terminated Tasks

Task Module Configuration Options

Number of Task Priorities [Task.numPriorities = 16]
Number of Task priorities supported. Default is 16.

The maximum number of priorities supported is target specific and depends on the number of bits in a UInt data type. For 6x and ARM devices the maximum number of priorities is therefore 32. For C28x devices, the maximum number of priorities is 16.

Default stack size (in MAUs) used for all tasks.

Default is obtained from the device-aware Settings table ( ti/sysbios/family/Settings.js).

Idle Task's Stack Size [Task.idleTaskStackSize = 1024]
Idle task stack size in MAUs

Default is obtained from the device-aware Settings table ( ti/sysbios/family/Settings.js).

Idle Task's "Vital Task" flag [Task.idleTaskVitalTaskFlag = true]
Idle task's vitalTaskFlag. Default is true.

See the "vitalTaskFlag" decription in the BIOS Users' Guide

Function to call while all tasks are blocked.

This function will be called repeatedly while no tasks are ready to run.

Ordinarily (in applications that have tasks ready to run at startup), the function will run in the context of the last task to block.

In an application where there are no tasks ready to run when BIOS_start() is called, the allBlockedFunc function is called within the BIOS_start() thread which runs on the system/ISR stack.

By default, allBlockedFunc is initialized to point to an internal function that simply returns.

By adding the following lines to the config script, the Idle functions will run whenever all tasks are blocked:

Task.enableIdleTask = false;
Task.allBlockedFunc = "Idle_run";
Initialize Stack Flag [Task.initStackFlag = true]
Initialize stack with known value for stack checking at runtime (see checkStackFlag). If this flag is set to false, while the ti.sysbios.hal.Hwi#checkStackFlag is set to true, only the first byte of the stack is initialized.

This is also useful for inspection of stack in debugger or core dump utilities. Default is true.

Check 'from' and 'to' task stacks before task context switch.

The check consists of testing the top of stack value against its initial value (see initStackFlag). If it is no longer at this value, the assumption is that the task has overrun its stack. If the test fails, then the E_stackOverflow error is raised.

Default is true.

To enable or disable full stack checking, you should set both this flag and the ti.sysbios.hal.Hwi#checkStackFlag.

note: Enabling stack checking will add some interrupt latency because the checks are made within the Task scheduler while interrupts are disabled.

Construct a task (of priority 0) to run the Idle functions in.

When set to true, a task is constructed that continuously calls the Idle_run() function, which, in turn calls each of the configured Idle functions.

When set to false, no Idle Task is created and it is up to the user to call the Idle_run() function if the configured Idle functions need to be run. Or, by adding the following lines to the config script, the Idle functions will run whenever all tasks are blocked:

Task.enableIdleTask = false;
Task.allBlockedFunc = "Idle_run";
Reduce interrupt latency by enabling interrupts within the Task scheduler.

By default, interrupts are disabled within certain critical sections of the task scheduler when switching to a different task thread. This default behavior guarantees that a task stack will only ever absorb ONE ISR context. Nested interrupts all run on the shared Hwi stack.

While most users find this behavior desirable, the resulting impact on interrupt latency is too great for certain applications.

By setting this parameter to 'true', the worst case interrupt latency imposed by the kernel will be reduced but will result in task stacks needing to be sized to accommodate one additional interrupt context.

Automatically delete terminated tasks.

If this feature is enabled, an Idle function is installed that deletes dynamically created Tasks that have terminated either by falling through their task function or by explicitly calling Task_exit().

A list of terminated Tasks that were created dynmically is maintained internally. Each invocation of the installed Idle function deletes the first Task on this list. This one-at-a-time process continues until the list is empty.

note: This feature is disabled by default.

warning: When this feature is enabled, an error will be raised if the user's application attempts to delete a terminated task. If a terminated task has already been automatically deleted and THEN the user's application attempts to delete it (ie: using a stale Task handle), the results are undefined and probably catastrophic!


Assert Configuration Synopsis

Assert.addFileLine = true;// Add file and line info to assert messages
Assert.useBkpt = false;// Use BKPT for assert function

Assert Module Configuration Options

Add file and line info to assert messages [Assert.addFileLine = true]
Add file and line info to assert messages

Use the C pre-processor's FILE and LINE macros to add file name and line number to the output string. You can set this parameter to 'false' to save flash space on the target.

Use BKPT for assert function [Assert.useBkpt = false]
Use a software breakpoint for the assert function

If this parameter is set to true, a software breakpoint opcode will be used to halt the processor when an Assert is raised.


Error Configuration Synopsis

Error.policy = 'Error_UNWIND';// Error policy
Error.raiseHook = 'NULL';// optional function to call when an error is raised
Error.printDetails = true;// use System_printf() to print details
Error.retainStrings = true;// Leave strings in memory (flash)
Error.addFileLine = true;// Add file and line info to error messages

Error Module Configuration Options

System-wide error handling policy

You can use this parameter to decide at the configuration time what happens when an error is raised. The program can either return back to the caller, call System_abort(), or spin indefinitely.

Valid options include the following:

'Error_UNWIND'
'Error_TERMINATE'
'Error_SPIN'

optional function to call when an error is raised [Error.raiseHook = 'NULL']
The function to call whenever an error is raised

If set to a non-null value, the referenced function is always called when an error is raised, even if the Error policy is TERMINATE or SPIN.

By default, this function is set to Error_print which causes the error to be formatted and output via System_printf. Setting this configuration parameter to null indicates that no function hook should be called.

@see #HookFxn @see #print

use System_printf() to print details [Error.printDetails = true]
use System_printf() to print error details

If set to true, error details will be printed using System_printf(). System_printf() is a fairly big function that uses a lot of flash. You can set this parameter to false to avoid pulling in System_printf().

Leave strings in memory (flash) [Error.retainStrings = true]
keep strings in target memory (flash)

If set to true, error strings will be stored in the .const section which will be loaded and take up space on the target. If set to false, the error strings will be placed in a separate section .error_str section which can be be placed in a no load section that won't be loaded on the target.

Add file and line info to error messages [Error.addFileLine = true]
keep strings in target memory (flash)

Use the C pre-processor's FILE and LINE macros to add file name and line number to the output string. You can set this parameter to 'false' to save flash space on the target.


Startup Configuration Synopsis

Startup.startupEnabled = true;// Startup Enabled
inst.startupFxn = '';// Startup Function
inst.functionType = 'First Function';// Startup Function Type
inst.priority = 1;// Priority

Startup Module Configuration Options


Startup Instance Configuration Options

Startup Function [inst.startupFxn = '']

Valid options include the following:

'Reset Function'
'First Function'
'Module Init Function'
'Last Function'


SysCallback Configuration Synopsis

SysCallback.abortFxn = 'SysCallback_defaultAbort';// User supplied abort function
SysCallback.exitFxn = 'SysCallback_defaultExit';// User supplied exit function
SysCallback.flushFxn = 'SysCallback_defaultFlush';// User supplied flush function
SysCallback.initFxn = 'SysCallback_defaultInit';// User supplied init function
SysCallback.putchFxn = 'SysCallback_defaultPutch';// User supplied output function
SysCallback.readyFxn = 'SysCallback_defaultReady';// User supplied ready function

SysCallback Module Configuration Options

User supplied abort function

This function is called when the application calls System_abort() function. If the user supplied funtion returns, the abort function of the ANSI C Standard library is called. For more information see the System_abort() documentation.

By default, this function is configured with a default abort function. This default abort function spins forever and never returns.

User supplied exit function

This function is called when the application calls System_exit() function. If the user supplied function returns, the ANSI C Standard Library atexit processing will be completed. For more information see the System_exit() documentation.

By default, this function is configured with a default exit function. The default exit function does nothing and returns.

User supplied flush function

This function is called when the application calls System_flush() function.

By default, this function is configured with a default flush function. The default flush function does nothing and returns.

User supplied character output function

This function is called whenever the System module needs to output a character; e.g., during System_printf() or System_putch().

By default, this function is configured with a default putch function. The default putch function drops the characters.

User supplied ready function

This function is called by the System module prior to performing any character output to check if the SystemSupport module is ready to accept the character.

By default, this function is configured with a default ready function. The default ready function returns true always.


SysMin Configuration Synopsis

SysMin.outputFunc = 'SysMin_output';// Character Output function callback
SysMin.bufSize = 1024;// Output Buffer Size
SysMin.flushAtExit = true;// Flush At Exit

SysMin Module Configuration Options

Character Output function callback [SysMin.outputFunc = 'SysMin_output']
User supplied character output function

If this parameter is set to a non-null value, the specified function will be called by System_flush() to output any characters buffered within SysMin.

For example, if you define a function named "myOutputFxn", the following configuration fragment will cause SysMin to call "myOutputFxn" whenever the character buffer is flushed. @p(code) var SysMin = scripting.addModule("/ti/sysbios/runtime/SysMin"); SysMin.outputFxn = "myOutputFxn"; @p

If this parameter is not set, a default function will be used which uses the ANSI C Standard Library function fwrite() (or HOSTwrite in the TI C Run Time Support library) to output accumulated output characters.

Output Buffer Size [SysMin.bufSize = 1024]
Size (in MAUs) of the output.

An internal buffer of this size is allocated. All output is stored in this internal buffer.

If 0 is specified for the size, no buffer is created, all output is dropped, and SysMin_ready() always returns false.

Flush the internal buffer during exit or abort.

If the application's target is a TI target, the internal buffer is flushed via the HOSTwrite function in the TI C Run Time Support (RTS) library.

If the application's target is not a TI target, the internal buffer is flushed to stdout via fwrite(..., stdout).

Setting this parameter to false reduces the footprint of the application at the expense of not getting output when the application ends via a System_exit(), System_abort(), exit() or abort().


System Configuration Synopsis

System.supportModule = 'SysMin';// SystemSupport Module
System.maxAtexitHandlers = 8;// Maximum Atexit Handlers
System.abortFxn = 'System_abortStd';// System_abort() function
System.exitFxn = 'System_exitStd';// System_exit(int status) function
System.extendedFormats = '';// Optional System_printf formats

System Module Configuration Options

back end support module

Module used to handle the bulk of System support functionality.

Valid options include the following:

'SysMin'
'SysCallback'

Maximum Atexit Handlers [System.maxAtexitHandlers = 8]
Maximum number of dynamic atexit handlers allowed in the system.

Maximum number of System_atexit handlers set during runtime via the System_atexit() function.

Abort handler function

This configuration parameter allows users to plug in their own abort function. By default, System_abortStd, which calls ANSI C Standard abort() is plugged in. Alternatively, System_abortSpin can be plugged which loops infinitely.

System_exit(int status) function [System.exitFxn = 'System_exitStd']
Exit handler function

This configuration parameter allows users to plug in their own exit function. By default, System_exitStd, which calls ANSI C Standard exit() is plugged in. Alternatively, System_exitSpin can be plugged which loops infinitely.

Optional System_printf formats [System.extendedFormats = '']
Optional conversions supported by System_printf

This string specifies the set of optional argument conversion specifiers required by the application. By reducing the number of optional conversions understood by the System printf methods, it is possible to significantly reduce the code size footprint of the System module. This configuration parameter enables one to balance printf functionality against code size footprint.

The format of this string is simply a concatenated list of the desired conversion specifiers (with the leading % character). For example, to support %f, set extendedFormats to "%f".

To disable all optional converstions, set extendedFormats to null or the empty string "".

For a complete list of supported extensions, see the System_printf "Extended_Format_Specifiers" section.

Note: If an optional conversion is used by some part of the application and it is not specified in extendedFormats, the conversion character(s) and leading % are treated as ordinary characters to be output. As a result, all subsequent arguments will almost certainly be converted using the wrong conversion specifier!


Timestamp Configuration Synopsis

Timestamp.timestampProvider = 'RTC TimestampProvider';// Timestamp Provider

Timestamp Module Configuration Options

Valid options include the following:

'RTC TimestampProvider'
'DWT TimestampProvider'
'LM4 TimestampProvider'
'SysTick TimestampProvider'


HeapBuf Configuration Synopsis

HeapBuf.trackMaxAllocs = false;// Track maximum number of outstanding alloc()s

HeapBuf Module Configuration Options

Track maximum number of outstanding alloc()s [HeapBuf.trackMaxAllocs = false]
Track maximum number of allocations

This will enable/disable the tracking of the maximum number of allocations for a HeapBuf instance. This maximum refers to the "all time" maximum number of allocations for the history of a HeapBuf instance, not the current number of allocations.


HeapCallback Configuration Synopsis

HeapCallback.allocInstFxn = 'HeapCallback_defaultAlloc';// alloc function callback
HeapCallback.createInstFxn = 'HeapCallback_defaultCreate';// create function callback
HeapCallback.deleteInstFxn = 'HeapCallback_defaultDelete';// delete function callback
HeapCallback.freeInstFxn = 'HeapCallback_defaultFree';// free function callback
HeapCallback.getStatsInstFxn = 'HeapCallback_defaultGetStats';// getStats function callback
HeapCallback.initFxn = 'HeapCallback_defaultInit';// init function callback
HeapCallback.isBlockingInstFxn = 'HeapCallback_defaultIsBlocking';// isBlocking function callback

HeapCallback Module Configuration Options

User supplied instance alloc function

This function is called when HeapCallback_alloc() is called.

This parameter is configured with a default alloc function. The default alloc function returns NULL.

User supplied instance create function

This function is called when HeapCallback_create() is called.

This parameter is configured with a default create function. The default create function returns 0.

User supplied instance delete function

This function is called when HeapCallback_delete() is called.

This parameter is configured with a default delete function.

User supplied instance free function

This function is called when HeapCallback_free() is called.

This parameter is configured with a default free function.

User supplied getStats function

This function is called when HeapCallback_getStats() is called.

This parameter is configured with a default getStats function. The default getStats function does not make any changes to stats structure.

User supplied init function

This function is called at boot time to initialize the custom heap manager.

This parameter is configured with a default init function. The default init function is a noop and does nothing.

User supplied isBlocking function

This function is called when HeapCallback_isBlocking() is called.

This parameter is configured with a default isBlocking function. The default isBlocking returns FALSE.


HeapMem Configuration Synopsis

HeapMem.modGateType = 'GateMutex';// Module Gate Type

HeapMem Module Configuration Options

Valid options include the following:

'GateHwi'Gate Hwi
'GateSwi'Gate Swi
'GateTask'Gate Task
'GateMutex'
'GateMutexPri'


HeapMin Configuration Synopsis

HeapMin.freeError = true;// Raise Error if free() is called

HeapMin Module Configuration Options

Raise Error if free() is called [HeapMin.freeError = true]
Flag to control whether HeapMin_E_freeError is enabled.

If true, a HeapMin_E_freeError error occurs when trying to free a buffer.

If false, no error occurs and the free() does nothing.


Hwi Configuration Synopsis

Hwi.numInterrupts = 54;// Number of Interrupts
Hwi.disablePriority = '1';// Hwi_disable() priority
Hwi.priGroup = '0';// Priority Group
Hwi.nvicCCR = STKALIGN;// NVIC CCR Register Settings
Hwi.initStackFlag = true;// Initialize Hwi Stack
Hwi.checkStackFlag = false;// Check Hwi Stack In Idle Task
Hwi.dispatcherAutoNestingSupport = true;// Dispatcher Auto Nesting Support
Hwi.dispatcherSwiSupport = true;// Dispatcher Swi Support
Hwi.dispatcherTaskSupport = true;// Dispatcher Task Support
Hwi.enableException = true;// Enable Exception Decoding at runtime
Hwi.excHandlerFunc = 'Hwi_excHandlerMax';// Exception Handler
Hwi.resetVectorAddress = '0';// Reset Vector Table Address
Hwi.vectorTableAddress = '536870912';// Runtime Vector Table Address
Hwi.coreVectors = ;// Core Exception Handlers

Hwi Module Configuration Options

Number of Interrupts [Hwi.numInterrupts = 54]

Hwi_disable() priority [Hwi.disablePriority = '1']
The priority that BASEPRI is set to by Hwi_disable().

All interrupts configured with equal or less priority (equal or higher number) than disablePriority are disabled by Hwi_disable. Interrupts configured with higher priority (smaller number) than Hwi.disablePriority are non-maskable (ie zero-latency).

The default setting is the second highest interrupt priority defined for the device (typically '0x20' for devices which support 8 priority values). This results in priority 0 (and all other values in the same priority group, ie 0x00 thru 0x1f) being the zero-latency, non-maskable interrupt priority. All other priorities are disabled with Hwi_disable().

Valid options include the following:

'7'7 - Lowest Priority
'6'
'5'
'4'
'3'
'2'
'1'1 - Highest Priority

Priority Group [Hwi.priGroup = '0']
Priority Group Setting

This value will be written to the PRIGROUP field within the NVIC's Application Interrupt and Reset Control Register (Hwi_nvic.AIRCR). It defines how the 8 bit priority values are interpreted by the hardware.

Valid options include the following:

'0'
'1'
'2'
'3'
'4'
'5'
'6'
'7'

NVIC CCR Register Settings [Hwi.nvicCCR = STKALIGN]

These setting are written to Hwi_nvic.CCR at startup time.

Valid options include the following:

STKALIGN
BFHFNMIGN
DIV_0_TRP
UNALIGN_TRP
USERSETMPEND
NONEBASETHRDENA

Initialize Hwi Stack [Hwi.initStackFlag = true]
Initialize ISR stack with known value for stack checking at runtime

This is useful for inspection of the stack in the debugger or core dump utilities for stack overflow and depth.

Default is true.

Check Hwi Stack In Idle Task [Hwi.checkStackFlag = false]
Check for Hwi stack overrun during Idle loop.

When set to 'true', an idle function is added to the idle loop that checks for a Hwi stack overrun condition and raises an Error if one is detected.

The check consists of testing the top of stack value against its initial value. If it is no longer at this value, the assumption is that the ISR stack has been overrun. If the test fails, then the "Hwi_E_stackOverflow" error is raised.

Dispatcher Auto Nesting Support [Hwi.dispatcherAutoNestingSupport = true]
Include interrupt nesting logic in interrupt dispatcher?

Default is true.

This option provides the user with the ability to optimize interrupt dispatcher performance when support for interrupt nesting is not required.

warning: Setting this parameter to false will disable interrupts during the execution of your Hwi functions.

Include Swi scheduling logic in interrupt dispatcher?

This option provides the user with the ability to optimize interrupt dispatcher performance when it is known that Swis will not be posted from any of their Hwi threads.

warning: Setting this parameter to false will disable the logic in the interrupt dispatcher that invokes the Swi scheduler prior to returning from an interrupt. With this setting, Swis MUST NOT be posted from Hwi functions!

The default is 'true'.

Dispatcher Task Support [Hwi.dispatcherTaskSupport = true]
Include Task scheduling logic in interrupt dispatcher?

This option provides the user with the ability to optimize interrupt dispatcher performance when it is known that no Task scheduling APIs (ie Semaphore_post()) will be executed from any of their Hwi threads.

warning: Setting this parameter to false will disable the logic in the interrupt dispatcher that invokes the Task scheduler prior to returning from an interrupt.

Default is 'true'.

Enable Exception Decoding at runtime [Hwi.enableException = true]
Enable full exception decoding

When this is enabled, the exception handler will fully decode an exception and dump the registers to the system console.

When disabled, the exception context is only available using ROV.

Exception handler function pointer.

The default is determined by the value of Hwi.enableException.

If the user does NOT set this parameter, then the following default behavior is followed:

If Hwi.enableException is true, then the internal 'Hwi_excHandlerMax' function is used. This exception handler saves the exception context then does a complete exception decode and dump to the console, then raises an Error. The exception context can be viewed within CCS in the ROV Hwi module's Exception view.

If Hwi.enableException is false, then the internal 'Hwi_excHandlerMin' function is used. This exception handler saves the exception context then raises an Error. The exception context can be viewed within CCS in the ROV Hwi module's Exception view.

If the user sets this parameter to their own function, then the user's function will be invoked with the following arguments:

Void myExceptionHandler(UInt *excStack, UInt lr);

Where 'excStack' is the address of the stack containing the register context at the time of the exception, and 'lr' is the link register value when the low-level-assembly-coded exception handler was vectored to.

If this parameter is set to 'null', then an infinite while loop is entered when an exception occurs. This setting minimizes code and data footprint but provides no automatic exception decoding.

Reset Vector Table Address [Hwi.resetVectorAddress = '0']
Reset vector table address. Default is 0x00000000.

This parameter is the address of the vector table used at system reset time. Typically this is placed at 0x00000000.

If the Hwi.resetVectorAddress has a different value than the Hwi.vectorTableAddress then two vector tables are generated, one at the Hwi.resetVectorAddress and another at the Hwi.vectorTableAddress.

After the initial boot code has been executed at startup, the NVIC's Vector Table Offset Register will be programmed to point to the vector table at the Hwi.vectorTableAddress.

is created and placed in the ".resetVecs" section.

Runtime Vector Table Address [Hwi.vectorTableAddress = '536870912']
Location of the Runtime Interrupt Vector Table. Default is device dependent.

This parameter allows the user to override the default placement of the runtime interrupt vector table. The NVIC's Vector Table Offset Register (VTOR) is also programmed to this value.

Some systems require the runtime vector table to be placed at an address other than 0 but still need a copy of the two M3/M4 boot vectors (SP and reset PC), located there. To achieve this, a separate parameter resetVectorAdress is provided. If the resetVectorAddress has a different value then the vectorTableAddress then a separate vector table is generated and placed at that address.

The vector table must be placed at an address at or lower than 0x3FFFFC00 and must be aligned on an even 64 word boundary.

Core Exception Handlers [Hwi.coreVectors = ]


Boot Configuration Synopsis

Boot.trimDevice = true;// Trim Device Flag
Boot.customerConfig = false;// Use default CCFG from driverlib

Boot Module Configuration Options

Trim device flag; determines if SetupTrimDevice() is called at boot, default is true.

Set to false to disable the Boot module from trimming the device. The device must be trimmed for proper operation. If the Boot module doesn't do this, the application must explicitly call SetupTrimDevice().

Use default CCFG from driverlib [Boot.customerConfig = false]
Include a default customer configuration (CCFG) structure, default is false.

Set to true to link in the default CCFG data structure in driverlib.


Load Configuration Synopsis

Load.postUpdate = 'NULL';// Post Update function
Load.updateInIdle = true;// Update in Idle
Load.windowInMs = 500;// Window size in milliseconds
Load.hwiEnabled = false;// Enable Hwi load monitoring
Load.swiEnabled = false;// Enable Swi load monitoring
Load.taskEnabled = true;// Enable Task load monitoring
Load.autoAddTasks = true;// Automatically add all tasks
Load.enableCPULoadCalc = true;// Enable CPU load calculation
Load.minIdle = 0;// Minimum time used to compute idle time

Load Module Configuration Options

Post Update function [Load.postUpdate = 'NULL']
User function called after each load update

If non-NULL, postUpdate is run immediately after each update.

Automatically call update in Idle loop

If this parameter is set to true, an Idle function, which computes and updates the CPU load, is added to the Idle loop.

Window size in milliseconds [Load.windowInMs = 500]
Load averaging period

When updateInIdle is enabled, this period determines the minimum elapsed time between updates of the load statistics in the idle loop.

Enable Hwi load monitoring [Load.hwiEnabled = false]
Enables Hwi time monitoring

When this parameter is set to true, Hwi processing time is accumulated between successive calls of update and, as part of Load_update, an event with this cumulative time is logged. This time, together with the total elapsed time, is used to estimate the CPU load due to any Hwi instances run between these updates.

Enable Swi load monitoring [Load.swiEnabled = false]
Enables Swi time monitoring

When this parameter is set to true, Swi processing time is accumulated between successive calls of update and, as part of Load_update, an event with this cumulative time is logged. This time together with the total elapsed time is used to estimate the CPU load due to any Swi instances run between these updates.

Enable Task load monitoring [Load.taskEnabled = true]
Enables Task time monitoring

When this parameter is set to true, each Task's processing time is accumulated between successive calls of update and, as part of Load_update, an event with this cumulative time is logged for each task. This time together with the total elapsed time is used to estimate the CPU load due to each Task run between these updates.

Automatically add all tasks [Load.autoAddTasks = true]
Automatically add all tasks

Enable CPU load calculation [Load.enableCPULoadCalc = true]
Automatically update the Load module's CPU load value in update.

If this parameter is set to true, Load_update() will calculate the CPU load for the elapsed time. In some cases, the user may prefer to use the statistics gathered by the Load module and do the CPU load calculation themself. Set this parameter to false, to disable the Load module's CPU load calculations. This can improve performance of the Load_update() call.

Minimum time used to compute idle time [Load.minIdle = 0]
Specifies the minimum time used to compute idle time

During CPU load measurement, the minimum time observed executing the idle loop together with the count of the number of times the idle loop runs id used to compute the total idle time. However, since the actual time spent in the idle loop will almost always be greater then the observed minimum, the idle time is almost always under estimated.

This configuration parameter can be used to compensate for this underestimate by placing a lower bound on the minimum time used in the CPU measurements. The minimum idle time used to compute CPU load is guarenteed to be greater than or equal to minIdle.


How to Read SysConfig Synopsis Lines

SysConfig configuration scripts consist of a sequence of assignments to configuration parameters defined by the modules used in an application. There are two types of assignments: assignments to module-level configuration parameters (that apply to all instances of the module) and assignments to instance-level configuration parameters (which are specific to the instance alone). All configuration parameters have a default value that's used in the event that it's not explicitly set in the configuration script.

Synopsis lines of the form
MOD.paramName = defaultValue
illustrate an assignment of a module configuration parameter's default value to the configuration parameter itself.

Similarily,
inst.paramName = defaultValue
illustrates an assignment of a instance configuration parameter's default value to the configuration parameter itself.

For example, the following is a snippet of a SysConfg script that configures the GPIO module and a GPIO instance.

// Add the GPIO module to this configuration
var GPIO = system.addModule('/ti/drivers/GPIO');
// Set a GPIO module configuration parameter
GPIO.optimizeCallbackTableSize = true;
// Add a new GPIO instance
var led = GPIO.addInstance();
// Set this instance's configuration parameters
led.$name = 'LED';
led.mode = 'Output';