Functions | |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming | interface (API) which enables seamless migration across the SimpleLink SDK portfolio. Unless specifically stated otherwise |
[drivers_common_overview] More... | |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating | system (RTOS) application. All TI-Driver implementations utilize the Power driver APIs to ensure low power consumption at all times. The drivers support TI-RTOS7(SYS/BIOS) |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization< b > may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open< b > it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref< b > Driver_config</b > Multiple software entities may use the same driver concurrently For a Bluetooth or WiFi stack may utilize a driver instance The application may concurrently use the same driver assuming it has opened a unique instance of the driver Let s examine the ADC driver for example include Driver_init h A couple observations from this code | ADC_init (). 4. We have to create a handle for our ADC driver instance. This is done by calling ADC_open() with our desired config index. Once a handle has been created the driver instance is ready for use. Each index can only be opened once! 4. In this simple example |
Function to initialize the ADC driver. More... | |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization< b > may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open< b > it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref< b > Driver_config</b > Multiple software entities may use the same driver concurrently For a Bluetooth or WiFi stack may utilize a driver instance The application may concurrently use the same driver assuming it has opened a unique instance of the driver Let s examine the ADC driver for example include Driver_init h A couple observations from this code we use the | ADC_convert () API. 5. A driver instance can be closed and re-open. For our simple example |
Variables | |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating | FreeRTOS |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant | Lastly |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par | Features |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists | of |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists | open |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists | use |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise | stated |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization | function |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization< b > | Driver_init</b > |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization< b > may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open< b > | Driver_open</b > |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization< b > may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open< b > it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref | driver_configuration |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization< b > may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open< b > it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref< b > Driver_config</b > Multiple software entities may use the same driver concurrently For | example |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization< b > may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open< b > it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref< b > Driver_config</b > Multiple software entities may use the same driver concurrently For a Bluetooth or WiFi stack may utilize a driver instance The application may concurrently use the same driver assuming it has opened a unique instance of the driver Let s examine the ADC driver for example include Driver_init h A couple observations from this code we use the that s all we need | However |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization< b > may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open< b > it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref< b > Driver_config</b > Multiple software entities may use the same driver concurrently For a Bluetooth or WiFi stack may utilize a driver instance The application may concurrently use the same driver assuming it has opened a unique instance of the driver Let s examine the ADC driver for example include Driver_init h A couple observations from this code we use the that s all we need for full details on the ADC and other | drivers |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization< b > may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open< b > it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref< b > Driver_config</b > Multiple software entities may use the same driver concurrently For a Bluetooth or WiFi stack may utilize a driver instance The application may concurrently use the same driver assuming it has opened a unique instance of the driver Let s examine the ADC driver for example include Driver_init h A couple observations from this code we use the that s all we need for full details on the ADC and other reference the< b > Drivers and Documentation</b > section below endparblock *******************************************************************************The Display driver is designed abstract to operations &considerations specific to a given output method *******************************************************************************< TABLE >< TR align="center">< TH > Display Driver Interface</TH >< TH > Implementations</TH ></TR >< TR align="center">< TD > ref Display h</TD >< TD > ref DisplayHost h n ref DisplayUart2 h</TD ></TR ></TABLE > *******************************************************************************< TABLE >< TR align="center">< TH > Display Driver Interface</TH >< TH > Implementations</TH ></TR >< TR align="center">< TD > ref Display h</TD >< TD > ref DisplaySharp h n ref DisplayHost h n ref DisplayExt h n ref DisplayUart2 h</TD ></TR ></TABLE > *******************************************************************************Logging is a lightweight framework for instrumenting target code *******************************************************************************< TABLE >< TR align="center">< TH > Log Interface</TH >< TH > Sinks</TH ></TR >< TR align="center">< TD >< a class="el" href="../../../tiutils/html/group__ti__log__LOG.html"> Log h</a ></TD >< TD > ref LogSinkBuf h</TD ></TR ></TABLE > *******************************************************************************< TABLE >< TR align="center">< TH > Log Interface</TH >< TH > Sinks</TH ></TR >< TR align="center">< TD >< a class="el" href="../../../tiutils/html/group__ti__log__LOG.html"> Log h</a ></TD >< TD > ref LogSinkBuf h n ref LogSinkITM h</TD ></TR ></TABLE > *******************************************************************************The NoRTOS framework module is provided to enable use of drivers without an underlying operating system The module provides interfaces used by drivers to perform | delays |
[drivers_common_overview] More... | |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization< b > may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open< b > it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref< b > Driver_config</b > Multiple software entities may use the same driver concurrently For a Bluetooth or WiFi stack may utilize a driver instance The application may concurrently use the same driver assuming it has opened a unique instance of the driver Let s examine the ADC driver for example include Driver_init h A couple observations from this code we use the that s all we need for full details on the ADC and other reference the< b > Drivers and Documentation</b > section below endparblock *******************************************************************************The Display driver is designed abstract to operations &considerations specific to a given output method *******************************************************************************< TABLE >< TR align="center">< TH > Display Driver Interface</TH >< TH > Implementations</TH ></TR >< TR align="center">< TD > ref Display h</TD >< TD > ref DisplayHost h n ref DisplayUart2 h</TD ></TR ></TABLE > *******************************************************************************< TABLE >< TR align="center">< TH > Display Driver Interface</TH >< TH > Implementations</TH ></TR >< TR align="center">< TD > ref Display h</TD >< TD > ref DisplaySharp h n ref DisplayHost h n ref DisplayExt h n ref DisplayUart2 h</TD ></TR ></TABLE > *******************************************************************************Logging is a lightweight framework for instrumenting target code *******************************************************************************< TABLE >< TR align="center">< TH > Log Interface</TH >< TH > Sinks</TH ></TR >< TR align="center">< TD >< a class="el" href="../../../tiutils/html/group__ti__log__LOG.html"> Log h</a ></TD >< TD > ref LogSinkBuf h</TD ></TR ></TABLE > *******************************************************************************< TABLE >< TR align="center">< TH > Log Interface</TH >< TH > Sinks</TH ></TR >< TR align="center">< TD >< a class="el" href="../../../tiutils/html/group__ti__log__LOG.html"> Log h</a ></TD >< TD > ref LogSinkBuf h n ref LogSinkITM h</TD ></TR ></TABLE > *******************************************************************************The NoRTOS framework module is provided to enable use of drivers without an underlying operating system The module provides interfaces used by drivers to perform block | execution |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming interface | ( | API | ) |
[drivers_common_overview]
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating system | ( | RTOS | ) |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b> li<b> Thread safe APIs</b> li<b> SysConfig support</b> li<b> Example usage</b> li<b> Power management support</b> par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization<b> may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open<b> it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref<b> Driver_config</b> Multiple software entities may use the same driver concurrently For a Bluetooth or WiFi stack may utilize a driver instance The application may concurrently use the same driver assuming it has opened a unique instance of the driver Let s examine the ADC driver for example include Driver_init h A couple observations from this code ADC_init | ( | void | ) |
Function to initialize the ADC driver.
This function must also be called before any other ADC driver APIs.
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b> li<b> Thread safe APIs</b> li<b> SysConfig support</b> li<b> Example usage</b> li<b> Power management support</b> par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization<b> may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open<b> it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref<b> Driver_config</b> Multiple software entities may use the same driver concurrently For a Bluetooth or WiFi stack may utilize a driver instance The application may concurrently use the same driver assuming it has opened a unique instance of the driver Let s examine the ADC driver for example include Driver_init h A couple observations from this code we use the ADC_convert | ( | ) |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par FreeRTOS |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant Lastly |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par Features |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b> li<b> Thread safe APIs</b> li<b> SysConfig support</b> li<b> Example usage</b> li<b> Power management support</b> par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists of |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b> li<b> Thread safe APIs</b> li<b> SysConfig support</b> li<b> Example usage</b> li<b> Power management support</b> par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists open |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b> li<b> Thread safe APIs</b> li<b> SysConfig support</b> li<b> Example usage</b> li<b> Power management support</b> par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists use |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b> li<b> Thread safe APIs</b> li<b> SysConfig support</b> li<b> Example usage</b> li<b> Power management support</b> par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise stated |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization< b > may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open function |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b> li<b> Thread safe APIs</b> li<b> SysConfig support</b> li<b> Example usage</b> li<b> Power management support</b> par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization<b> Driver_init</b > |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b> li<b> Thread safe APIs</b> li<b> SysConfig support</b> li<b> Example usage</b> li<b> Power management support</b> par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization<b> may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open<b> Driver_open</b > |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b> li<b> Thread safe APIs</b> li<b> SysConfig support</b> li<b> Example usage</b> li<b> Power management support</b> par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization<b> may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open<b> it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref driver_configuration |
This file contains snippets to be used in the TI Driver s documentation *******************************************************************************TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b > li< b > Thread safe APIs</b > li< b > SysConfig support</b > li< b > Example usage</b > li< b > Power management support</b > par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization< b > may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open< b > it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref< b > Driver_config</b > Multiple software entities may use the same driver concurrently For a Bluetooth or WiFi stack may utilize a driver instance The application may concurrently use the same driver assuming it has opened a unique instance of the driver Let s examine the ADC driver for example include Driver_init h A couple observations from this code example |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b> li<b> Thread safe APIs</b> li<b> SysConfig support</b> li<b> Example usage</b> li<b> Power management support</b> par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization<b> may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open<b> it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref<b> Driver_config</b> Multiple software entities may use the same driver concurrently For a Bluetooth or WiFi stack may utilize a driver instance The application may concurrently use the same driver assuming it has opened a unique instance of the driver Let s examine the ADC driver for example include Driver_init h A couple observations from this code we use the that s all we need However |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b> li<b> Thread safe APIs</b> li<b> SysConfig support</b> li<b> Example usage</b> li<b> Power management support</b> par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization<b> may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open<b> it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref<b> Driver_config</b> Multiple software entities may use the same driver concurrently For a Bluetooth or WiFi stack may utilize a driver instance The application may concurrently use the same driver assuming it has opened a unique instance of the driver Let s examine the ADC driver for example include Driver_init h A couple observations from this code we use the that s all we need for full details on the ADC and other drivers |
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b> li<b> Thread safe APIs</b> li<b> SysConfig support</b> li<b> Example usage</b> li<b> Power management support</b> par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization<b> may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open<b> it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref<b> Driver_config</b> Multiple software entities may use the same driver concurrently For a Bluetooth or WiFi stack may utilize a driver instance The application may concurrently use the same driver assuming it has opened a unique instance of the driver Let s examine the ADC driver for example include Driver_init h A couple observations from this code we use the that s all we need for full details on the ADC and other reference the<b> Drivers and Documentation</b> section below endparblock******************************************************************************* The Display driver is designed abstract to operations& considerations specific to a given output method*******************************************************************************<TABLE><TR align ="center"><TH> Display Driver Interface</TH><TH> Implementations</TH></TR><TR align ="center"><TD> ref Display h</TD><TD> ref DisplayHost h n ref DisplayUart2 h</TD></TR></TABLE> *******************************************************************************<TABLE><TR align ="center"><TH> Display Driver Interface</TH><TH> Implementations</TH></TR><TR align ="center"><TD> ref Display h</TD><TD> ref DisplaySharp h n ref DisplayHost h n ref DisplayExt h n ref DisplayUart2 h</TD></TR></TABLE> ******************************************************************************* Logging is a lightweight framework for instrumenting target code*******************************************************************************<TABLE><TR align ="center"><TH> Log Interface</TH><TH> Sinks</TH></TR><TR align ="center"><TD><a class="el" href="../../../tiutils/html/group__ti__log__LOG.html"> Log h</a></TD><TD> ref LogSinkBuf h</TD></TR></TABLE> *******************************************************************************<TABLE><TR align ="center"><TH> Log Interface</TH><TH> Sinks</TH></TR><TR align ="center"><TD><a class="el" href="../../../tiutils/html/group__ti__log__LOG.html"> Log h</a></TD><TD> ref LogSinkBuf h n ref LogSinkITM h</TD></TR></TABLE> ******************************************************************************* The NoRTOS framework module is provided to enable use of drivers without an underlying operating system The module provides interfaces used by drivers to perform delays |
[drivers_common_overview]
[drivers_common_display] [drivers_common_display] [drivers_common_display_table] [drivers_common_display_table] [drivers_full_display_table] [drivers_full_display_table] [drivers_common_log] [drivers_common_log] [drivers_common_log_table] [drivers_common_log_table] [drivers_full_log_table] [drivers_full_log_table] [drivers_common_nortos]
This file contains snippets to be used in the TI Driver s documentation******************************************************************************* TI Drivers is a collective of peripheral drivers for TI s SimpleLink portfolio The drivers are centered around a portable application programming TI Drivers are designed to be thread safe and work seamlessly inside of a real time operating and NoRTOS with examples provided for each variant the drivers are supported by SysConfig to enable easy re configuration of the drivers par and NoRTOS</b> li<b> Thread safe APIs</b> li<b> SysConfig support</b> li<b> Example usage</b> li<b> Power management support</b> par Driver Initialization parblock TI Driver APIs follow a common initialization model This model typically consists and close the driver Unless otherwise the initialization<b> may be called multiple times by the application It is only required that the initialization is done once For drivers which have an open<b> it must be called per instance of the driver to be used Each instance of the driver corresponds to a unique index in the ref<b> Driver_config</b> Multiple software entities may use the same driver concurrently For a Bluetooth or WiFi stack may utilize a driver instance The application may concurrently use the same driver assuming it has opened a unique instance of the driver Let s examine the ADC driver for example include Driver_init h A couple observations from this code we use the that s all we need for full details on the ADC and other reference the<b> Drivers and Documentation</b> section below endparblock******************************************************************************* The Display driver is designed abstract to operations& considerations specific to a given output method*******************************************************************************<TABLE><TR align ="center"><TH> Display Driver Interface</TH><TH> Implementations</TH></TR><TR align ="center"><TD> ref Display h</TD><TD> ref DisplayHost h n ref DisplayUart2 h</TD></TR></TABLE> *******************************************************************************<TABLE><TR align ="center"><TH> Display Driver Interface</TH><TH> Implementations</TH></TR><TR align ="center"><TD> ref Display h</TD><TD> ref DisplaySharp h n ref DisplayHost h n ref DisplayExt h n ref DisplayUart2 h</TD></TR></TABLE> ******************************************************************************* Logging is a lightweight framework for instrumenting target code*******************************************************************************<TABLE><TR align ="center"><TH> Log Interface</TH><TH> Sinks</TH></TR><TR align ="center"><TD><a class="el" href="../../../tiutils/html/group__ti__log__LOG.html"> Log h</a></TD><TD> ref LogSinkBuf h</TD></TR></TABLE> *******************************************************************************<TABLE><TR align ="center"><TH> Log Interface</TH><TH> Sinks</TH></TR><TR align ="center"><TD><a class="el" href="../../../tiutils/html/group__ti__log__LOG.html"> Log h</a></TD><TD> ref LogSinkBuf h n ref LogSinkITM h</TD></TR></TABLE> ******************************************************************************* The NoRTOS framework module is provided to enable use of drivers without an underlying operating system The module provides interfaces used by drivers to perform block execution |