In embedded systems, task categorization and task states are critical for achieving efficient and

predictable system performance. Task categorization helps in organizing tasks based on functionality,
priority, and timing requirements, while understanding task states allows for smoother transitions
and ensures tasks are executed efficiently.

Task Categorization in Embedded Systems

1. Periodic Tasks:

o Description: Periodic tasks run at regular intervals. They have a defined cycle time
and are often synchronized with a clock or timer.

o Example: Reading sensor data at fixed intervals, such as reading temperature data
every second.

2. Aperiodic Tasks:

o Description: These tasks occur irregularly and are typically triggered by external
events.

o Example: Processing an interrupt from a user input button press.

3. Sporadic Tasks:

o Description: Sporadic tasks are similar to aperiodic tasks but have minimum inter-
arrival times. They occur irregularly but with a minimum time constraint between
occurrences.

o Example: Handling errors or warnings in systems where fault conditions are rare but
must be addressed promptly.

4. Background Tasks:

o Description: These tasks run with the lowest priority and are only executed when
the processor is idle.

o Example: System diagnostics or memory clean-up routines.

5. Real-Time Tasks:

o Description: Real-time tasks require strict timing constraints and are classified into
hard and soft real-time tasks.

 Hard Real-Time Tasks: Must be completed within a strict deadline; failure

can lead to catastrophic outcomes.

 Soft Real-Time Tasks: Preferably meet their deadlines but can tolerate
occasional delays.

o Example: Hard real-time: airbag deployment in cars; Soft real-time: video playback
buffering.

6. System-Level Tasks:

o Description: These are high-priority tasks that handle essential operations, such as
power management, memory management, or inter-process communication.
 o Example: Allocating memory or handling low-level hardware functions.

Task States in Embedded Systems

Embedded systems typically have a limited set of task states that outline the various stages a task
goes through during its lifecycle. The primary states are as follows:

1. Ready State:

o Description: In the ready state, the task is prepared to run and waiting for the CPU to
become available. Multiple tasks can be in the ready state, with a scheduler
determining the next task to execute based on priority.

o Example: A task that has completed an I/O operation and is waiting to run again.

2. Running State:

o Description: In the running state, the task is actively executing on the CPU. Only one
task can be in the running state on a single-core CPU.

o Example: A task that reads temperature data from a sensor and processes it for
display.

3. Blocked/Waiting State:

o Description: In the blocked state, the task is waiting for an event or resource, such as
I/O completion or a signal from another task. It cannot proceed until the condition is
met.

o Example: A task that is waiting for data from a sensor.

4. Suspended State:

o Description: In the suspended state, the task is paused or put on hold. Unlike the
blocked state, where the task waits for a specific condition, a suspended task must
be explicitly resumed by the system or another task.

o Example: A diagnostic task suspended to allow higher-priority real-time tasks to

execute.

5. Terminated State:

o Description: In this state, the task has completed its execution and is no longer
active. The system may deallocate its resources, or it may be restarted if required.

o Example: A task that completes a one-time system initialization and then terminates.

Task State Transitions in Embedded Systems

The embedded system's scheduler controls task transitions between states to meet timing
requirements and optimize performance. Below are common transitions:

1. Ready to Running:

o The scheduler selects a task from the ready queue based on priority and places it in
the running state.
 2. Running to Blocked:

o A running task may move to a blocked state if it requires resources that are not
available, such as waiting for I/O completion.

3. Running to Ready (Preemption):

o If a higher-priority task becomes ready while a lower-priority task is running, the

scheduler preempts the running task, moving it back to the ready state.

4. Blocked to Ready:

o Once the required resource or event is available, a blocked task moves back to the
ready state.

5. Running to Suspended:

o The task voluntarily suspends itself or is suspended by the system, moving it out of
the active scheduling cycle.

6. Suspended to Ready:

o A suspended task can resume operation by moving back to the ready state when the
condition allowing its suspension is cleared.

7. Running to Terminated:

o A task moves to the terminated state after completing its execution, freeing
resources for other tasks.

Characteristics in Embedded Task Management

 Resource Constraints.

 Determinism

 Interrupts and ISRs

 Context Switching

In summary, task categorization and states are crucial in embedded systems to ensure real-time
performance, efficiency, and reliability. By carefully managing task states and employing appropriate
scheduling strategies, embedded systems can meet stringent timing and resource constraints critical
to their operation.

