Processor SDK RTOS Software ran v0.1Part1
Transcript of Processor SDK RTOS Software ran v0.1Part1
Introduction toIntroduction to Processor SDK RTOS Part 1
Agenda• Processor RTOS SDK Overview• TI‐RTOS KernelTI RTOS Kernel• Inter‐Processor Communication (IPC)• Network Development Kit (NDK)Network Development Kit (NDK)• Diagnostic Software• Algorithm Libraries• Algorithm Libraries• Drivers (Covered in Part 2)
Processor RTOS SDK Overview
Introduction to Processor SDK RTOS
Processor SDK RTOS Development Ecosystem Eclipse IDE
Processor SDK RTOS Code Composer
TMThird Party
StudioTM (CCS) Plug‐Ins
For CCS Training: processors.wiki.ti.com/index.php/Category:CCS_
TrainingTraining
Host Computer Target Board/SimulatorEmulator
p g /
Processor SDK RTOS Install• Each TI part has its own install page. For example:
AM335x: http://www ti com/tool/processor sdk am335x―AM335x: http://www.ti.com/tool/processor‐sdk‐am335x
―AM57x: http://www.ti.com/tool/processor‐sdk‐am57x
• Click on the Get Software link and it will take you to install page like the one in the next slideinstall page like the one in the next slide.
• The Getting Started Guide and the Developer Guide show how to start developing Processor SDK RTOS‐based applications.
Part of Processor SDK RTOS Install Page
Processor SDK RTOS: OverviewThe RTOS (Real Time Operating System) perspective of the TI Processor SDK (Software Development Kit):
• Provides a set of software building blocks that facilitate development of (real‐time) applications
• Consists of SOC (device) and platform dependent modules, Core dependent software, TI‐RTOS kernel and utilities and application examples
• Includes source code and prebuilt librariesp
• Embedded OS: TI‐RTOS kernel for DSP, ARM, and M4
• De elopment OS Windo s and Lin PC s pport• Development OS: Windows and Linux PC support
• Available as a free download with all components in one i t llinstaller
Processor SDK ElementsApplications
Implemented on top of the operating system and may be architecture dependent.
Operating System Dependent Components
TI‐RTOS kernel, Tools, Utilities, Drivers, , ,
Core‐Specific / OS‐Independent Components
Optimized Libraries, Compiler Tools
SOC Dependent / OS Independent ComponentsSOC ‐Dependent / OS‐Independent Components
device and platform drivers
Processor SDK RTOS Software (Superset)
Application OOB Demos
RTOS ‐ NetworkSoftware Framework Components
InfotainmentVisionIndustrialSmall CellAudioVideoHPC
TI‐RTOS XDCtools
RTOS Network
TCP/IPNetworking
(NDK)
Software Framework Components
Inter‐Processor Communication
(IPC)
Framework Components
OS AbstractionLayer (OSAL)
Network I/FMgmt Unit(NIMU)
Algorithm Libraries
DSPLIB IMGLIB MATHLIB Code Generation
Platform/EVM Software
Secondary Bootloader FATFS
Tools forDifferentCores
(will move to CCS)
BoardLibraryLow Level Drivers (LLD)
EDMA3 ICSS‐EMAC PCIe PRUSS I2C EMAC CCS) Diagnostics
Chip Support Library (CSL)
SPI GPIO UART …USB SD/MMC
Hardware
p pp y ( )
Component used by core code developersDevice/platform‐dependent
OS‐dependent Applications
Processor SDK RTOS
Single prod ct s pports m ltiple SoCsSingle product supports multiple SoCs
Processor SDK RTOS Release (AM335)
Processor SDK RTOS Release (AM437)
Processor SDK RTOS Release (AM572X)Superset of Featuresp
Processor SDK RTOS Release (AM572X)
pdk_am57xx_1_0_0
edma3 lld 02 12 01 21edma3_lld_02_12_01_21
framework_components_3_40_00_02
The pdk folder contains the platform development kit
The edma folder includes multiple EDMA controllers
The framework components folder includes a set ofdevelopment kit,
which is a collection of CSL and low‐level drivers that configure
EDMA controllers, management drivers, and the resource manager
includes a set of utilities to manage the target board hardware, memories,drivers that configure
and manage the hardware.
resource manager. hardware, memories, interfaces, etc.
Processor SDK RTOS Release (AM572X)
dsplib_c66x_3_4_0_0
imglib_c66x_3_2_0_1
mathlib_c66x_3_1_0_0
ti‐cgt‐c6000_8.0.3
xdais_7_24_00_04
The following folders contain optimized The xdais folder The ti‐cgt‐c6000 folder The following folders contain optimized libraries for DSP core applications:
• dsplib: FFT, Filters, etc.
The xdais folder includes a set of standard DSP interfaces that enable
contains code generation tools that enable code development on the
• imglib: Image processing
• mathlib: Standard math functions (sin, cosin, sqrt)
interfaces that enable easy integration of XDAIS‐compatible algorithms (voice and
target board.
NOTE: This tool will move (sin, cosin, sqrt)
NOTE: Many more libraries are available as source code outside of th l
algorithms (voice and video codecs) into applications.
to CCS with the other code generation tools.
the release.
Processor SDK RTOS Release (AM572X)bios_6_41_04_54
cg_xml
xdctools_3_31_02_38
ipc_3_36_01_11
processor_sdk_rtos_2_00_00_00
ndk_2_24_01_18
The bios folder includes the RTOS operating
The cg_xml and xdctoolsfolders contain sets of
The ipc folder contains a set of utilities used to
system kernel (scheduler and utilities).
h dk
utilities used to build and configure OS modules using a GUI interface or
fi i fil
facilitate inter‐processor communications internal and external the device.
The processor_sdk_rtosfolder contains collateral, documentation, and
l
ASCII configuration file .The ndk folder includes the TCP/IP stack.
examples.
Processor SDK RTOS Release (AM572X)
ctoolslib 1 1 1 0ctoolslib_1_1_1_0
uia_2_00_03_43
The ctools folder is a collection of libraries
The uia (universal instrumentationcollection of libraries
that control real‐time debug and collect debug information
instrumentation architecture) folder contains utilities, which are used to processdebug information
(instrumentation) .are used to process, analyze, and display debug data from the hardware ( l )(visualization).
TI‐RTOS Kernel
Introduction to Processor SDK RTOS
TI‐RTOS: Generic Real Time Operating System
• TI‐RTOS is a scalable OS that is currently available for l i lmultiple cores:
– Tiva‐C (M4)Concerto (M3+C28x)– Concerto (M3+C28x)
– C28x– MSP430– C6000– Sitara
• TI‐RTOS is embedded within Processor SDK RTOS.• The RTOS kernel is a real‐time multi‐tasks scheduler. • Tools, utilities, and drivers are also included.
Real Time Multi‐Tasks Scheduler
By definition, real‐time is a controlled response time to (multiple) external events.• Able to accept multiple interruptsAble to accept multiple interrupts• Controls the maximum latency in responding to interruptNOTE: Deterministic latency is hard to achieveNOTE: Deterministic latency is hard to achieve
• Provides a strong priority scheme for tasks
TI‐RTOS Real Time Multi‐Tasks SchedulerE t d i ti t• Event‐driven operating systemNOTE: Event can be clock, but usually not.
V ll d ti f t i t• Very small adaptive footprint• Very efficient context switching
More Information About TI‐RTOS• Comprehensive TI RTOS online training:
http://processors.wiki.ti.com/index.php/Introduction_to_the_TI‐RTOS_Kernel_Workshop
d d– 10 video presentations cover TI‐RTOS and CCS in great detail.All lid il bl f d l d– All slides are available for download.
• Other URLs that contain RTOS training are http://processors wiki ti com/index php/SYS/BIOS Online Training andhttp://processors.wiki.ti.com/index.php/SYS/BIOS_Online_Training and http://processors.wiki.ti.com/index.php/Hands‐On_Training_for_TI_Embedded_Processors
• The back‐up slides attached to the end of this presentation (See Resources for PDF) provide a brief description of all TI‐RTOS thread types.
Inter‐Processor CommunicationInter‐Processor Communication (IPC)( )Introduction to Processor SDK RTOS
IPC PrinciplesIPC provides standard APIs to communicate bet een threadsbetween threads:• The same APIs for all SOCs• The same APIs regardless of what CPU is the sender and what CPU is the receiversender and what CPU is the receiver
• The same APIs regardless of the operating system
• The same APIs regardless of the transportThe same APIs regardless of the transport mechanism
IPC Challengesg• Cooperation between multiple cores requires a smart way to exchange data and messagesway to exchange data and messages.
• IPC must support any number of cores within a single SOC with the ability to connect multiple devicesSOC with the ability to connect multiple devices.
• An efficient scheme is required to avoid high cost in terms of CPU cyclesterms of CPU cycles.
• Implementations depend on the hardware, transport layer and operating systemlayer, and operating system.
• There are the usual trade‐offs: performance (speed, flexibility) versus cost (complexity, more resources).flexibility) versus cost (complexity, more resources).
SOC Architecture Support for IPCpp
• Depends on the SOC―Memories that can be shared between cores―Mailboxes or interrupt registers ―Multicore Navigator or other DMA mechanismMulticore Navigator or other DMA mechanism
• Uses peripherals for communication between devices
IPC Modulel l l• Current IPC implementation may use multiple transports:
– Core Core – Device Device (SoC peripheral interface)
• Chosen at configuration; Same code regardless of thread location.
Device 1ARM C66
Device 2ARM
• IPC Manager initializes IPC and ARM
hread 1
hread 2
C66x
hread 1
hread 2
ARM
hread 1
hread 2
initializes IPC and synchronization
API summary: ‐RTO
S
‐RTO
S
RTOS
Th
IPCIPC
Th Th
IPCIPC
Th Th
IPCIPC
ThAPI summary:Ipc_start reserves memory, create default gate and heapIpc_stop releases all resourcesIpc attach sets up transport
TI‐
TI‐
TI‐
MEMIpc_attach sets up transport between two processorsIpc_detach finalizes transport
SoC Peripheral SoC Peripheral
IPC Services• The IPC package is a set of standard APIs MessageQ is the• The IPC package is a set of standard APIs MessageQ is the
highest layer Th i l t ti i d i d ti t d d t• The implementation is device and operating system dependent
Application
MessageQ
Drivers
IPC Config And
Initialization
Transport layer (shared memory, Navigator, srio)Transport layer (shared memory, Navigator, srio)
MessageQ Highest Layer API (1/3)Core 2 READER
MessageQ_create(“myQ”, *synchronizer);
Core 2 ‐ READER
SINGLE reader, MessageQ_get(“myQ”, &msg, timeout);“myQ”multiple WRITERS
model (READER owns queue/mailbox)
• MessageQ transactions begin with READER creating a MessageQ.
READER’ l i bl k ( l• READER’s attempt to get a message results in a block (unlesstimeout was specified), since no messages are in the queue yet.
Using MessageQ (2/3)Core 1 WRITER Core 2 READER
MessageQ_create(“myQ”, …);MessageQ_open (“myQ”, …);
Core 1 ‐WRITER Core 2 ‐ READER
“myQ” MessageQ_get(“myQ”, &msg…);msg = MessageQ_alloc (heap, size,…);
MessageQ_put(“myQ”, msg, …);
HeapHeap
• WRITER begins by opening MessageQ created by READER.• WRITER gets a message block from a heap and fills it, as desired.• WRITER puts the message into the MessageQ.
Using MessageQ (3/3)Core 1 WRITER Core 2 READER
MessageQ_create(“myQ”, …);MessageQ_open (“myQ”, …);
Core 1 ‐WRITER Core 2 ‐ READER
“myQ” MessageQ_get(“myQ”, &msg…);
*** PROCESS MSG ***
msg = MessageQ_alloc (heap, size,…);
MessageQ_put(“myQ”, msg, …);
MessageQ_free(“myQ”, …);
MessageQ_delete(“myQ”, …);
MessageQ_close(“myQ”, …);
HeapHeap
• Once WRITER puts msg in MessageQ, READER is unblocked.• READER can now read/process the received message.• READER frees message back to Heap.• READER can optionally delete the created MessageQ, if desired.
Network Developer’s Kit (NDK)
Introduction to Processor SDK RTOS
Network ServicesThe Network Developer’s Kit (NDK) serves as a rapid prototype platform for the development of network andprototype platform for the development of network and packet‐processing applications. NDK includes the following:following:• IPv6 and IPv4 compliant TCP/IP stack • Layer 3 & 4 network protocolsLayer 3 & 4 network protocols• High‐level network applications including HTTP server and
DHCP
NOTE: NDK was developed as a prototype code example. It is not aimed for high‐throughput networkingIt is not aimed for high throughput networking.
Network Services• The NDK is divided into two parts:parts:– NIMU (Network Interface Management Unit)Management Unit)
– User interface unit
• For more information, refer to the NDK User’s Guide.
Algorithm Libraries
Introduction to Processor SDK RTOS
Optimized Algorithm Libraries• The Processor SDK release contains three algorithm libraries.
• Each release directory has a C66 DSP‐optimized code as well as a standard ANSI C implementation of all th f tithe functions.
• The standard ANSI C implementation is used to validate the results of the optimized libraryvalidate the results of the optimized library functions.
• Compiling the ANSI C source code using another core p g g(like M4 or A15) compiler provides (non‐optimized) libraries for non‐DSP core.
DSP Algorithm Libraries• Optimized algorithm libraries contain C66x C‐callable, C with intrinsic functions for specific usage.
• Few legacy functions are written using assembly code.
• The following three libraries are part of the Processor SDK release:Fundamental math & signal processing libraries:– Fundamental math & signal processing libraries: DSPLIB: Signal‐processing math and vector functions MathLIB: Floating‐point math functionsg p
– IMGLIB: Image/video processing functions• A complete set of libraries that are available as source code can be found here: http://processors.wiki.ti.com/index.php/Software_libraries
Diagnostics Software
Introduction to Processor SDK RTOS
CCS Diagnostic Elements• CCS‐based Debug
break points– break points– watch points– step/step into– resume
• CCS‐based Trace (Instrumentation)C fi l i– Configure trace logic
– Getting trace information back to host
• CCS‐based data processing (Visualization)
Run‐Time Diagnostic ElementsPart of Processor SDKPart of Processor SDK
CToolsLib (Chip Tools Library) has multiple libraries that provide run‐time debug capabilities.
NOTE: Not all features are available for all devices. Usage is dependent on core and device hardware.
More details at http://processors.wiki.ti.com/index.php/CToolsLib
Run‐Time Diagnostic Elements• AET (Advanced Event Trigger Library) configures stateLibrary) configures state machines that control tracing.
• DSPTraceLib and ETBLib(Embedded Trace Buffer(Embedded Trace Buffer Library) provide a set of functions to control the DSPfunctions to control the DSP trace buffer operation and trace data transporttrace data transport.
More details at http://processors.wiki.ti.com/index.php/CToolsLib
Run‐Time Diagnostic Elements• ETMLib (Embedded Trace
Macrocell Library) controls theMacrocell Library) controls the ARM macrocell trace facilities.
• PMICMILib (Power and Clock Management InstrumentationManagement Instrumentation library) provides programming and control APIs for the PMI/CMI units, which provide power and clock state profiling.
More details at http://processors.wiki.ti.com/index.php/CToolsLib
Run‐Time Diagnostic Elements• SCILib (Statistic Collectors Library) collects statisticalLibrary) collects statistical data from hardware counters (core dependent)(core dependent).
b ( b )• STMLib (System Trace Library) provides a set of utilities to ll lcollect real‐time, non‐
intrusive system trace d i imessages during run‐time.
More details at http://processors.wiki.ti.com/index.php/CToolsLib
For More Information• TI‐RTOS Tool Folder• TI‐RTOS Wiki• TI‐RTOS Kernel WorkshopTI RTOS Kernel Workshop• Introduction to Processor SDK RTOS Part 2• For questions regarding topics covered in this training, visit the support forums at the TI E2E g, ppCommunity website.
Back‐Up Slides
TI‐RTOS Real Time Multi‐Tasks Scheduler
Four thread layers are prioritized as follo sas follows:1. Hardware Interrupts (HWI) are the
i iti l i t t i tiinitial interrupt service routines 2. Software Interrupts (SWI) are short and
light threads usually initiated by thelight threads usually initiated by the HWI
3 A Task is a “permanent” thread that Priority
3. A Task is a permanent thread that wakes up when it has data to process, goes to sleep after finishing processing
P
and continue until it is closed4. Idle – lowest priority task
TI‐RTOS HWI (Hardware Interrupt)• Starts as soon as interrupt occurs. But start can be delayed if either of the following occurs:– Another HWI executes– The application intervenes (limited time)pp ( )
• Interrupts can be blocked, latched, and/or nested,• Software controls:• Software controls:
– The maximum latency for the start of HWITh i it f HWI d b h i– The priority of HWI and behavior
• HWI always has higher priority than SWI.
CCS GUI Interface to Configure HWI
TI‐RTOS SWI (Software Interrupt)• Regarded as the processing part of an ISR (Interrupt Service Routine)( p )
• Short and light execution model with full priority scheme:priority scheme:– SWI is preempted when higher priority SWI is scheduled (and for all HWI)
– Fast‐switch context mechanism (small memory footprint)
• Software controls the priority of SWISoftware controls the priority of SWI.But SWI always has higher priority than Task
• All HWIs and SWIs share the same stack
CCS GUI Interface to Configure SWI
TI‐RTOS Tasks• Main processing parts of execution:
– Runs in infinite loopRuns in infinite loop– Sleeps until external event wakes it up.After finishing e ec tion goes back to sleep– After finishing execution, goes back to sleep.
• Full priority scheme:– Task is preempted when higher priority task is scheduled (for all HWI or SWI)( )
– Fast‐switch context mechanism: Each task has its own stackown stack.
• Software controls the priority of Task
CCS GUI Interface to Configure Task
TI‐RTOS Clock• Generate periodic “ticks” to follow periodic events
• Can be used for time slice operationh h d ( h l bl )• Uses the hardware times (when it is available)
• Easily configured either by the GUI or withEasily configured either by the GUI or with code
Clock Function
CCS GUI Interface
Modifies theModifies the cfg Script