Zephyr System Requirements

UID:

VERSION:

CLASSIFICATION:

PREFIX:

ZEP-SYRS-

Type	Level	UID	STATUS	TYPE	COMPONENT	REFS	Title	Statement	USER_STORY
TEXT								SPDX-License-Identifier: Apache-2.0
SECTION	1						Atomic Service
REQUIREMENT	1.1	ZEP-SYRS-26	Draft	Functional	Atomic Service	Children: ZEP-SRS-26-1 Atomic variable ZEP-SRS-26-2 Atomic value ZEP-SRS-26-3 Tearing freedom ZEP-SRS-26-4 Cross-CPU visibility ZEP-SRS-26-5 Indivisibility ZEP-SRS-26-6 Memory ordering ZEP-SRS-26-7 Software implementation fallback ZEP-SRS-26-8 Native atomic instructions ZEP-SRS-26-9 Compute size of atomic variables ZEP-SRS-26-10 Define an array of atomic variables ZEP-SRS-26-11 Initialize atomic variable ZEP-SRS-26-12 Set atomic variable ZEP-SRS-26-13 Get atomic variable ZEP-SRS-26-14 Atomic bitwise operations ZEP-SRS-26-19 Atomic addition ZEP-SRS-26-21 Atomic subtraction ZEP-SRS-26-23 Atomic compare and set ZEP-SRS-26-24 Atomic clear ZEP-SRS-26-25 Atomic bit operations ZEP-SRS-26-32 Atomic pointer ZEP-SRS-26-33 Atomic pointer value ZEP-SRS-26-34 Initialize atomic pointer ZEP-SRS-26-35 Atomic pointer operations ZEP-SRS-26-40 Usable from threads and interrupt service routines	ZEP-SYRS-26 Atomic Service	The Zephyr RTOS shall provide an interface to perform atomic operations on variables, guaranteeing that all reads and writes are free from tearing across all processors.
REQUIREMENT	2	ZEP-SYRS-3	Draft	Functional	C Library	Children: ZEP-SRS-18-1 Formatted output ZEP-SRS-18-2 Floating Point Math Support ZEP-SRS-18-3 Boolean Primitives Support ZEP-SRS-18-4 Standard Unix time interface ZEP-SRS-18-5 Strings support ZEP-SRS-18-6 Moving/copying regions of memory ZEP-SRS-18-7 I/O based interface ZEP-SRS-18-8 C99 integer types ZEP-SRS-18-9 Standard System Error Numbers (IEEE Std 1003.1-2017) ZEP-SRS-18-10 Document set of Zephyr OS required C library functions in Safety Manual ZEP-SRS-18-11 Support external C libraries documentation in Zephyr Safety Manual	ZEP-SYRS-3 Support Subset of Standard C Library	The Zephyr RTOS shall support a subset of the standard C library.	As a Zephyr RTOS user I want to have a selection of standard C library implementations e.g. a full extend and a minimal with a smaller footprint or a particular fast executing implementation.
SECTION	3						Condition Variables
REQUIREMENT	3.1	ZEP-SYRS-21	Draft	Non-Functional	Condition Variables	Children: ZEP-SRS-21-1 Dynamic initialization of condition variables ZEP-SRS-21-2 Static initialization of condition variables ZEP-SRS-21-3 Signal one waiting thread ZEP-SRS-21-4 Signal multiple waiting threads ZEP-SRS-21-5 Wait on a condition variable ZEP-SRS-21-6 Wait timeout on a condition variable ZEP-SRS-21-7 Wait timeout occurence ZEP-SRS-21-8 Release mutex on wait ZEP-SRS-21-9 Unblock a waiting thread	ZEP-SYRS-21 Condition Variables	The Zephyr RTOS shall provide a framework to synchronize threads based on a condition variable.
REQUIREMENT	4	ZEP-SYRS-4	Draft	Functional	Device Drivers	Children: ZEP-SRS-14-1 Device Driver Abstraction ZEP-SRS-14-2 Expose kernel to hardware interrupts	ZEP-SYRS-4 Device Driver Abstraction	The Zephyr RTOS shall provide a framework for managing device drivers and peripherals.	As a Zephyr RTOS user I want my application to be portable between different MCU architectures (ARM Cortex-M/A, Intel x86, RISCV etc.) and MCU vendors (STM, NXP, Intel, etc.) without having to change the MCU peripherals access.
REQUIREMENT	5	ZEP-SYRS-5	Draft	Functional	Exception and Error Handling	Children: ZEP-SRS-16-1 Fatal Exception Error Handler ZEP-SRS-16-2 Default handler for fatal errors ZEP-SRS-16-3 Assigning a specific handler ZEP-SRS-16-4 Assigning a specific handler for a fatal error	ZEP-SYRS-5 Fatal error and exception handling	The Zephyr RTOS shall provide a framework for error and exception handling.	As a Zephyr RTOS user I want errors and exceptions to handled and react according to my applications requirements (e.g. reach/establish the applications safety state).
SECTION	6						FIFOs
REQUIREMENT	6.1	ZEP-SYRS-24	Draft	Functional	FIFOs	Children: ZEP-SRS-24-1 FIFO definition at compile time ZEP-SRS-24-2 FIFO cancel waiting thread ZEP-SRS-24-3 FIFO enqueue item to the back ZEP-SRS-24-4 FIFO implicit memory allocation ZEP-SRS-24-5 FIFO append item list to the back ZEP-SRS-24-6 FIFO append and empty item list to the back ZEP-SRS-24-7 FIFO get and dequeue item from front ZEP-SRS-24-8 FIFO empty check ZEP-SRS-24-9 FIFO peek item at front ZEP-SRS-24-10 FIFO peek item at back	ZEP-SYRS-24 FIFOs data passing	The Zephyr RTOS shall implement FIFOs which can be used to pass data between threads and interrupt service routines.
REQUIREMENT	7	ZEP-SYRS-6	Draft	Functional	File Systems	Children: ZEP-SRS-17-1 Create file ZEP-SRS-17-2 Open files ZEP-SRS-17-3 Read files ZEP-SRS-17-4 Write to files ZEP-SRS-17-5 Close file ZEP-SRS-17-6 Move file ZEP-SRS-17-7 Delete file	ZEP-SYRS-6 Common File system operation support	The Zephyr RTOS shall provide a framework for managing file system access.	As a Zephyr RTOS user I want a posix / c like file system access to store data.
REQUIREMENT	8	ZEP-SYRS-1	Draft	Functional	Hardware Architecture Interface	Children: ZEP-SRS-19-1 Atomic Operations ZEP-SRS-19-2 Thread Context Switching ZEP-SRS-19-3 Software Exceptions ZEP-SRS-19-4 Processor Mode Support ZEP-SYRS-2 Support multiprocessor management	ZEP-SYRS-1 Architecture Layer Interface	The Zephyr RTOS shall provide a framework to communicate with a set of hardware architectural services.	As a Zephyr RTOS user I want to be able to easily switch my application to a different MCU architecture (x86, ARM Cortex-M/A, RISCV etc.).
REQUIREMENT	9	ZEP-SYRS-2	Draft	Functional	Hardware Architecture Interface	Parents: ZEP-SYRS-1 Architecture Layer Interface	ZEP-SYRS-2 Support multiprocessor management	The Zephyr RTOS shall support symmetric multiprocessing on multiple cores.	As a Zephyr RTOS user I want to use Zephyr OS on multi core (SMP-)MCUs/MPUs.
REQUIREMENT	10	ZEP-SYRS-7	Draft	Functional	Interrupts	Children: ZEP-SRS-7-1 Installing static IRQ service routines (ISR). ZEP-SRS-7-2 Static IRQ initial status. ZEP-SRS-7-3 Installing direct IRQ service routines (ISR). ZEP-SRS-7-4 Direct IRQ initial status. ZEP-SRS-7-5 Installing dynamic IRQ service routines (ISR). ZEP-SRS-7-6 Dynamic IRQ initial status. ZEP-SRS-7-7 Uninstalling dynamic IRQ service routines (ISR). ZEP-SRS-7-8 Global IRQ disable ZEP-SRS-7-9 Global IRQ enable ZEP-SRS-7-10 Specific IRQ disable ZEP-SRS-7-11 Specific IRQ enable ZEP-SRS-7-12 IRQ Enabled status ZEP-SRS-7-13 ISR Context status ZEP-SRS-7-14 Multi-level interrupts ZEP-SRS-7-15 Interrupt service routine invocation ZEP-SRS-7-16 Interrupt service routine parameter ZEP-SYRS-20 Direct ISR, Platform Specific helpers.	ZEP-SYRS-7 Interrupt Management	The Zephyr RTOS shall provide a framework for interrupt and interrupt service routine management.	As the Zephyr RTOS user I want the Kernel to provide abstracted interfaces to the platform enabling me to implement standard interrupts interrupt service routines without detailed knowledge of the platform architecture and programming model.
REQUIREMENT	11	ZEP-SYRS-20	Draft	Functional	Interrupts	Parents: ZEP-SYRS-7 Interrupt Management	ZEP-SYRS-20 Direct ISR, Platform Specific helpers.	Zephyr RTOS shall support development of direct ISRs by providing platform specific code fragments and factory functions including, minimal header instructions, minimal footer instructions, low power termination, and ISR construction.	As the Zephyr RTOS user I want the Kernel to provide support for implementing standard low latency and low power interrupt service routines without detailed knowledge of the platform architecture and programming model.
SECTION	12						LIFOs
REQUIREMENT	12.1	ZEP-SYRS-23	Draft	Functional	LIFOs	Children: ZEP-SRS-23-1 LIFO definition at compile time ZEP-SRS-23-2 LIFO enqueue item to the back ZEP-SRS-23-3 LIFO implicit memory allocation ZEP-SRS-23-4 LIFO get and dequeue item from front	ZEP-SYRS-23 LIFOs data passing	The Zephyr RTOS shall implement a LIFOs which can be used to pass data between threads and interrupt service routines.
REQUIREMENT	13	ZEP-SYRS-8	Draft	Functional	Logging	Children: ZEP-SRS-11-1 Dedicated Logging Thread Support ZEP-SRS-11-2 Logs available for post processing ZEP-SRS-11-3 Formatting log messages ZEP-SRS-11-4 Logging Filtering Support ZEP-SRS-11-5 Multiple Backend Logging Support ZEP-SRS-11-6 Deferred Logging Support	ZEP-SYRS-8 Logging	The Zephyr RTOS shall provide a framework for logging events.	As a Zephyr RTOS user I want to be able to log application defined events as well as framework exceptions.
SECTION	14						Mailboxes
REQUIREMENT	14.1	ZEP-SYRS-25	Draft	Functional	Mailboxes	Children: ZEP-SRS-25-1 Mailbox Initialization At Run Time ZEP-SRS-25-2 Mailbox Initialization At Compile Time ZEP-SRS-25-3 Message Size Support ZEP-SRS-25-4 Mailbox Data Transfer ZEP-SRS-25-5 Synchronous Message Sending ZEP-SRS-25-6 Synchronous Send Timeout Handling ZEP-SRS-25-7 Asynchronous Message Sending ZEP-SRS-25-8 Asynchronous Completion Signaling ZEP-SRS-25-9 Message Reception ZEP-SRS-25-10 Message Data Retrieval ZEP-SRS-25-11 Message Reception Blocking ZEP-SRS-25-12 Message Reception Timeout Handling ZEP-SRS-25-13 Non-Anonymous Messaging ZEP-SRS-25-14 Priority-Based Message Delivery ZEP-SRS-25-15 Priority-Based Message Delivery ZEP-SRS-25-16 Mailbox Quantity Support ZEP-SRS-25-17 Invalid Parameter Handling	ZEP-SYRS-25 Mailboxes	The Zephyr RTOS shall provide a framework to pass messages of arbitrary size between threads.
REQUIREMENT	15	ZEP-SYRS-9	Draft	Functional	Memory Management	Children: ZEP-SRS-9-1 Dynamic Memory Allocation ZEP-SRS-9-2 Memory Slab Object ZEP-SRS-8-1 Memory Protection ZEP-SRS-8-2 Granting access to kernel objects ZEP-SRS-8-3 Separation between user and kernel threads for memory access ZEP-SRS-8-4 Safely handle unimplemented calls or invalid system calls ZEP-SRS-8-5 Response to invalid system call IDs ZEP-SRS-8-6 Prevent user threads creating higher priority threads ZEP-SRS-8-7 Revoking threads permissions on a kernel object ZEP-SRS-8-8 Prevent user threads creating supervisor threads ZEP-SRS-8-9 Reduced Privilege Level Threads ZEP-SRS-8-10 User Mode Threads Performing Privileged Operations ZEP-SRS-8-11 User mode handling of detected stack overflow ZEP-SRS-8-12 Stack Overflow Detection ZEP-SRS-8-13 Boot Time Memory Access Policy ZEP-SRS-8-14 System Call Handler Functions ZEP-SRS-8-15 System Call C strings in user mode ZEP-SRS-8-16 Tracking kernel objects in used by user mode threads ZEP-SRS-8-17 Granting threads access to specific memory ZEP-SRS-8-18 Assigning memory pools to act as a thread resource pool	ZEP-SYRS-9 Memory Management framework	The Zephyr RTOS shall support a memory management framework.	As a Zephyr RTOS user I want memory to be allocated and protected to my application threads preventing mistakenly access to foreign memory as far as the hardware allows.
SECTION	16						Message Queues
REQUIREMENT	16.1	ZEP-SYRS-31	Draft	Functional	Message Queues	Children: ZEP-SRS-31-1 Message queue definition at compile time ZEP-SRS-31-2 Message queue initialization at run time ZEP-SRS-31-3 Message queue initialization at run time with a dynamically allocated buffer ZEP-SRS-31-4 Sending a message to the back ZEP-SRS-31-5 Sending a message to the front ZEP-SRS-31-6 Send timeout ZEP-SRS-31-7 Send timeout expiry ZEP-SRS-31-8 Receiving a message ZEP-SRS-31-9 Message retrieval order ZEP-SRS-31-10 Receive timeout ZEP-SRS-31-11 Receive timeout expiry ZEP-SRS-31-12 Peeking at a message ZEP-SRS-31-13 Peeking at a message by index ZEP-SRS-31-14 Purging a message queue ZEP-SRS-31-19 Purging with blocked senders ZEP-SRS-31-15 Querying used message count ZEP-SRS-31-16 Querying free message count ZEP-SRS-31-21 Querying message queue attributes ZEP-SRS-31-17 Releasing a dynamically allocated message queue buffer ZEP-SRS-31-20 Releasing a buffer with waiting threads	ZEP-SYRS-31 Message Queues	The Zephyr RTOS shall provide a mechanism for threads and interrupt service routines to asynchronously exchange fixed-size data items.
SECTION	17						Multi core and SMP
REQUIREMENT	17.1	ZEP-SYRS-11	Draft	Functional	SMP and Multi core		ZEP-SYRS-11 Multiple CPU scheduling	The Zephyr RTOS shall support scheduling of threads on multiple hardware CPUs.	As a Zephyr RTOS user I want Zephyr OS to run on MCUs/CPUs with one or more CPU cores.
REQUIREMENT	17.2	ZEP-SYRS-12	Draft	Functional	SMP and Multi core		ZEP-SYRS-12 Scheduling	The Zephyr RTOS shall provide an interface to assign a thread to a specific CPU.	As a Zephyr RTOS user, I want to be able to control which thread will run on which CPU.
REQUIREMENT	18	ZEP-SYRS-10	Draft	Functional	Power Management	Children: ZEP-SRS-13-1 Power State Control ZEP-SRS-13-2 Power Management ZEP-SRS-13-3 Notification of changes to system power states	ZEP-SYRS-10 Power Management	The Zephyr RTOS shall provide an interface to control hardware power states.	As a Zephyr RTOS user I want to be able to control the power mode of the MCU and its peripherals to take advantage of the hardware features and to be able to implement low power or battery driven long life applications.
SECTION	19						Pipes
REQUIREMENT	19.1	ZEP-SYRS-32	Draft	Functional	Pipes	Children: ZEP-SRS-32-1 Pipe definition at compile time ZEP-SRS-32-2 Pipe initialization at run time ZEP-SRS-32-3 Writing data to a pipe ZEP-SRS-32-4 Reading data from a pipe ZEP-SRS-32-5 Pipe write timeout ZEP-SRS-32-11 Pipe write timeout expiry ZEP-SRS-32-6 Pipe read timeout ZEP-SRS-32-12 Pipe read timeout expiry ZEP-SRS-32-7 Resetting a pipe ZEP-SRS-32-8 Closing a pipe ZEP-SRS-32-9 Operations on a closed pipe ZEP-SRS-32-10 Operations interrupted by a reset	ZEP-SYRS-32 Pipes	The Zephyr RTOS shall provide a mechanism to transfer a stream of bytes between threads.
SECTION	20						Polling
REQUIREMENT	20.1	ZEP-SYRS-33	Draft	Functional	Polling	Children: ZEP-SRS-33-1 Waiting for any of multiple poll events ZEP-SRS-33-2 Supported poll event conditions ZEP-SRS-33-11 Poll event initialization ZEP-SRS-33-3 Poll wait timeout ZEP-SRS-33-4 Reporting ready poll events ZEP-SRS-33-5 Poll signal object ZEP-SRS-33-6 Poll signal initialization ZEP-SRS-33-7 Raising a poll signal ZEP-SRS-33-8 Persistence of a raised poll signal ZEP-SRS-33-9 Resetting a poll signal ZEP-SRS-33-10 Querying a poll signal	ZEP-SYRS-33 Polling	The Zephyr RTOS shall provide a mechanism for a thread to wait concurrently for any one of multiple conditions to be satisfied.
SECTION	21						Queues
REQUIREMENT	21.1	ZEP-SYRS-22	Draft	Functional	Queues	Children: ZEP-SRS-20-1 Queue definition at compile time ZEP-SRS-20-2 Queue definition at run time. ZEP-SRS-20-3 Queue enqueue item to the back ZEP-SRS-20-4 Queue enqueue item to the front ZEP-SRS-20-5 Queue remove item ZEP-SRS-20-6 Queue get and dequeue item from front ZEP-SRS-20-7 Queue empty check ZEP-SRS-20-8 Queue peek item at back ZEP-SRS-20-9 Queue peek item at front ZEP-SRS-20-10 Queue insert ZEP-SRS-20-11 Queue append item list to the back ZEP-SRS-20-12 Queue append and empty item list to the back ZEP-SRS-20-13 Queue append unique data item ZEP-SRS-20-14 Queue implicit memory allocation	ZEP-SYRS-22 Queues data passing	The Zephyr RTOS shall implement a queue which can be used to pass data between threads and interrupt service routines.
SECTION	22						Stacks
REQUIREMENT	22.1	ZEP-SYRS-30	Draft	Functional	Stacks	Children: ZEP-SRS-30-1 Stack definition at compile time ZEP-SRS-30-2 Stack initialization at run time with an user-defined memory area ZEP-SRS-30-3 Stack initialization at run time with automatically allocated memory area ZEP-SRS-30-4 Releasing a dynamically allocated stack buffer ZEP-SRS-30-5 Push an item to the stack ZEP-SRS-30-6 Pop an item from the stack ZEP-SRS-30-7 Pushing onto a full stack ZEP-SRS-30-8 Concurrent access protection ZEP-SRS-30-9 Stack data retrieval with timeout ZEP-SRS-30-11 Stack pop timeout expiry	ZEP-SYRS-30 Stacks	The Zephyr RTOS shall implement a stack which can be used to pass data between threads and interrupt service routines.
SECTION	23						Thread Synchronization
REQUIREMENT	23.1	ZEP-SYRS-13	Draft	Functional	Mutex	Children: ZEP-SRS-6-1 Mutex Kernel Object ZEP-SRS-6-2 Mutex definition at compile time ZEP-SRS-6-3 Mutex definition at run time ZEP-SRS-6-4 Locking a mutex ZEP-SRS-6-5 Locking an unowned mutex ZEP-SRS-6-6 Locking a mutex owned by another thread ZEP-SRS-6-7 Mutex lock timeout ZEP-SRS-6-8 Mutex lock timeout expiry ZEP-SRS-6-9 Recursive mutex locking ZEP-SRS-6-10 Unlocking a mutex ZEP-SRS-6-11 Unlocking by a non-owner ZEP-SRS-6-12 Priority inheritance	ZEP-SYRS-13 Mutex	The Zephyr RTOS shall provide an interface for managing communication between threads.	As a Zephyr RTOS user I want to able to exchange information between threads in a thread-safe manner guaranteeing data consistence.
REQUIREMENT	23.2	ZEP-SYRS-14	Draft	Functional	Semaphore	Children: ZEP-SRS-5-1 Counting Semaphore Definition At Compile Time ZEP-SRS-5-2 Counting Semaphore Definition At Run Time ZEP-SRS-5-3 Maximum limit of a semaphore ZEP-SRS-5-4 Initialialization with maximum count value ZEP-SRS-5-5 Initial semaphore value ZEP-SRS-5-6 Semaphore acquisition mechanism ZEP-SRS-5-7 Semaphore acquisition with count greater than zero ZEP-SRS-5-8 Semaphore acquisition with zero count ZEP-SRS-5-9 Semaphore acquisition timeout ZEP-SRS-5-10 Semaphore acquisition timeout error handling ZEP-SRS-5-11 Semaphore acquisition no wait error handling ZEP-SRS-5-12 Semaphore release ZEP-SRS-5-13 Semaphore count increment on release ZEP-SRS-5-14 Highest-priority waiter unblocked on release ZEP-SRS-5-15 Checking semaphore count ZEP-SRS-5-16 Semaphore reset ZEP-SRS-5-17 Semaphore acquisitions abort after reset ZEP-SRS-5-18 Semaphore Initialization Option Validation ZEP-SRS-5-19 Semaphore release at maximum count ZEP-SRS-5-20 Semaphore operations from interrupt context	ZEP-SYRS-14 Counting Semaphore	The system shall implement a semaphore synchronization primitive for coordinating access to shared resources among multiple threads.
SECTION	24						Threads
REQUIREMENT	24.1	ZEP-SYRS-15	Draft	Functional	Threads	Children: ZEP-SRS-2-4 Scheduling a thread based on an event ZEP-SRS-1-1 Creating threads ZEP-SRS-1-3 Suspending a thread ZEP-SRS-1-4 Resuming a suspended thread ZEP-SRS-1-5 Resuming a suspended thread after a timeout ZEP-SRS-1-6 Deleting a thread ZEP-SRS-1-7 Thread states ZEP-SRS-1-8 Thread stack objects ZEP-SRS-1-9 Thread privileges ZEP-SRS-1-11 Thread Options ZEP-SRS-1-12 Thread Custom Data	ZEP-SYRS-15 Thread support	The Zephyr RTOS shall support threads.	As a Zephyr RTOS user, I want to be able to have support for the kernel objects named threads for processing work.
REQUIREMENT	24.2	ZEP-SYRS-16	Draft	Functional	Threads	Children: ZEP-SRS-1-1 Creating threads ZEP-SRS-1-3 Suspending a thread ZEP-SRS-1-4 Resuming a suspended thread ZEP-SRS-1-5 Resuming a suspended thread after a timeout ZEP-SRS-1-6 Deleting a thread ZEP-SRS-1-7 Thread states ZEP-SRS-1-8 Thread stack objects ZEP-SRS-1-9 Thread privileges ZEP-SRS-1-10 Scheduling multiple threads ZEP-SRS-1-11 Thread Options ZEP-SRS-1-12 Thread Custom Data	ZEP-SYRS-16 Thread management	The Zephyr RTOS shall provide a framework for managing multiple threads of execution.	As a Zephyr RTOS user, I want to be able to manage the execute of multiple threads with different priorities.
REQUIREMENT	24.3	ZEP-SYRS-17	Draft	Functional	Threads	Children: ZEP-SRS-1-2 Setting thread priority	ZEP-SYRS-17 Thread priority	Threads shall have a priority.	As a Zephyr RTOS user, I want to be able to give my threads different priorities for execution.
REQUIREMENT	25	ZEP-SYRS-18	Draft	Functional	Timers	Children: ZEP-SRS-4-1 Timer definition at compile time ZEP-SRS-4-2 Timer expiry function ZEP-SRS-4-3 Timer stop function ZEP-SRS-4-4 Timer definition at run time ZEP-SRS-4-5 Timer start ZEP-SRS-4-6 Timer stop ZEP-SRS-4-7 Timer status ZEP-SRS-4-8 Timer status reinitialization ZEP-SRS-4-9 Timer thread synchronization ZEP-SRS-4-10 Timer next expiration time in system ticks ZEP-SRS-4-11 Timer remaining time until expiration in system ticks ZEP-SRS-4-12 Timer remaining time until expiration in milliseconds ZEP-SRS-4-13 Timer set user data ZEP-SRS-4-14 Timer get user data ZEP-SRS-4-15 Timer expire functions in interrupt context	ZEP-SYRS-18 Timers	The Zephyr RTOS shall provide a framework for managing time-based events.	As a Zephyr RTOS user, I want to start, suspend, resume and stop timers which shall trigger an event on a set expiration time.
REQUIREMENT	26	ZEP-SYRS-19	Draft	Functional	Tracing	Children: ZEP-SRS-10-1 Initializing a trace ZEP-SRS-10-2 Triggering a trace ZEP-SRS-10-3 Dumping trace results ZEP-SRS-10-4 Removing trace data ZEP-SRS-10-5 Tracing Object Identification ZEP-SRS-10-6 Tracing Non-Interference	ZEP-SYRS-19 Tracing	Zepyhr shall provide a framework mechanism for tracing low level system operations (NOTE: system calls, interrupts, kernel calls, thread, synchronization, etc.).	As a Zephyr RTOS user, I want to be able to trace different OS operations.