In semaphore-based synchronization, several key functions (operations) are used to manage

and control the semaphore's state. These functions help ensure safe access to shared
resources, prevent race conditions, and maintain proper task synchronization. Here are the
primary functions used in semaphore operations and their explanations:
1. Wait (P Operation)
 Function: The wait function, also known as the P operation (from the Dutch word
“proberen,” meaning "to test"), is used to request access to a resource protected by
a semaphore.
 Mechanism:
o When a task or process performs a wait on a semaphore, the semaphore's
count is checked.
o If the count is greater than zero, it is decremented by one, allowing the task
to proceed, indicating that a resource instance has been allocated.
o If the count is zero, the task is put into a waiting (blocked) state until the
resource becomes available.
 Purpose: Prevents multiple tasks from entering a critical section simultaneously,
ensuring mutual exclusion and resource availability.
 Example: In a system with a single printer (binary semaphore), a task calling wait
would decrement the semaphore count to zero, preventing any other task from
accessing the printer until it’s done.
2. Signal (V Operation)
 Function: The signal function, also known as the V operation (from the Dutch word
“verhogen,” meaning "to increment"), is used to release a resource or indicate that a
task has finished using it.
 Mechanism:
o When a task completes its use of a shared resource, it performs a signal
operation, which increments the semaphore's count by one.
o If other tasks are waiting (blocked) for access to the resource, one of them
will be awakened and allowed to access the resource.
 Purpose: Releases the resource for other tasks, maintaining a balanced use of the
shared resource.
 Example: After a task finishes using the printer, it calls signal to increment the
semaphore count, allowing another waiting task to use the printer.
3. Initialize (Semaphore Initialization)
 Function: The initialize function sets the initial count or value of a semaphore. This
count determines the number of concurrent accesses allowed to a particular
resource.
 Mechanism:
 o When a semaphore is created, it is initialized with a count that represents the
number of available instances of the resource it controls.
o For a binary semaphore (mutex), this count is typically set to 1, allowing only
one task at a time. For a counting semaphore, it can be set to any positive
integer, indicating the number of resources available.
 Purpose: Prepares the semaphore for managing access to a resource by setting an
appropriate initial count.
 Example: If a semaphore is managing access to three identical machines, it would be
initialized with a count of 3, allowing three concurrent accesses.
4. Timed Wait (Optional)
 Function: In systems that support timed waits, a timed wait function is a variant of
the wait function, allowing a task to wait for a resource up to a specified time limit.
 Mechanism:
o A task requests access to a resource with a specified timeout value.
o If the semaphore is not available within the given time frame, the task exits
the wait state and continues its execution, handling the timeout scenario.
 Purpose: Useful in real-time or time-sensitive applications where tasks cannot afford
to wait indefinitely.
 Example: A task requests access to a database but will only wait up to 5 seconds. If
access is not granted in that period, the task continues or handles the resource
unavailability.

UNIT III PART C 2ND

Task
In embedded systems, a task is a fundamental unit of work, often defined by a sequence of
operations or functions that the system must perform to achieve a specific goal. Tasks are
managed by a real-time operating system (RTOS) to ensure they are scheduled and executed
with precise timing and deterministic behavior, which is crucial for real-time embedded
applications.
Characteristics of a Task
 Independent Execution: Tasks execute independently, though they can communicate
or synchronize with other tasks through various inter-process communication (IPC)
mechanisms.
 Priority Levels: Tasks can have different priority levels, allowing critical tasks to pre-
empt less important tasks.
  Execution Modes: Tasks in embedded systems may run periodically (at fixed
intervals), on-demand, or in response to external events.
 Limited Stack and Heap Usage: As tasks run in memory-constrained environments,
