# US 2026/0161445 A1 · Technique to Execute Code Written for an RTOS Environment from a Bare Metal Environment

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 2026/0161445 A1
- Document ID: US20260161445A1
- Status: Published application
- Kind: A1
- Application number: 18/975,177
- Filed: 2024-12-10
- Published: 2026-06-11
- Earliest claimed: 2024-12-10
- Assignees: Silicon Laboratories Inc.
- Applicants: Silicon Laboratories Inc.
- Inventors: Jean Francois Deschenes; Christian Galante; Louis Levesque
- Web page: https://patentgrep.com/patent/US20260161445A1

## CPC

- G06F 9/4484: {Executing subprograms}
- G06F 9/4881: {Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues}
- G06F 9/30043: {LOAD or STORE instructions; Clear instruction}
- G06F 9/4486: {Formation of subprogram jump address}
- G06F 9/45504: {Abstract machines for program code execution, e.g. Java virtual machine [JVM], interpreters or emulators}
- G06F 9/4812: {by interrupt, e.g. masked}
- G06F 9/4843: {by program, e.g. task dispatcher, supervisor, operating system}
- G06F 9/485: {Task life-cycle, e.g. stopping, restarting, resuming execution (G06F9/4881 takes precedence)}
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

A system and method that allows instructions and tasks written for an RTOS environment to be executed in a bare metal environment without any modifications is disclosed. An abstraction layer is used to implement traditional RTOS functions such as blocking and releasing calls. In addition, a pseudo RTOS process is added to the main infinite loop of the bare metal environment which is used to ensure that the various tasks are executed in a sequential manner. Context for each task and for the pseudo RTOS process is stored in a dedicated region of memory and is loaded into the processing unit when needed.

## Claims

### Claim 1

A method to allow a plurality of tasks that are written for a real time operating system (RTOS) environment to execute in a bare metal environment, comprising:
executing an infinite loop that comprises a user application and a pseudo RTOS process;
wherein the pseudo RTOS process cycles through each of the plurality of tasks that are ready to execute; and
wherein when the pseudo RTOS process switches to a first of the plurality of tasks, its context is saved in a first designated region of memory; and
wherein when the first of the plurality of tasks is blocked, the context stored in the first designated region of memory is restored to allow the pseudo RTOS process to continue execution.

### Claim 2 (depends on 1)

The method of claim 1, wherein the pseudo RTOS process loads context stored in a second designated region of memory to switch to the first of the plurality of tasks.

### Claim 3 (depends on 2)

The method of claim 2, wherein setjmp( ) and longjmp( ) instructions are used to save and load context to and from designated regions of memory.

### Claim 4 (depends on 2)

The method of claim 2, wherein the first of the plurality of tasks becomes blocked after performing a pending/blocking call.

### Claim 5 (depends on 4)

The method of claim 4, wherein the pending/blocking call comprises:
performing a computation on a selected construct;
and if the selected construct is not available:
storing context of the first of the plurality of tasks in the second designated region of memory; and
loading the context from the first designated region of memory to switch to the pseudo RTOS process.

### Claim 6 (depends on 5)

The method of claim 5, wherein the pending/blocking call further comprises: indicating that the first of the plurality of tasks is not ready to execute.

### Claim 7 (depends on 5)

The method of claim 5, wherein the first of the plurality of tasks becomes ready after a second of the plurality of tasks executes a post/release call.

### Claim 8 (depends on 7)

The method of claim 7, wherein the post/release call comprises:
performing a computation on the selected construct; and
marking the first of the plurality of tasks as ready.

### Claim 9 (depends on 1)

The method of claim 1, wherein the plurality of tasks utilize RTOS functions, wherein the plurality of tasks utilize RTOS calls that are coded as application programming interfaces (APIs), and an abstraction layer is provided to allow the RTOS functions to be performed in the bare metal environment.

### Claim 10

A method to allow a plurality of tasks that are written for a real time operating system (RTOS) environment to execute in a bare metal environment, comprising:
including RTOS functions in the plurality of tasks, wherein each RTOS call is coded as application programming interfaces (APIs); and
providing an abstraction layer, wherein the abstraction layer comprises instructions that to allow the RTOS functions to be performed in the bare metal environment.

### Claim 11 (depends on 10)

The method of claim 10, wherein one of the RTOS calls comprises a pending/blocking call.

### Claim 12 (depends on 11)

The method of claim 11, wherein the pending/blocking call comprises:
performing a computation on a selected construct;
and if the selected construct is not available:
storing context of a task that is executing in
a second designated region of memory; and
loading context from a first designated region of memory to switch to a pseudo RTOS process.

### Claim 13 (depends on 12)

The method of claim 12, wherein the pending/blocking call further comprises:
indicating that the task is not ready to execute.

### Claim 14 (depends on 10)

The method of claim 10, wherein a pseudo RTOS process is used to cycle through all tasks that are ready to execute to allow each task to execute once.

### Claim 15 (depends on 14)

The method of claim 14, wherein the plurality of tasks and the pseudo RTOS process use setjmp( ) and longjmp( ) instructions to switch context.

### Claim 16 (depends on 10)

The method of claim 10, wherein one of the RTOS calls comprises a post/release call.

### Claim 17 (depends on 16)

The method of claim 16, wherein the post/release call comprises:
performing a computation on a selected construct; and
marking a task or a user application that was waiting on the selected construct as ready to execute.
