![]() |
![]() |
This module supports users utilizing Texas Instruments boards by generating board-specific support functions. For more details, please visit the Configuration Options and the Board Description.
This module provides basic validation required by any Hardware Component that has been added to the board.
Hardware Components that require validation simply declare the name of a module that must be added to a configuration. The declaration is made by adding a "requiredModule" field to the settings structure of the Hardware Component.
The module named by a requiredModule field implements a validation function that can reflect on the state of the configuration and plant errors, warnings, and/or info messages throughout the system as needed.
The example below is a fragment of the TMP116 component from the BOOSTXL-BASSENSORS.syscfg.json:
"TMP116": {
"type": "TMP116",
"displayName": "TMP116 Temperature Sensor",
"description": "Accurate Digital Temperature Sensor ...",
"settings": {
"requiredModule": "/ti/boards/boosterpacks/bas/BAS",
:
},
:
}In this case, whenever this TMP116 component is added to the board's Hardware Components, the /ti/boards/boosterpacks/bas/BAS module will be implicitly added to the application's configuration. This, in turn, will ensure that any validation functions defined by the BAS module will execute.
Board.generateInitializationFunctions = true; | // Generate Initialization Functions |
Generate Initialization Functions
[Board.generateInitializationFunctions = true]
|
The DMA module provides support to other drivers that need to allocate exclusive access to a DMA resource to support CPU-less peripheral data transfers. There is no user API for this module. See Driver configurations reference for more information.
DMA Implementation
[DMA.dmaImplementation = 'DMAWFF3']
|
Displays DMA delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'DMAWFF3' | |
The GPIO driver allows you to manage General Purpose I/O resources via simple and portable APIs. GPIO pin behavior is configured statically, but can also be reconfigured at runtime.
Note: If you add only a GPIO to a configuration, you will need to manually add either Board or Power to generate the correct templates due to a circular dependency issue.
GPIO.gpioImplementation = 'GPIOWFF3'; | // GPIO Implementation |
GPIO.interruptPriority = '15'; | // Interrupt Priority |
inst.$name = 'CONFIG_GPIO_{num}'; | // Name |
inst.mode = 'Input'; | // Mode |
inst.outputStrength = 'Low'; | // Output Strength |
inst.initialOutputState = 'Low'; | // Initial Output State |
inst.pull = 'None'; | // Pull |
inst.interruptTrigger = 'None'; | // Interrupt Trigger |
inst.doNotConfig = false; | // Do Not Configure |
inst.alternativeMux = 'None'; | // Alternative Mux |
inst.irq = ''; | // GPIO uses interruptTrigger instead of irq |
inst.parentSignalName = ''; | // Parent Signal Name |
inst.parentInterfaceName = ''; | // Parent Interface Name |
inst.parentSignalDisplayName = ''; | // Parent Signal Display Name |
GPIO Implementation
[GPIO.gpioImplementation = 'GPIOWFF3']
|
Displays GPIO delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'GPIOWFF3' | |
Interrupt Priority
[GPIO.interruptPriority = '15']
|
This configuration allows you to configure the hardware interrupt priority.
Valid options include the following:
'15' | 15 - Lowest Priority | |
'14' | | |
'13' | | |
'12' | | |
'11' | | |
'10' | | |
'9' | | |
'8' | | |
'7' | | |
'6' | | |
'5' | | |
'4' | | |
'3' | | |
'2' | | |
'1' | 1 - Highest Priority |
This name is declared in the generated ti_drivers_config.h file so applications can reference this instance symbolically. Additionally, this name is used to declare an 'extern const' which allows libraries to define symbolic names for required driver configurations without needing to rebuild library source files. The 'const' identifier is declared as the same name with a _CONST suffix. The name can be set to any globally unique name that is also a valid C/C++ identifier.
The SysConfig tooling ensures that all names defined in a configuration are unique. When instances are first created, SysConfig gives them a default name, CONFIG_GPIO_, that's made unique by appending a numeric id. If you provide a name, it's checked against all other instance names in the configuration and, if another instance has the same name, an error is triggered. The additional 'const' declaration is assumed to also be globally unique.
Note: since not all names are added to ti_drivers_config.h, it's possible that some names will not be allowed even though they do not actually collide in the generated files.
The mode configuration parameter is used to determine the initial state of GPIO, eliminating the need to configure the GPIO pin at runtime prior to using it.
Valid options include the following:
'Input' | | - This GPIO is initially configured for input |
'Output' | | - This GPIO is initially configured for output |
Output Strength
[inst.outputStrength = 'Low']
|
This specifies the output strength for the GPIO. Not all GPIOs necessarily support controlling the drive strength. Please consult the technical reference manual and the device-specific datasheet for individual I/O output strength capability.
Valid options include the following:
'High' | | |
'Low' | |
Initial Output State
[inst.initialOutputState = 'Low']
|
This specifies if an output will be driven high or low after GPIO_init().
Valid options include the following:
'High' | | |
'Low' | |
Pull
[inst.pull = 'None']
|
Valid options include the following:
'None' | | |
'Pull Up' | | |
'Pull Down' | |
Interrupt Trigger
[inst.interruptTrigger = 'None']
|
This parameter configures when the GPIO pin interrupt will trigger. Even when this config is set, interrupts are not enabled until
GPIO_enableInt() is called at runtime.
Valid options include the following:
'None' | | |
'High' | | |
'Low' | | |
'Falling Edge' | | |
'Rising Edge' | | |
'High' | | |
'Low' | |
Do Not Configure
[inst.doNotConfig = false]
|
Alternative Mux
[inst.alternativeMux = 'None']
|
This options is for users wanting to interface with a non-GPIO peripheral, such as a UART or SPI, without using the TI provided peripheral driver, such as the UART2 or SPI driver respectively.
However, it is recommended to select "None" and use the relevant TI provided peripheral driver and associated SysConfig module to configure the pin muxing, unless you have a specific need.
When an option other than "None" is selected, SysConfig will only allow you to
select DIOs which support the selected mux option.
Additionally SysConfig will generate a define named <instance name>_ALT_MUX
where the value is the mux value to be passed by the application to the
GPIO_setConfigAndMux()
function and where <instance name> is the name of the GPIO instance.
Note, when the value of this config is changed to a different peripheral, any assigned pin in the PinMux settings for this GPIO instance will be lost, and you will need to reassign the pin in the PinMux settings.
Valid options include the following:
'None' | | |
'ADC0' | | |
'ADC1' | | |
'ADC2' | | |
'ADC3' | | |
'ADC4' | | |
'ADC5' | | |
'ADC6' | | |
'ADC7' | | |
'ADCTRG' | | |
'ANT_SEL_0' | | |
'ANT_SEL_1' | | |
'ANT_SEL_2' | | |
'ANT_SEL_3' | | |
'BLE_RFC_GPI_1' | | |
'BLE_RFC_GPI_2' | | |
'BLE_RFC_GPI_3' | | |
'BLE_RFC_GPO_4' | | |
'BLE_RFC_GPO_5' | | |
'BLE_RFC_GPO_6' | | |
'BLE_RFC_GPO_7' | | |
'BLE_RFTRC' | | |
'CCA' | | |
'COEX_GRANT' | | |
'COEX_PRIORITY' | | |
'COEX_REQ' | | |
'DCAN_RX' | | |
'DCAN_TX' | | |
'DEBUG_BUS_0' | | |
'DEBUG_BUS_1' | | |
'DEBUG_BUS_10' | | |
'DEBUG_BUS_11' | | |
'DEBUG_BUS_12' | | |
'DEBUG_BUS_13' | | |
'DEBUG_BUS_14' | | |
'DEBUG_BUS_15' | | |
'DEBUG_BUS_2' | | |
'DEBUG_BUS_3' | | |
'DEBUG_BUS_4' | | |
'DEBUG_BUS_5' | | |
'DEBUG_BUS_6' | | |
'DEBUG_BUS_7' | | |
'DEBUG_BUS_8' | | |
'DEBUG_BUS_9' | | |
'DEBUG_BUS_CLK' | | |
'DIGITAL_FAST_CLK_IN' | | |
'DRIVE0' | | |
'DRIVE1' | | |
'EXT_CLK' | | |
'FAST_CLK_REQ' | | |
'GPT0_0' | | |
'GPT0_0N' | | |
'GPT0_1' | | |
'GPT0_1N' | | |
'GPT0_2' | | |
'GPT0_2N' | | |
'GPT0_3' | | |
'GPT0_3N' | | |
'GPT0_PREEVENT' | | |
'GPT_INFRARED' | | |
'GPT1_0' | | |
'GPT1_0N' | | |
'GPT1_1' | | |
'GPT1_1N' | | |
'GPT1_2' | | |
'GPT1_2N' | | |
'GPT1_3' | | |
'GPT1_3N' | | |
'GPT1_PREEVENT' | | |
'HI-Z_(INPUT)' | | |
'I2C0_CLK' | | |
'I2C0_DATA' | | |
'I2C1_CLK' | | |
'I2C1_DATA' | | |
'I2S_BCLK' | | |
'I2S_DATA0' | | |
'I2S_DATA1' | | |
'I2S_MCLK' | | |
'I2S_WCLK' | | |
'JTAG_TCK' | | |
'JTAG_TDI' | | |
'JTAG_TDO' | | |
'JTAG_TMS' | | |
'LFXT_N' | | |
'LOGGER' | | |
'PDM_BCLK' | | |
'PDM_DATA0' | | |
'PDM_DATA1' | | |
'SD_CD' | | |
'SD_CLK' | | |
'SD_CMD' | | |
'SD_DATA_0' | | |
'SD_DATA_1' | | |
'SD_DATA_2' | | |
'SD_DATA_3' | | |
'SD_DATA_4' | | |
'SD_DATA_5' | | |
'SD_DATA_6' | | |
'SD_DATA_7' | | |
'SD_POW1' | | |
'SD_POW2' | | |
'SD_WP' | | |
'SDIO_CLK' | | |
'SDIO_CMD' | | |
'SDIO_D0' | | |
'SDIO_D1' | | |
'SDIO_D2' | | |
'SDIO_D3' | | |
'SDIO_OOB_IRQ' | | |
'SPI0_CLK' | | |
'SPI0_CS1' | | |
'SPI0_CS2' | | |
'SPI0_CS3' | | |
'SPI0_CS4' | | |
'SPI0_MISO' | | |
'SPI0_MOSI' | | |
'SPI1_CLK' | | |
'SPI1_CS1' | | |
'SPI1_CS2' | | |
'SPI1_CS3' | | |
'SPI1_CS4' | | |
'SPI1_MISO' | | |
'SPI1_MOSI' | | |
'SWCLK' | | |
'SWDIO' | | |
'SWO_M3' | | |
'SWO_M33' | | |
'TRCLK' | | |
'TRDATA_0' | | |
'TRDATA_1' | | |
'TRDATA_2' | | |
'TRDATA_3' | | |
'UART0_CTS' | | |
'UART0_RTS' | | |
'UART0_RX' | | |
'UART0_TX' | | |
'UART_RS232_RX' | | |
'UART_RS232_TX' | | |
'UART1_CTS' | | |
'UART1_RTS' | | |
'UART1_RX' | | |
'UART1_TX' | | |
'WAKE_OBSERVE_BUS_0' | | |
'WAKE_OBSERVE_BUS_1' | | |
'WAKE_OBSERVE_BUS_10' | | |
'WAKE_OBSERVE_BUS_11' | | |
'WAKE_OBSERVE_BUS_12' | | |
'WAKE_OBSERVE_BUS_13' | | |
'WAKE_OBSERVE_BUS_14' | | |
'WAKE_OBSERVE_BUS_15' | | |
'WAKE_OBSERVE_BUS_2' | | |
'WAKE_OBSERVE_BUS_3' | | |
'WAKE_OBSERVE_BUS_4' | | |
'WAKE_OBSERVE_BUS_5' | | |
'WAKE_OBSERVE_BUS_6' | | |
'WAKE_OBSERVE_BUS_7' | | |
'WAKE_OBSERVE_BUS_8' | | |
'WAKE_OBSERVE_BUS_9' | | |
'XSPI_CLK' | | |
'XSPI_CSFLASH' | | |
'XSPI_CSRAM' | | |
'XSPI_DATA0' | | |
'XSPI_DATA1' | | |
'XSPI_DATA2' | | |
'XSPI_DATA3' | | |
'XSPI_DATA4' | | |
'XSPI_DATA5' | | |
'XSPI_DATA6' | | |
'XSPI_DATA7' | | |
'XSPI_DQS' | | |
'XSPI_RESETFLASH' | | |
'XSPI_RESETRAM' | |
GPIO uses interruptTrigger instead of irq
[inst.irq = '']
|
Parent Signal Name
[inst.parentSignalName = '']
|
Parent Interface Name
[inst.parentInterfaceName = '']
|
Parent Signal Display Name
[inst.parentSignalDisplayName = '']
|
The Timer driver allows you to manage a GPTimer peripheral via simple and portable APIs.
GPTimer.gptimerImplementation = 'GPTimerWFF3'; | // GPTimer Implementation |
inst.$name = 'CONFIG_GPTIMER_{num}'; | // Name |
inst.interruptPriority = '15'; | // Interrupt Priority |
inst.channel0Connection = 'Internal'; | // Channel 0 Connection |
inst.channel1Connection = 'Internal'; | // Channel 1 Connection |
inst.channel2Connection = 'Internal'; | // Channel 2 Connection |
inst.channel3Connection = 'Internal'; | // Channel 3 Connection |
inst.channel0NConnection = 'Internal'; | // Complementary Channel 0 Connection |
inst.channel1NConnection = 'Internal'; | // Complementary Channel 1 Connection |
inst.channel2NConnection = 'Internal'; | // Complementary Channel 2 Connection |
inst.channel3NConnection = 'Internal'; | // Complementary Channel 3 Connection |
GPTimer Implementation
[GPTimer.gptimerImplementation = 'GPTimerWFF3']
|
Displays GPTimer delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'GPTimerWFF3' | |
This name is declared in the generated ti_drivers_config.h file so applications can reference this instance symbolically. Additionally, this name is used to declare an 'extern const' which allows libraries to define symbolic names for required driver configurations without needing to rebuild library source files. The 'const' identifier is declared as the same name with a _CONST suffix. The name can be set to any globally unique name that is also a valid C/C++ identifier.
The SysConfig tooling ensures that all names defined in a configuration are unique. When instances are first created, SysConfig gives them a default name, CONFIG_GPTIMER_, that's made unique by appending a numeric id. If you provide a name, it's checked against all other instance names in the configuration and, if another instance has the same name, an error is triggered. The additional 'const' declaration is assumed to also be globally unique.
Note: since not all names are added to ti_drivers_config.h, it's possible that some names will not be allowed even though they do not actually collide in the generated files.
Interrupt Priority
[inst.interruptPriority = '15']
|
This configuration allows you to configure the hardware interrupt priority.
Valid options include the following:
'15' | 15 - Lowest Priority | |
'14' | | |
'13' | | |
'12' | | |
'11' | | |
'10' | | |
'9' | | |
'8' | | |
'7' | | |
'6' | | |
'5' | | |
'4' | | |
'3' | | |
'2' | | |
'1' | 1 - Highest Priority |
Channel 0 Connection
[inst.channel0Connection = 'Internal']
|
Valid options include the following:
'Internal' | | |
'Pin' | |
Channel 1 Connection
[inst.channel1Connection = 'Internal']
|
Valid options include the following:
'Internal' | | |
'Pin' | |
Channel 2 Connection
[inst.channel2Connection = 'Internal']
|
Valid options include the following:
'Internal' | | |
'Pin' | |
Channel 3 Connection
[inst.channel3Connection = 'Internal']
|
Valid options include the following:
'Internal' | | |
'Pin' | |
Complementary Channel 0 Connection
[inst.channel0NConnection = 'Internal']
|
Valid options include the following:
'Internal' | | |
'Pin' | |
Complementary Channel 1 Connection
[inst.channel1NConnection = 'Internal']
|
Valid options include the following:
'Internal' | | |
'Pin' | |
Complementary Channel 2 Connection
[inst.channel2NConnection = 'Internal']
|
Valid options include the following:
'Internal' | | |
'Pin' | |
Complementary Channel 3 Connection
[inst.channel3NConnection = 'Internal']
|
Valid options include the following:
'Internal' | | |
'Pin' | |
The Power driver facilitates the transition of the MCU from active states to one of the sleep states and vice versa. The Power driver enables the other driver modules to minimize power consumption. In addition, applications can set or release power constraints to prevent the MCU from transitioning into a particular sleep state.
Power.powerImplementation = 'PowerWFF3'; | // Power Implementation |
Power.policyFunction = 'PowerWFF3_sleepPolicy'; | // Policy Function |
Power.policyCustomFunction = 'customPolicyFxn'; | // Custom Policy Function |
Power.policyInitFunction = 'Not Required'; | // Policy Init Function |
Power.policyInitCustomFunction = 'customPolicyInitFxn'; | // Custom Policy Init Function |
Power.loggingEnabled = false; | // Enable Logging |
Power Implementation
[Power.powerImplementation = 'PowerWFF3']
|
Displays Power delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'PowerWFF3' | |
Policy Function
[Power.policyFunction = 'PowerWFF3_sleepPolicy']
|
When enabled, this function is invoked in the idle loop, to opportunistically select and activate sleep states.
Two reference policies are provided:
In addition to this static selection, the Power Policy can be dynamically changed at runtime, via the Power_setPolicy() API.
Valid options include the following:
'PowerWFF3_sleepPolicy' | | - An aggressive policy that checks constraints and time until next scheduled work, and optionally chooses SLEEP, IDLE (power down), or WFI, in that order of preference. |
'PowerWFF3_doWFI' | | - A simple policy that will invoke CPU wait for interrupt (WFI). |
'Custom' | | - Custom policies can be written and specified via configuration of a Custom Policy Function. |
Custom Policy Function
[Power.policyCustomFunction = 'customPolicyFxn']
|
Policy Init Function
[Power.policyInitFunction = 'Not Required']
|
Valid options include the following:
'Not Required' | | - The selected Policy Function does not require an Init function. |
'Custom' | | - A custom initialization function can be written and specified via configuration of a Custom Policy Init Function. |
Custom Policy Init Function
[Power.policyInitCustomFunction = 'customPolicyInitFxn']
|
Enable Logging
[Power.loggingEnabled = false]
|
The PWM driver allows you to generate Pulse Width Modulated signals via simple and portable APIs.
PWM.pwmImplementation = 'PWMTimerWFF3'; | // PWM Implementation |
inst.$name = 'CONFIG_PWM_{num}'; | // Name |
inst.prescalerDivider = 1; | // Timer Prescaler Divider |
PWM Implementation
[PWM.pwmImplementation = 'PWMTimerWFF3']
|
Displays PWM delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'PWMTimerWFF3' | |
This name is declared in the generated ti_drivers_config.h file so applications can reference this instance symbolically. Additionally, this name is used to declare an 'extern const' which allows libraries to define symbolic names for required driver configurations without needing to rebuild library source files. The 'const' identifier is declared as the same name with a _CONST suffix. The name can be set to any globally unique name that is also a valid C/C++ identifier.
The SysConfig tooling ensures that all names defined in a configuration are unique. When instances are first created, SysConfig gives them a default name, CONFIG_PWM_, that's made unique by appending a numeric id. If you provide a name, it's checked against all other instance names in the configuration and, if another instance has the same name, an error is triggered. The additional 'const' declaration is assumed to also be globally unique.
Note: since not all names are added to ti_drivers_config.h, it's possible that some names will not be allowed even though they do not actually collide in the generated files.
Timer Prescaler Divider
[inst.prescalerDivider = 1]
|
The prescaler of the underlying timer can divide the incoming system clock to the timer counter forcing an extended PWM signal period with decreased precision. A value of 1 means division by 1. Division factor = value. Min. value is 1. Max. value is 256.
The Watchdog driver allows you to configure the system watchdog. A watchdog timer is used to reset the system if it has become unresponsive. Parameters such as reset behavior and the callback function can be configured at runtime.
Watchdog.watchdogImplementation = 'WatchdogWFF3'; | // Watchdog Implementation |
inst.period = 1000; | // Period |
Watchdog Implementation
[Watchdog.watchdogImplementation = 'WatchdogWFF3']
|
Displays Watchdog delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'WatchdogWFF3' | |
Period
[inst.period = 1000]
|
The period has a resolution of 7.8125 ms, which imposes limitations on achieving certain exact values. When a requested period cannot be precisely implemented, the system will automatically adjust to the nearest possible value within the resolution and report this adjusted period. For instance, if a period of 22 ms is specified, the actual implemented period will be 23.4375 ms.
The I2C driver provides a portable application interface to access peripherals on an I2C bus.
I2C.i2cImplementation = 'I2CWFF3'; | // I2C Implementation |
inst.$name = 'CONFIG_I2C_{num}'; | // Name |
inst.maxBitRate = 0; | // Maximum Bit Rate |
inst.ignoreUnusedAddressConflicts = false; | // Ignore Unused Address Conflicts |
inst.addressChecks = 'Fail'; | // Address Checks |
inst.speedChecks = 'Fail'; | // Speed Checks |
inst.interruptPriority = '15'; | // Interrupt Priority |
inst.softwareInterruptPriority = '0'; | // Software Interrupt Priority |
I2C Implementation
[I2C.i2cImplementation = 'I2CWFF3']
|
Displays I2C delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'I2CWFF3' | |
This name is declared in the generated ti_drivers_config.h file so applications can reference this instance symbolically. Additionally, this name is used to declare an 'extern const' which allows libraries to define symbolic names for required driver configurations without needing to rebuild library source files. The 'const' identifier is declared as the same name with a _CONST suffix. The name can be set to any globally unique name that is also a valid C/C++ identifier.
The SysConfig tooling ensures that all names defined in a configuration are unique. When instances are first created, SysConfig gives them a default name, CONFIG_I2C_, that's made unique by appending a numeric id. If you provide a name, it's checked against all other instance names in the configuration and, if another instance has the same name, an error is triggered. The additional 'const' declaration is assumed to also be globally unique.
Note: since not all names are added to ti_drivers_config.h, it's possible that some names will not be allowed even though they do not actually collide in the generated files.
Maximum Bit Rate
[inst.maxBitRate = 0]
|
This parameter determines the value of a 'maximum bitrate' symbol declared in the generated ti_drivers_config.h file. This symbol can be used in code to portably open the bus at a speed that's likely to work. This is because the parameter is rounded down to the nearest bit rate supported by the hardware.
If this configuration parameter is set to zero, the maximum speed for this instance is the maximum speed supported by the slowest attached target. If no target devices are attached, the maximum bit rate is 100 kbps.
The symbol is named (instance name)_MAXBITRATE.
Ignore Unused Address Conflicts
[inst.ignoreUnusedAddressConflicts = false]
|
Address Checks
[inst.addressChecks = 'Fail']
|
By default, SysConfig triggers an error if two or more devices in this bus have the same address. You can override this error by setting this configuration parameter to either 'Warn' or 'Remark'.
Valid options include the following:
'Fail' | | - Trigger an error if two or more devices in the bus have the same address |
'Warn' | | - Warn if two or more devices on the bus have the same address |
'Remark' | | - Emit a remark if two or more devices on the bus have the same address |
Speed Checks
[inst.speedChecks = 'Fail']
|
By default, SysConfig triggers an error if a target device on the bus has a maximum speed below the maximum bit rate specified for the bus. You can override this error by setting this configuration parameter to either 'Warn' or 'Remark'.
Valid options include the following:
'Fail' | | - Trigger an error if the bus speed exceeds a target's maximum speed |
'Warn' | | - Warn if the bus speed exceeds any target's maximum speed |
'Remark' | | - Emit a remark if the bus speed exceeds a target's maximum speed |
Interrupt Priority
[inst.interruptPriority = '15']
|
This configuration allows you to configure the hardware interrupt priority.
Valid options include the following:
'15' | 15 - Lowest Priority | |
'14' | | |
'13' | | |
'12' | | |
'11' | | |
'10' | | |
'9' | | |
'8' | | |
'7' | | |
'6' | | |
'5' | | |
'4' | | |
'3' | | |
'2' | | |
'1' | 1 - Highest Priority |
Software Interrupt Priority
[inst.softwareInterruptPriority = '0']
|
This configuration allows you to configure the software interrupt priority.
Valid options include the following:
'0' | 0 - Lowest Priority | |
'1' | | |
'2' | | |
'3' | | |
'4' | | |
'5' | | |
'6' | | |
'7' | | |
'8' | | |
'9' | | |
'10' | | |
'11' | | |
'12' | | |
'13' | | |
'14' | | |
'15' | 15 - Highest Priority |
The I2S driver provides a simplified application interface to access peripherals on an I2S bus.
I2S.i2sImplementation = 'I2SWFF3'; | // I2S Implementation |
inst.$name = 'CONFIG_I2S_{num}'; | // Name |
inst.interruptPriority = '15'; | // Hardware Interrupt Priority |
inst.sd1DataDirection = 'Input'; | // SD1 Data Direction |
inst.sd0DataDirection = 'Output'; | // SD0 Data Direction |
inst.enableCCLK = false; | // Enable CCLK |
inst.clkSrc = 'I2SWFF3_CLK_SRC_SOC_PLL_CLK'; | // Clock Source |
inst.audioClkFreq = 'I2SWFF3_ACLK_12P288MHZ'; | // Audio Clock Frequency |
I2S Implementation
[I2S.i2sImplementation = 'I2SWFF3']
|
Displays I2S delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'I2SWFF3' | |
This name is declared in the generated ti_drivers_config.h file so applications can reference this instance symbolically. Additionally, this name is used to declare an 'extern const' which allows libraries to define symbolic names for required driver configurations without needing to rebuild library source files. The 'const' identifier is declared as the same name with a _CONST suffix. The name can be set to any globally unique name that is also a valid C/C++ identifier.
The SysConfig tooling ensures that all names defined in a configuration are unique. When instances are first created, SysConfig gives them a default name, CONFIG_I2S_, that's made unique by appending a numeric id. If you provide a name, it's checked against all other instance names in the configuration and, if another instance has the same name, an error is triggered. The additional 'const' declaration is assumed to also be globally unique.
Note: since not all names are added to ti_drivers_config.h, it's possible that some names will not be allowed even though they do not actually collide in the generated files.
Hardware Interrupt Priority
[inst.interruptPriority = '15']
|
This configuration allows you to configure the hardware interrupt priority.
Valid options include the following:
'15' | 15 - Lowest Priority | |
'14' | | |
'13' | | |
'12' | | |
'11' | | |
'10' | | |
'9' | | |
'8' | | |
'7' | | |
'6' | | |
'5' | | |
'4' | | |
'3' | | |
'2' | | |
'1' | 1 - Highest Priority |
SD1 Data Direction
[inst.sd1DataDirection = 'Input']
|
May also be referred to as the AD or McAXR.
Valid options include the following:
'Input' | | |
'Output' | | |
'Disabled' | |
SD0 Data Direction
[inst.sd0DataDirection = 'Output']
|
May also be referred to as the AD or McAXR
Valid options include the following:
'Input' | | |
'Output' | | |
'Disabled' | |
Enable CCLK
[inst.enableCCLK = false]
|
Clock Source
[inst.clkSrc = 'I2SWFF3_CLK_SRC_SOC_PLL_CLK']
|
This option selects the input clock to the ADFS. This clock is used to generate the audio clock (ACLK). For details on which clock source to select, please refer to Selecting the Clock Source.
Valid options include the following:
'I2SWFF3_CLK_SRC_SOC_CLK' | SOC clock | - 80 MHz |
'I2SWFF3_CLK_SRC_SOC_PLL_CLK' | SOC PLL clock | - 160 MHz |
'I2SWFF3_CLK_SRC_HFXT_CLK' | HFXT clock | - 52 MHz |
Audio Clock Frequency
[inst.audioClkFreq = 'I2SWFF3_ACLK_12P288MHZ']
|
This option selects the audio clock (ACLK) frequency. For details on which frequency to select, please refer to Selecting the Audio Clock Frequency.
Valid options include the following:
'I2SWFF3_ACLK_11P2896MHZ' | 11.2896 MHz | - Suitable for sample rates of 22.05 kHz and 44.1 kHz. |
'I2SWFF3_ACLK_12P288MHZ' | 12.288 MHz | - Suitable for sample rates of 8 kHz, 16 kHz, 24 kHz, 32 kHz and 48 kHz. |
'I2SWFF3_ACLK_CLK_SRC_FREQ' | Clock source frequency | - Not intended for any standard sample rate, but it can still be selected if desired. |
The ITM driver interfaces to the hardware module with the same name. ITM provides a memory-mapped register interface that applications can use to write logging or event words to a trace sink such as the TPIU.
ITM.itmImplementation = 'ITMWFF3'; | // ITM Implementation |
ITM.tpiuSerialFormat = 'ITM_TPIU_SWO_UART'; | // TPIU Serial Format |
ITM.baudRate = 12000000; | // Baud Rate |
ITM.traceEnable = 4294967295; | // Trace Enable |
ITM.fullPacketInCycles = 96; | // Full Packet In Cycles |
ITM.tpiuPrescaler = 2; | // TPIU Prescaler Register Value |
ITM Implementation
[ITM.itmImplementation = 'ITMWFF3']
|
Displays ITM delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'ITMWFF3' | |
TPIU Serial Format
[ITM.tpiuSerialFormat = 'ITM_TPIU_SWO_UART']
|
Valid options include the following:
'ITM_TPIU_SWO_MANCHESTER' | Manchester | |
'ITM_TPIU_SWO_UART' | UART |
Baud Rate
[ITM.baudRate = 12000000]
|
Trace Enable
[ITM.traceEnable = 4294967295]
|
Full Packet In Cycles
[ITM.fullPacketInCycles = 96]
|
TPIU Prescaler Register Value
[ITM.tpiuPrescaler = 2]
|
The SPI driver provides a portable application interface to control onboard Serial Peripheral Interfaces (SPI).
SPI.spiImplementation = 'SPIWFF3DMA'; | // SPI Implementation |
inst.$name = 'CONFIG_SPI_{num}'; | // Name |
inst.mode = 'Three Pin'; | // Mode |
inst.defaultTxBufferValue = '~0'; | // Default TX Buffer Value |
inst.minDmaTransferSize = 10; | // Min DMA Transfer Size |
inst.duplex = 'Full'; | // Duplex |
inst.dmaInterruptPriority = '15'; | // Interrupt Priority |
inst.softwareInterruptPriority = '0'; | // Software Interrupt Priority |
SPI Implementation
[SPI.spiImplementation = 'SPIWFF3DMA']
|
Displays SPI delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'SPIWFF3DMA' | |
This name is declared in the generated ti_drivers_config.h file so applications can reference this instance symbolically. Additionally, this name is used to declare an 'extern const' which allows libraries to define symbolic names for required driver configurations without needing to rebuild library source files. The 'const' identifier is declared as the same name with a _CONST suffix. The name can be set to any globally unique name that is also a valid C/C++ identifier.
The SysConfig tooling ensures that all names defined in a configuration are unique. When instances are first created, SysConfig gives them a default name, CONFIG_SPI_, that's made unique by appending a numeric id. If you provide a name, it's checked against all other instance names in the configuration and, if another instance has the same name, an error is triggered. The additional 'const' declaration is assumed to also be globally unique.
Note: since not all names are added to ti_drivers_config.h, it's possible that some names will not be allowed even though they do not actually collide in the generated files.
In Three Pin mode, the user is responsible for controlling the chip select line.
Valid options include the following:
'Three Pin' | | |
'Four Pin CS Active Low' | | |
'Four Pin CS Active High' | |
Default TX Buffer Value
[inst.defaultTxBufferValue = '~0']
|
Value sent when a TX buffer is not specified. This value must be provided in hexadecimal format; 0 and ~0 are also acceptable inputs.
Min DMA Transfer Size
[inst.minDmaTransferSize = 10]
|
Duplex
[inst.duplex = 'Full']
|
In a typical SPI transfer, both participants transmit and receive at the same time (full duplex) but in some situations only one side will ever transmit and the other side may only need to receive. In these cases some pins can stay unassigned. If full duplex is not required, the user may select the role of this SPI.
Valid options include the following:
'Full' | | |
'Controller TX Only' | | |
'Controller RX Only' | | |
'Peripheral TX Only' | | |
'Peripheral RX Only' | |
Interrupt Priority
[inst.dmaInterruptPriority = '15']
|
This configuration allows you to configure the hardware interrupt priority.
Valid options include the following:
'15' | 15 - Lowest Priority | |
'14' | | |
'13' | | |
'12' | | |
'11' | | |
'10' | | |
'9' | | |
'8' | | |
'7' | | |
'6' | | |
'5' | | |
'4' | | |
'3' | | |
'2' | | |
'1' | 1 - Highest Priority |
Software Interrupt Priority
[inst.softwareInterruptPriority = '0']
|
This configuration allows you to configure the software interrupt priority.
Valid options include the following:
'0' | 0 - Lowest Priority | |
'1' | | |
'2' | | |
'3' | | |
'4' | | |
'5' | | |
'6' | | |
'7' | | |
'8' | | |
'9' | | |
'10' | | |
'11' | | |
'12' | | |
'13' | | |
'14' | | |
'15' | 15 - Highest Priority |
The UART2 driver provides device independent APIs for reading and writing to the UART peripherals.
UART2.uart2Implementation = 'UART2WFF3'; | // UART2 Implementation |
UART2.loggingEnabled = false; | // Enable Logging |
inst.$name = 'CONFIG_UART2_{num}'; | // Name |
inst.baudRates = 115200; | // Baud Rates |
inst.enableNonblocking = true; | // Enable Nonblocking Mode |
inst.dataDirection = 'Send and Receive'; | // Data Direction |
inst.flowControl = false; | // Flow Control |
inst.interruptPriority = '15'; | // Interrupt Priority |
inst.rxRingBufferSize = 32; | // RX Ring Buffer Size |
inst.txRingBufferSize = 32; | // TX Ring Buffer Size |
inst.codingScheme = 'UART'; | // Coding/Decoding Scheme |
inst.SIRLPclockDivider = 26; | // LP-SIR Clock Divider |
inst.concatenateFIFOs = false; | // Concatenate RX And TX FIFO |
UART2 Implementation
[UART2.uart2Implementation = 'UART2WFF3']
|
Displays UART2 delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'UART2WFF3' | |
Enable Logging
[UART2.loggingEnabled = false]
|
With logging enabled a special version of the driver will be used.Log-statments are embedded in this driver version and it should only be used for debugging.This implies an overhead in both code size and runtime
This name is declared in the generated ti_drivers_config.h file so applications can reference this instance symbolically. Additionally, this name is used to declare an 'extern const' which allows libraries to define symbolic names for required driver configurations without needing to rebuild library source files. The 'const' identifier is declared as the same name with a _CONST suffix. The name can be set to any globally unique name that is also a valid C/C++ identifier.
The SysConfig tooling ensures that all names defined in a configuration are unique. When instances are first created, SysConfig gives them a default name, CONFIG_UART2_, that's made unique by appending a numeric id. If you provide a name, it's checked against all other instance names in the configuration and, if another instance has the same name, an error is triggered. The additional 'const' declaration is assumed to also be globally unique.
Note: since not all names are added to ti_drivers_config.h, it's possible that some names will not be allowed even though they do not actually collide in the generated files.
Baud Rates
[inst.baudRates = 115200]
|
Valid options include the following:
1200 | | |
2400 | | |
4800 | | |
9600 | | |
19200 | | |
38400 | | |
57600 | | |
115200 | | |
230400 | | |
460800 | | |
921600 | |
Enable Nonblocking Mode
[inst.enableNonblocking = true]
|
If your application does not use UART2_Mode_NONBLOCKING you can disable this mode.This will reduce both flash-size and RAM-usage for your application.
Data Direction
[inst.dataDirection = 'Send and Receive']
|
Valid options include the following:
'Send and Receive' | | |
'Send Only' | | |
'Receive Only' | |
Flow Control
[inst.flowControl = false]
|
Hardware flow control between two devices is accomplished by connecting the UART Request-To-Send (RTS) pin to the Clear-To-Send (CTS) input on the receiving device, and connecting the RTS output of the receiving device to the UART CTS pin
Interrupt Priority
[inst.interruptPriority = '15']
|
This configuration allows you to configure the hardware interrupt priority.
Valid options include the following:
'15' | 15 - Lowest Priority | |
'14' | | |
'13' | | |
'12' | | |
'11' | | |
'10' | | |
'9' | | |
'8' | | |
'7' | | |
'6' | | |
'5' | | |
'4' | | |
'3' | | |
'2' | | |
'1' | 1 - Highest Priority |
RX Ring Buffer Size
[inst.rxRingBufferSize = 32]
|
The RX ring buffer serves as an extension of the RX FIFO. If data is received when UART2_read() is not called, data will be stored in the RX ring buffer. The size can be changed to suit the application.
TX Ring Buffer Size
[inst.txRingBufferSize = 32]
|
The TX ring buffer serves as an extension of the TX FIFO. Data is written to the TX ring buffer when UART_write() is called. Data in the TX ring buffer is then copied by the DMA to the TX FIFO. The size can be changed to suit the application.
Coding/Decoding Scheme
[inst.codingScheme = 'UART']
|
UART: bits are encoded/decoded as standard UART bitstreamSerial Infrared: bits are encoded/decoded according to IrDA specification.
Valid options include the following:
'UART' | | |
'Serial Infrared' | | |
'Low-Power Serial Infrared' | |
LP-SIR Clock Divider
[inst.SIRLPclockDivider = 26]
|
Concatenate RX And TX FIFO
[inst.concatenateFIFOs = false]
|
The SDIO driver provides device independent APIs for I/F between hosts.
SDIO.sdioImplementation = 'SDIOWFF3'; | // SDIO Implementation |
inst.$name = 'CONFIG_SDIO_{num}'; | // Name |
inst.interruptPriority = '15'; | // Interrupt Priority |
inst.irqSignal = 'In-band'; | // IRQ Band |
inst.thresholdLen = 4; | // Rx Treshold Length |
SDIO Implementation
[SDIO.sdioImplementation = 'SDIOWFF3']
|
Displays SDIO delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'SDIOWFF3' | |
This name is declared in the generated ti_drivers_config.h file so applications can reference this instance symbolically. Additionally, this name is used to declare an 'extern const' which allows libraries to define symbolic names for required driver configurations without needing to rebuild library source files. The 'const' identifier is declared as the same name with a _CONST suffix. The name can be set to any globally unique name that is also a valid C/C++ identifier.
The SysConfig tooling ensures that all names defined in a configuration are unique. When instances are first created, SysConfig gives them a default name, CONFIG_SDIO_, that's made unique by appending a numeric id. If you provide a name, it's checked against all other instance names in the configuration and, if another instance has the same name, an error is triggered. The additional 'const' declaration is assumed to also be globally unique.
Note: since not all names are added to ti_drivers_config.h, it's possible that some names will not be allowed even though they do not actually collide in the generated files.
Interrupt Priority
[inst.interruptPriority = '15']
|
This configuration allows you to configure the hardware interrupt priority.
Valid options include the following:
'15' | 15 - Lowest Priority | |
'14' | | |
'13' | | |
'12' | | |
'11' | | |
'10' | | |
'9' | | |
'8' | | |
'7' | | |
'6' | | |
'5' | | |
'4' | | |
'3' | | |
'2' | | |
'1' | 1 - Highest Priority |
IRQ Band
[inst.irqSignal = 'In-band']
|
IRQ from SDIO peripheral to host could be done in 2 ways:
* In-band IRQ (ibi) - IRQ will be driven on data line 1
* Out-of-band IRQ (obi) - saperated pin for IRQ
IRQ implementation depend on the SDIO host and the customer board.
Valid options include the following:
'In-band' | | |
'Out-of-band' | |
Rx Treshold Length
[inst.thresholdLen = 4]
|
Rx FIFO is 256 bytes, it is two times the max block length.
There is a threshold IRQ on the Rx FIFO.
Threshold value must be divided by 4 and the max value is 128 bytes.
note: if the threshold is bigger than the expected recieved data that the IRQ
threshold will not rise.
The default value is 4 bytes, in this case for any recieved data the IRQ will rise.
The ADC driver allows you to manage an Analog to Digital peripheral via simple and portable APIs.
ADC.adcImplementation = 'ADCWFF3'; | // ADC Implementation |
inst.$name = 'CONFIG_ADC_{num}'; | // Name |
inst.adcFullScaleRange = 'ADCWFF3_FULL_SCALE_RANGE_0V0_3V3'; | // ADC Full Scale Range |
inst.adcSampleClockSource = 'ADCWFF3_SAMPLE_CLK_SOC_CLK'; | // ADC Sample Clock Source |
inst.adcClockDivider = 'ADCWFF3_CLKDIV_8'; | // ADC Clock Divider |
inst.adcSampleTime = 20; | // ADC Sample Duration |
ADC Implementation
[ADC.adcImplementation = 'ADCWFF3']
|
Displays ADC delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'ADCWFF3' | |
This name is declared in the generated ti_drivers_config.h file so applications can reference this instance symbolically. Additionally, this name is used to declare an 'extern const' which allows libraries to define symbolic names for required driver configurations without needing to rebuild library source files. The 'const' identifier is declared as the same name with a _CONST suffix. The name can be set to any globally unique name that is also a valid C/C++ identifier.
The SysConfig tooling ensures that all names defined in a configuration are unique. When instances are first created, SysConfig gives them a default name, CONFIG_ADC_, that's made unique by appending a numeric id. If you provide a name, it's checked against all other instance names in the configuration and, if another instance has the same name, an error is triggered. The additional 'const' declaration is assumed to also be globally unique.
Note: since not all names are added to ti_drivers_config.h, it's possible that some names will not be allowed even though they do not actually collide in the generated files.
ADC Full Scale Range
[inst.adcFullScaleRange = 'ADCWFF3_FULL_SCALE_RANGE_0V0_3V3']
|
Valid options include the following:
'ADCWFF3_FULL_SCALE_RANGE_0V0_3V3' | 0 V to 3.3 V | |
'ADCWFF3_FULL_SCALE_RANGE_0V1_3V3' | 0.1 V to 3.3 V | |
'ADCWFF3_FULL_SCALE_RANGE_0V0_3V2' | 0 V to 3.2 V | |
'ADCWFF3_FULL_SCALE_RANGE_0V0_1V8' | 0 V to 1.8 V |
ADC Sample Clock Source
[inst.adcSampleClockSource = 'ADCWFF3_SAMPLE_CLK_SOC_CLK']
|
Valid options include the following:
'ADCWFF3_SAMPLE_CLK_SOC_CLK' | SOC clock | - 80 MHz |
'ADCWFF3_SAMPLE_CLK_HFXT' | HFXT clock | - 40 MHz |
'ADCWFF3_SAMPLE_CLK_SOC_PLL_CLK_DIV' | SOC PLL clock | - 80 MHz |
ADC Clock Divider
[inst.adcClockDivider = 'ADCWFF3_CLKDIV_8']
|
This option, along with the ADC sample duration must ensure a minimum sampling time of 500 ns if using an external reference source or 1000 ns if using an internal reference source.
Valid options include the following:
'ADCWFF3_CLKDIV_1' | 1 | |
'ADCWFF3_CLKDIV_2' | 2 | |
'ADCWFF3_CLKDIV_4' | 4 | |
'ADCWFF3_CLKDIV_8' | 8 | |
'ADCWFF3_CLKDIV_16' | 16 | |
'ADCWFF3_CLKDIV_24' | 24 | |
'ADCWFF3_CLKDIV_32' | 32 | |
'ADCWFF3_CLKDIV_48' | 48 |
ADC Sample Duration
[inst.adcSampleTime = 20]
|
This option, along with the ADC clock divider must ensure a minimum sampling time of 500 ns if using an external reference source or 1000 ns if using an internal reference source.
The SD driver provides a simple interface to perform basic operations on SD cards.
SD.sdImplementation = 'SDWFF3'; | // SD Implementation |
inst.$name = 'CONFIG_SD_{num}'; | // Name |
inst.interruptPriority = '15'; | // Interrupt Priority |
inst.numOfDataLines = '1 Pins'; | // Number Of Data Lines |
inst.busFreq = '20MHz'; | // Card Bus Frequency |
inst.CardDetect = 'Disable'; | // Card Detect Functionality |
inst.WriteProtect = 'Disable'; | // Write Protect Functionality |
inst.powerSignal = 'Disable'; | // Power Indication Functionality |
SD Implementation
[SD.sdImplementation = 'SDWFF3']
|
Displays SD delegates available for the CC3500 device.
Since there is only one delegate, it is a read-only value that cannot be changed. Please refer to the TI-Drivers implementation matrix for all available drivers and documentation.
Valid options include the following:
'SDWFF3' | |
This name is declared in the generated ti_drivers_config.h file so applications can reference this instance symbolically. Additionally, this name is used to declare an 'extern const' which allows libraries to define symbolic names for required driver configurations without needing to rebuild library source files. The 'const' identifier is declared as the same name with a _CONST suffix. The name can be set to any globally unique name that is also a valid C/C++ identifier.
The SysConfig tooling ensures that all names defined in a configuration are unique. When instances are first created, SysConfig gives them a default name, CONFIG_SD_, that's made unique by appending a numeric id. If you provide a name, it's checked against all other instance names in the configuration and, if another instance has the same name, an error is triggered. The additional 'const' declaration is assumed to also be globally unique.
Note: since not all names are added to ti_drivers_config.h, it's possible that some names will not be allowed even though they do not actually collide in the generated files.
Interrupt Priority
[inst.interruptPriority = '15']
|
This configuration allows you to configure the hardware interrupt priority.
Valid options include the following:
'15' | 15 - Lowest Priority | |
'14' | | |
'13' | | |
'12' | | |
'11' | | |
'10' | | |
'9' | | |
'8' | | |
'7' | | |
'6' | | |
'5' | | |
'4' | | |
'3' | | |
'2' | | |
'1' | 1 - Highest Priority |
Number Of Data Lines
[inst.numOfDataLines = '1 Pins']
|
Valid options include the following:
'1 Pins' | | |
'4 Pins' | |
Card Bus Frequency
[inst.busFreq = '20MHz']
|
The clock frequency that provided to the SD card
Valid options include the following:
'10MHz' | | |
'20MHz' | | |
'40MHz' | |
Card Detect Functionality
[inst.CardDetect = 'Disable']
|
Define if card-detection (CD) functionality is enabled, Depende on the card slot.
'Disable': The card slot doesn't supply CD indication
'Enable Active High': Card slot supply CD indication
* High - card connected
* Low - card disconnected
'Enable Active Low' : Card slot supply CD indication
* High - card disconnected
* Low - card connected
Valid options include the following:
'Disable' | | |
'Enable Active High' | | |
'Enable Active Low' | |
Write Protect Functionality
[inst.WriteProtect = 'Disable']
|
Define if write-protection (WP) functionality is enabled, Depende on the card.
'Disable': The card doesn't supply WP indication
'Enable Active High': Card supply WP indication
* High - Write disabled
* Low - Write ensabled
'Enable Active Low' : Card supply WP indication
* High - Write ensabled
* Low - Write disabled
Valid options include the following:
'Disable' | | |
'Enable Active High' | | |
'Enable Active Low' | |
Power Indication Functionality
[inst.powerSignal = 'Disable']
|
This feature controls the power supply to the SD card through a dedicated pad, providing different power management options: Options: Disable - Power is continuously supplied directly to the SD card No ability to disconnect power SD card remains powered at all times Enable, Turn-Off Sleep - Power to the SD card is automatically cut when the chip enters sleep mode Requires SD card re-initialization by the host when power is restored Enable, Always On - Power to the SD card is maintained even when the chip enters sleep mode SD card remains powered and ready without requiring re-initialization Note: When the SD card power is turned off using any method, the host must re-initialize the SD card before use.
Valid options include the following:
'Disable' | | |
'Enable, Turn-Off Sleep' | | |
'Enable, Always On' | |
inst.$name = 'CONFIG_BUTTON_{num}'; | // Name |
inst.autoHwConfig = true; | // Use Provided Button Configuration |
inst.polarity = 'Active Low'; | // Button Configuration |
inst.pull = 'Internal'; | // Pull Resistor |
This name is declared in the generated ti_drivers_config.h file so applications can reference this instance symbolically. Additionally, this name is used to declare an 'extern const' which allows libraries to define symbolic names for required driver configurations without needing to rebuild library source files. The 'const' identifier is declared as the same name with a _CONST suffix. The name can be set to any globally unique name that is also a valid C/C++ identifier.
The SysConfig tooling ensures that all names defined in a configuration are unique. When instances are first created, SysConfig gives them a default name, CONFIG_BUTTON_, that's made unique by appending a numeric id. If you provide a name, it's checked against all other instance names in the configuration and, if another instance has the same name, an error is triggered. The additional 'const' declaration is assumed to also be globally unique.
Note: since not all names are added to ti_drivers_config.h, it's possible that some names will not be allowed even though they do not actually collide in the generated files.
Use Provided Button Configuration
[inst.autoHwConfig = true]
|
When this setting is enabled, the board specific settings will be used to determine the button's hardware configuration. This will provide the correct configuration most of the time. If the button hardware has been modified, this setting should be disabled and the user should manually set the correct hardware configuration.
Button Configuration
[inst.polarity = 'Active Low']
|
Specify whether the button is connected to ground or Vcc when pushed. 'Active High' should be set for a button that is connected to Vcc when pushed. 'Active Low' should be set for a button that is connected to ground when pushed.
Valid options include the following:
'Active Low' | | |
'Active High' | |
Pull Resistor
[inst.pull = 'Internal']
|
Choose whether the GPIO hardware should pull the pin. If you have an external pullup resistor, choose 'External' and the GPIO pullup will be disabled.
Valid options include the following:
'Internal' | | |
'External' | |
inst.$name = 'CONFIG_LED_{num}'; | // Name |
inst.dimmable = false; | // Dimmable |
This name is declared in the generated ti_drivers_config.h file so applications can reference this instance symbolically. Additionally, this name is used to declare an 'extern const' which allows libraries to define symbolic names for required driver configurations without needing to rebuild library source files. The 'const' identifier is declared as the same name with a _CONST suffix. The name can be set to any globally unique name that is also a valid C/C++ identifier.
The SysConfig tooling ensures that all names defined in a configuration are unique. When instances are first created, SysConfig gives them a default name, CONFIG_LED_, that's made unique by appending a numeric id. If you provide a name, it's checked against all other instance names in the configuration and, if another instance has the same name, an error is triggered. The additional 'const' declaration is assumed to also be globally unique.
Note: since not all names are added to ti_drivers_config.h, it's possible that some names will not be allowed even though they do not actually collide in the generated files.
Dimmable
[inst.dimmable = false]
|
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
|
Similarily,
inst.paramName = defaultValue
|
For example, the following is a snippet of a SysConfg script that configures the GPIO module and a GPIO instance.