their memory usage is carefully managed.
Types of Tasks
1. Periodic Tasks:
o Definition: Executed at regular intervals based on a timer or clock tick.
o Purpose: Used in scenarios where repeated actions are required at consistent
intervals.
o Example: An embedded temperature monitoring task that reads sensor data
every second.
2. Aperiodic Tasks:
o Definition: Triggered by external events rather than a timer.
o Purpose: Suitable for handling unpredictable actions, such as user
interactions or hardware interrupts.
o Example: A task in an automotive system that responds to button presses on
the dashboard.
3. Sporadic Tasks:
o Definition: Like aperiodic tasks but with an upper limit on execution
frequency to avoid system overload.
o Purpose: Manages infrequent events that still need some constraint on how
often they occur.
o Example: A task that logs error events in an industrial control system, which
shouldn’t occur more than once per second.
4. For example: Consider the task Ti with period = 5 and execution time
=3
5. Phase is not given so, assume the release time of the first job as zero.
So the job of this task is first released at t = 0, then it executes for 3s,
and then the next job is released at t = 5, which executes for 3s, and
the next job is released at t = 10. So jobs are released at t = 5k where
k = 0, 1. . . N
 6.

7. Hyper period of a set of periodic tasks is the least common multiple of

all the tasks in that set. For example, two tasks T 1 and T2 having period
4 and 5 respectively will have a hyper period, H = lcm(p1, p2) = lcm(4,
5) = 20. The hyper period is the time after which the pattern of job
release times starts to repeat.

Process
A process is an independent instance of a running program with its own allocated memory
space, resources, and state. In embedded systems, processes are less common than tasks
due to resource limitations but are still used in complex systems where applications require
memory isolation, security, or distinct execution environments.
Characteristics of a Process
 Independent Memory Space: Processes have their own memory, preventing
interference with other processes.
 Resource Allocation: Each process has its own CPU register set, stack, heap, and
other resources.
 Inter-Process Communication (IPC): Processes often communicate with each other
through IPC mechanisms like pipes, shared memory, and message queues.
Types of Processes
1. Foreground Processes:
o Definition: High-priority processes directly engaged with the CPU, often
performing real-time tasks.
o Purpose: Used for critical operations where response times are essential.
o Example: An audio decoding process in an embedded multimedia system that
must play sound without lag.
2. Background Processes:
o Definition: Processes with lower priority, running in the background,
performing less time-sensitive tasks.
 o Purpose: Often handle non-critical functions, like logging or diagnostics.
o Example: A logging process in an embedded IoT sensor that records
environmental data periodically.
3. Daemon Processes:
o Definition: Background processes that run continuously, providing system-
wide services.
o Purpose: Typically handle ongoing maintenance or monitoring functions.
o Example: A network daemon in a networked embedded device, continuously
monitoring for incoming data packets.
Example of Process Usage in Embedded Systems
In a medical embedded system, a foreground process might manage real-time vital signs
monitoring, a background process could handle storage of recorded data, and a daemon
process might ensure network connectivity for data transfer to a healthcare server.

Thread
A thread is the smallest unit of execution within a process, sharing the process’s memory
and resources. Threads are lightweight and are more efficient than processes, making them
ideal for embedded systems where quick context-switching and low resource usage are
required. Multiple threads within a process allow for concurrent execution, helping optimize
processing time and improve responsiveness.
Characteristics of a Thread
 Shared Memory: Threads within the same process share memory space and
resources, allowing fast communication between threads.
 Lightweight: Threads are lighter than processes because they don’t require separate
memory allocation for their data and code.
 Concurrency: Threads allow for parallel operations within a single process, increasing
efficiency.
Types of Threads
1. Kernel-Level Threads:
o Definition: Threads managed by the operating system kernel, providing
precise control and timing.
o Purpose: Essential for systems requiring real-time task management and
priority scheduling.
 o Example: In a real-time operating system (RTOS) for automotive control,
kernel-level threads handle tasks such as braking or acceleration.
2. User-Level Threads:
o Definition: Threads managed by the application, without direct OS
intervention.
o Purpose: Useful in embedded applications without strict timing
requirements, as they are faster to create and manage but lack robustness.
o Example: Threads in a user interface layer of an embedded device that
handle screen rendering and user input processing.
3. Hybrid Threads:
o Definition: A mix of kernel and user-level threads, combining the control of
kernel-level with the flexibility of user-level threads.
o Purpose: Used in complex systems needing both high control and flexibility.
o Example: In an embedded router, hybrid threads may manage high-speed
data handling (kernel) and user configuration settings (user level).
Example of Thread Usage in Embedded Systems
In an industrial robotic arm system, a kernel-level thread could handle precise motion
control in real-time, while a user-level thread could manage communication between the
robotic arm and a control server.