FPGA Design Services with GeMRTOS

FPGA design services built on a multiprocessor RTOS we develop ourselves

We design embedded systems on Altera FPGA devices, and we build them on
GeMRTOS — the real-time operating system we develop and maintain. That
means there is no handover between the company that licenses you an RTOS
and the team that has to make it work in your product. The people who
write the kernel are the people who design your application on it.

GeMRTOS is available two ways, together or separately: as an
IP licence, and as a custom application-design
service.

Designed for multiprocessor operation from the start

GeMRTOS — Generic Embedded Multiprocessor RTOS — was not a
single-processor RTOS later adapted to run on several cores. Its
scheduling model is part of the kernel’s own data structures, so a design
can mix strategies inside one system:

Partitioned — pin a task, or a whole scheduling
list, to specific processors when its timing must be isolated from
everything else.
Global — let tasks float across all available
processors when throughput matters more than which core runs
what.
Concurrency-limited — cap how many tasks from a
group may run at once, independently of how many processors
exist, when a shared resource is the real constraint.

Generic in the name refers to supporting arbitrary
applications on that multiprocessor architecture — not to being a
general-purpose kernel with multiprocessor support added on.

Timing behaviour that comes from hardware

The GeMRTOS controller is an FPGA IP component. It arbitrates system
time, external events and mutual exclusion between processors in
hardware.

The practical consequence is what matters: there is no periodic
scheduler tick and no polling loop. System functions execute only
when system state actually needs to change. Response timing to an event
therefore does not depend on where the next tick happens to fall, or on
how busy the software is at that moment — the arbitration is not competing
for the processor it is arbitrating.

This is the property that makes timing behaviour something you can
reason about and argue for, rather than measure and hope.

Evaluate the programming model before committing to hardware

GeMRTOS ships with ten complete example applications — task models and
delays, semaphores and mutexes, resource contention, message queues as
publish/subscribe, hardware triggers and interrupt service tasks,
multiprocessor scheduling, fault handling, and a networked HTTP server.
Each one carries an automated check on its own expected output.

They are delivered running on development boards and in a
Windows simulation layer that needs no FPGA. An engineer can read the
examples, run them, and judge the programming model on their own machine
before any board is bought or any commitment is made.

An engineering record you can audit

Long-lived embedded products are maintained by people who were not in
the room when the decisions were made. GeMRTOS is documented accordingly:
a single user and development manual covering architecture, API and
workflow, per-example documentation, and a maintained record of design
decisions — including the ones later superseded, with the reasoning that
led to each.

That record is why a question like “why does it behave this way?” has an
answer years later, instead of an archaeology exercise.

Integrated through Altera’s own design flow

The kernel and controller are delivered as Platform Designer IP
components and added to a design through the standard Quartus® Prime flow. There
is no bespoke toolchain to adopt and no parallel build system to maintain.
GeMRTOS targets Nios V today, with the Nios II build path still
supported.

We are an Altera Solution Acceleration Partner.

How an engagement works

Tell us what the system has to do — the timing
constraints that matter, what runs concurrently, and what must never
be late.
We design the control layer — task decomposition,
synchronisation, the scheduling model, and how faults are detected
and handled.
You keep the source — the application is built on a
licensed IP core with documented interfaces, not on a black box you
cannot maintain without us.

Engagements range from a scoped design review through to designing and
delivering the complete control layer of a product.

Talk to us about your system

Tell us what you are building and what its timing requirements are, and
we will tell you plainly whether GeMRTOS is the right foundation for it —
including when it is not.