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 |
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 n ref LogSinkUART 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 LogSinkUART 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 register interrupts and more li ref NoRTOS h *******************************************************************************The Driver Porting | Layer (DPL) is a set of modules to provide OS-independent access to typical operating system services. Interfaces are only supported on operating systems where they can be backed by OS primitives.< TABLE >< TR >< TH >DPL Module</TH >< TH >Description</TH >< TH >Supported OSes</TH ></TR >< TR >< TD > @ref ClockP.h</TD >< TD >One-shot timer instances based on kernel ticks</TD >< TD >TI-RTOS 7 |
[drivers_common_nortos] More... | |
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 n ref LogSinkUART 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 LogSinkUART 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 n ref LogSinkUART 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 LogSinkUART 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 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 n ref LogSinkUART 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 LogSinkUART 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 register interrupts and more li ref NoRTOS h *******************************************************************************The Driver Porting NoRTOS</TD ></TR >< TR >< TD > ref EventP h</TD >< TD > Pendable bit event groups</TD >< TD > TI | 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 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 n ref LogSinkUART 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 LogSinkUART 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 register interrupts and more li ref NoRTOS h *******************************************************************************The Driver Porting NoRTOS</TD ></TR >< TR >< TD > ref EventP h</TD >< TD > Pendable bit event groups</TD >< TD > TI FreeRTOS</TD ></TR >< TR >< TD > ref HwiP h</TD >< TD > Hardware interrupt | interface |
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 n ref LogSinkUART 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 LogSinkUART 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 register interrupts and more li ref NoRTOS h *******************************************************************************The Driver Porting NoRTOS</TD ></TR >< TR >< TD > ref EventP h</TD >< TD > Pendable bit event groups</TD >< TD > TI FreeRTOS</TD ></TR >< TR >< TD > ref HwiP h</TD >< TD > Hardware interrupt including global enable disable</TD >< TD > TI NoRTOS</TD ></TR >< TR >< TD > ref MutexP h</TD >< TD > | Pendable |
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 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 n ref LogSinkUART 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 LogSinkUART 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 register interrupts and more li ref NoRTOS h******************************************************************************* The Driver Porting Layer | ( | DPL | ) |
[drivers_common_nortos]
[drivers_common_dpl]
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 n ref LogSinkUART 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 LogSinkUART 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 register interrupts and more li ref NoRTOS h *******************************************************************************The Driver Porting NoRTOS</TD ></TR >< TR >< TD > ref EventP h</TD >< TD > Pendable bit event groups</TD >< TD > TI FreeRTOS</TD ></TR >< TR >< TD > ref HwiP h</TD >< TD > Hardware interrupt including global enable disable</TD >< TD > TI NoRTOS</TD ></TR >< TR >< TD > ref MutexP h</TD >< TD > recursive single mutex</TD >< TD > TI FreeRTOS</TD ></TR >< TR >< TD > ref SemaphoreP h</TD >< TD > Binary or counting semaphore instances</TD >< TD > TI NoRTOS</TD ></TR >< TR >< TD > ref SwiP h</TD >< TD > Software interrupt interface</TD >< TD > TI NoRTOS</TD ></TR >< TR >< TD > ref TaskP h</TD >< TD > OS task object wrapper</TD >< TD > TI FreeRTOS</TD ></TR >< TR >< TD > ref TimestampP h</TD >< TD > Utility functions to get device timestamp</TD >< TD > TI 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 n ref LogSinkUART 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 LogSinkUART 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 n ref LogSinkUART 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 LogSinkUART 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 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 n ref LogSinkUART 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 LogSinkUART 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 register interrupts and more li ref NoRTOS h *******************************************************************************The Driver Porting NoRTOS</TD ></TR >< TR >< TD > ref EventP h</TD >< TD > Pendable bit event groups</TD >< TD > TI FreeRTOS</TD ></TR >< TR >< TD > ref HwiP h</TD >< TD > Hardware interrupt including global enable disable</TD >< TD > TI NoRTOS</TD ></TR >< TR >< TD > ref MutexP h</TD >< TD > recursive single mutex</TD >< TD > TI FreeRTOS</TD ></TR >< TR >< TD > ref SemaphoreP h</TD >< TD > Binary or counting semaphore instances</TD >< TD > TI NoRTOS</TD ></TR >< TR >< TD > ref SwiP h</TD >< TD > Software interrupt interface</TD >< TD > TI NoRTOS</TD ></TR >< TR >< TD > ref TaskP h</TD >< TD > OS task object wrapper</TD >< TD > TI FreeRTOS</TD ></TR >< TR >< TD > ref TimestampP h</TD >< TD > Utility functions to get device timestamp</TD >< TD > TI NoRTOS</TD ></TR >< TR >< TD > ref MessageQueueP h</TD >< TD > OS mailbox queue object wrapper</TD >< TD > TI 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 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 n ref LogSinkUART 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 LogSinkUART 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 register interrupts and more li ref NoRTOS h******************************************************************************* The Driver Porting NoRTOS</TD></TR><TR><TD> ref EventP h</TD><TD> Pendable bit event groups</TD><TD> TI FreeRTOS</TD></TR><TR><TD> ref HwiP h</TD><TD> Hardware interrupt interface |
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 n ref LogSinkUART 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 LogSinkUART 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 register interrupts and more li ref NoRTOS h******************************************************************************* The Driver Porting NoRTOS</TD></TR><TR><TD> ref EventP h</TD><TD> Pendable bit event groups</TD><TD> TI FreeRTOS</TD></TR><TR><TD> ref HwiP h</TD><TD> Hardware interrupt including global enable disable</TD><TD> TI NoRTOS</TD></TR><TR><TD> ref MutexP h</TD><TD> Pendable |