Don't see an exact match for your microcontroller part number and compiler vendor choice? These demos can be adapted to any microcontroller within a supported microcontroller family. See the Creating a new FreeRTOS application and Adapting a FreeRTOS Demo documentation pages.
No hardware yet? Don't worry - see the Demo Quick Start page for links to Windows and Linux ports, as well as Arm Cortex-M3 QEMU projects.
The 'Officially Supported' and 'Contributed' FreeRTOS Code page provides a detailed explanation of the differences between officially supported and contributed FreeRTOS ports. Officially supported FreeRTOS demos are provided that target microcontrollers from the following manufacturers:
Cortex-A9 HPS (Hard Processor System) on a Cyclone V SoC
This RTOS demo runs on one core of the hard wired Cortex-A9 processor on a Cyclone V SoC. The demo uses the Atlera SoC Embedded Design Suite (EDS) which includes a special version of ARM's DS-5 Eclipse based development environment with the GCC toolchain.
ARMv8-M/ARM Cortex-M33 Simulator
A pre-configured FreeRTOS project that targets the Keil uVision ARM Cortex-M33 Simulator and uses the armclang compiler to build the FreeRTOS ARMv8-M GCC port. The project demonstrates using the ARM Cortex-M33 TrustZone and the ARM Cortex-M33 Memory Protection Unit (MPU).
Atmel ATSAMD20 Xplained Pro with Atmel Studio
This demo includes a simple blinky example, and a comprehensive demo that includes FreeRTOS-Plus-CLI. The command line interface uses the Atmel Software Framework UART drivers for its character input and output.
SAMV7 and SAME7 ARM Cortex-M7 based microcontrollers
Atmel SAM4L-EK low power tickless demo
The application demonstrates how the FreeRTOS tick suppression features can be used to minimise the power consumption of an application running on a SAM4L ARM Cortex-M4 microcontroller from Atmel. The SAM4L is designed specifically for use in applications that require extremely low power consumption.
Atmel SAM4S-EK demo using Atmel Studio and GCC
A project targeting a SAM4S ARM Cortex-M4 microcontroller that is pre-configured to build with the free Atmel Studio IDE and run on the SAM4S-EK evaluation kit.
Atmel SAM3U-EK demo using IAR
The demo application presented on this page is pre-configured to execute on the official SAM3U-EK evaluation kit from Atmel. The demo uses the FreeRTOS IAR ARM Cortex-M3 port and can be compiled and debugged directly from the IAR Embedded Workbench for ARM.
Atmel SAM7X ARM7 with IAR development tools
Uses the FreeRTOS SAM7 IAR ARM7 port, uIP and the Atmel AT91SAM7X-EK development board to create an embedded web server within a fully preemptive multitasking project. This demo also includes a simple CGI scripting language and a simple driver for the SAM7X EMAC peripheral.
Atmel SAM7X ARM7 with GCC and Eclipse development tools
Uses the FreeRTOS SAM7 GCC ARM7 port, uIP and the Atmel AT91SAM7X-EK development board to create an embedded web server within a fully preemptive multitasking project - this time using a completely open source development environment based on Eclipse and OpenOCD. A simple USB mouse driver implementation is also provided.
Atmel SAM7X ARM7 with GCC and Rowley development tools
Uses the FreeRTOS GCC ARM7 port, Rowley CrossStudio, lwIP and the Atmel AT91SAM7X-EK development board to create an embedded web server within a fully preemptive multitasking project. This demo also includes a sample USB CDC class driver (USB to serial).
Cypress PSoC5 CY8C5588 ARM Cortex-M3
A FreeRTOS demo for the PSoC5 that targets the CY8CKIT-001 PSoC® Development Kit, using a CY8CKIT- 010 PSoC® CY8C55 Family Processor Module Kit. The PSoC5 demo includes a schematic design with several peripherals to demonstrate their integration with the RTOS. The included peripherals are the UART, LCD Character Display and two different types of timer implementations. PSoC Creator projects are provided for GCC, as well as the ARM Keil/RVDS compilers.
Freescale Kinetis K60 using IAR
An IAR project is provided that is pre-configured to run on the TWR-K60N512 controller module. The demo application includes an example tiny web server. The TWR-K60N512 does not itself include an Ethernet connector, so a TWR-SER peripheral module is also required to make use of the embedded web server functionality. The two modules can be purchased together in the TWR-K60N512-KIT tower kit.
Fujitsu microcontrollers were acquired by Spansion. See Spansion below.
Imagination/MIPS
The FreeRTOS download does not contain official MIPS support, but the following options are made available and supported directly by Imagination in the FreeRTOS Interactive site:
Following the acquisition of Luminary Micro by Texas Instruments, demo applications that target Stellaris microcontrollers are now listed under the Texas Instruments heading.
PIC32 (PIC32MZ and PIC32MZ EF with MIPS M14K core) MPLAB GCC
Port and demo application for the MIPS M14K based PIC32MZ and PIC32MZ EF (with floating point) from Microchip. The demo utilises the XC32 compiler, MPLAB X and the PIC32MZ and PIC32MZ EF Starter Kits.
PIC32 (PIC32MX with MIPS M4K core) MPLAB GCC
Port and demo application for the MIPS M4K based PIC32 from Microchip. The demo utilises the XC32 compiler and MPLAB X. Build configurations are provided for the Explorer16 development board and the PIC32 USB II starter kit.
CEC1302 ARM Cortex-M4F, GCC, Keil, MikroC
Comprehensive and low power tick-less demos for the CEC1302 ARM Cortex-M4F based microcontroller from Microchip. The project demonstrates the CEC1302 being used with both aggregated and disaggregated interrupt schemes.
Please note that the segmented memory on the PIC18 makes it a less than ideal candidate for use with an RTOS.
Microchip PIC18 MPLAB
The demo is pre-configured to run on the 40 pin PICmicro prototyping board from Forest Electronic Developments, with a PIC18F452 microcontroller. This is a very low cost platform that has an in system programming capability. The MPLAB development tools are also utilised, comprising of the MPLAB IDE and the MPLAB C18 compiler.
M2S020 using GCC and the SoftConsole IDE
This demo includes FreeRTOS-Plus-CLI and FreeRTOS-Plus-FAT SL. Configurations are provided to target both the SmartFusion2 Starter Kit and the SmartFusion2 Development Kit.
Following the merger of NEC and Renesas under the Renesas brand, demo applications that target what were NEC microcontrollers are now listed under the Renesas heading.
NXP LPCXpresso55S69 Development Board Demo using GCC and MCUXpresso
This demo targets the ARM Cortex-M33 core on the LPCXpresso55S69 Development Board. The pre-configured project demonstrates using the ARM Cortex-M33 TrustZone and the ARM Cortex-M33 Memory Protection Unit (MPU).
ARM Cortex-M4F based microcontrollers
NXP LPC4350 demo using Keil/RVDS
This application demonstrates the FreeRTOS ARM Cortex-M4F RVDS port on the ARM Cortex-M4 core of the dual core LPC4350. The demo is pre-configured to run on the Hitex LPC4350 evaluation board. The LPC4300 microcontroller is configured to run at 204MHz. The demo includes a basic LED flashing configuration, and a comprehensive configuration. The comprehensive configuration creates more than 40 tasks, including tasks that test the FreeRTOS port itself.
NXP LPC1768 demonstrating FreeRTOS-Plus-IO and FreeRTOS-Plus-CLI
A comprehensive demo that uses FreeRTOS-Plus-CLI to interact with FreeRTOS-Plus-IO and the FatFS file system hosted on an SD card. FreeRTOS-Plus-IO manages the UART, I2C and SPI ports. The demo builds with the free LPCXPresso IDE and runs on the LPCXpresso base board.
Bertrik Sikkens open source LPCUSB USB stack to implement a CDC class echo server.
NXP LPC1768 demo using GCC and Rowley CrossWorks
Similar to the LPC1768 LPCXpresso IDE demo, but targeted at the MCB1700 development board and configured to use the Rowley CrossWorks development tools. This demo also incorporates a uIP web server and a USB CDC class driver.
NXP LPC1768 demo using the IAR Embedded Workbench
Similar to the LPC1768 LPCXpresso IDE demo, but targeted at the IAR evaluation board and configured to use the IAR development tools. This demo also incorporates a uIP web server and a USB CDC class driver.
NXP LPC1114 LPCXpresso
This application demonstrates the FreeRTOS ARM Cortex-M0 GCC port on low cost LPCXpresso LPC1114 hardware. The free LPCXpresso IDE is used.
NXP ARM7 with the Keil development tools
The demo is pre-configured to run on the MCB2100 development/prototyping board. The development tools provide an excellent debugger and peripheral simulator - allowing the entire demo application to be executed within the simulator. An excellent way to learn FreeRTOS!
NXP ARM7 with GCC
The demo is pre-configured to run on the LPC-P2106 prototyping board, with a LPC2106 microcontroller. This is a very low cost prototyping board that has an in system programming capability. The port uses a Win32 build of the ARM7 GNU development tools.
Pico
These demos use the FreeRTOS symmetric multiprocessing (SMP) version of the
kernel. The demos target the Raspberry Pi Pico board, which uses the
RP2040 microcontroller from Raspberry Pi that
features a Dual-core ARM Cortex M0+ processor.
RZ/A1 Embedded Processor (ARM Cortex-A9 core) with ARM and IAR development tools
A FreeRTOS demo application for the Renesas RZ/A1 embedded processor, which has an ARM Cortex-A9 core. Two projects are provided, allowing the demo to be built with both the IAR Embedded Workbench and ARM DS-5 embedded development tools. The demo includes FreeRTOS-Plus-CLI and FreeRTOS-Plus-FAT SL.
RZ/T Embedded Processor (ARM Cortex-R4F core) with Renesas, GCC and IAR compilers
A FreeRTOS demo application for the Renesas RZ/T embedded processor, which has an ARM Cortex-R core. Three projects are provided, allowing the demo to be built with the IAR, GCC and Renesas compilers. The GCC and Renesas compiler projects use the e2studio IDE. The demo includes a command line interface implemented with FreeRTOS-Plus-CLI.
RX700
RX700 RX71M (RXv2 core) with Renesas, GCC and IAR compilers
A FreeRTOS demo application for the Renesas RX71M microcontroller, which has an RXv2 core. Three projects are provided, allowing the demo to be built with the IAR, GCC and Renesas compilers. The GCC and Renesas compiler projects use the e2studio IDE. The demo includes a command line interface implemented with FreeRTOS-Plus-CLI.
RX600
RX64M (RXv2 core) using e2studio
Two e2studio projects are provided, both of which target the RX64M RSK (Renesas Starter Kit). One project users the Renesas RX compiler, and the other the GCC compiler.
RX62N and RX63N using the Renesas compiler and HEW IDE
There are two demo applications for the RX62N that use the Renesas development tools. One demo targets the Renesas RX62N Starter Kit (RSK), and the other the Renesas RX62N Demonstration Kit (RDK). There is also a project for the RX63N that targets the RX63N RDK. Each demo project includes three build configurations - a simple blinky example for RTOS beginners and two comprehensive examples that each create approximately 50 tasks. The demo also includes a web server with CGI scripting that is implemented using a free TCP/IP stack.
RX62N using the GCC compiler and HEW IDE
There are two demo applications for the RX62N that use the KPIT GNURX GCC development tools. One demo targets the Renesas RX62N Starter Kit (RSK), and the other the Renesas RX62N Demonstration Kit (RDK). Each demo project includes three build configurations - a simple blinky example for RTOS beginners and two comprehensive examples that each create approximately 50 tasks. The demo also includes a web server with CGI scripting that is implemented using a free TCP/IP stack.
RX62N using the IAR Embedded Workbench
There are two demo applications for the RX62N that use the IAR EMbedded Workbench. One demo targets the Renesas RX62N Starter Kit (RSK), and the other the Renesas RX62N Demonstration Kit (RDK). Each demo project includes three build configurations - a simple blinky example for RTOS beginners and two comprehensive examples that each create approximately 50 tasks. The demo also includes a web server with CGI scripting that is implemented using a free TCP/IP stack.
RX200
RX231 with Renesas, GCC and IAR compilers
A FreeRTOS demo application for the Renesas RX231 microcontroller, which as an RXv2 core. Three projects are provided, allowing the demo to be built with the IAR, GCC and Renesas compilers. The GCC and Renesas compiler projects use the e2studio IDE.
RX113 with Renesas, GCC and IAR compilers
A FreeRTOS demo application for the Renesas RX113 microcontroller. Three projects are provided, allowing the demo to be built with the IAR, GCC and Renesas compilers. The GCC and Renesas compiler projects use the e2studio IDE. The demo includes a command line interface implemented with FreeRTOS-Plus-CLI.
Tickless low power demo for RX100 (IAR, GCC and Renesas compilers)
An application that demonstrates how to use FreeRTOS tick suppression functionality to reduce power consumption on an RX100 microcontroller. Projects are provided for IAR, e2studio with GCC and e2studio with the Renesas compiler.
RL78/G13, RL78/G14, RL78/G1C, RL78/L13 and RL78/G1A using IAR
An IAR demo with build configurations to target the following RL78 chips and hardware: YRPBRL78G13 RL78/G13 promotion board, YRDKRL78G14 RL78/G14 development board, RSKRL78G1C RL78/G1C starter kit, RSKRL78L13 RL78/L13 starter kit, RL78/G1A TB RL78/G1A target board. Far and near memory models are supported.
RL78/G13 promotion board
An IAR demo that targets the RL78/G13 promotion board. Far and near memory models are supported.
V850ES 32bit microcontroller
An IAR demo that contains configurations for many different Renesas target boards and the V850ES/Fx3 Starter Board. Large and small memory models are supported.
78K0R 16bit microcontroller
An IAR demo that contains configurations for different Renesas target boards. Far and near memory models are supported.
Demos targeting RISC-V
RISC-V Spike Simulator GCC [Unofficial third party demo, links to the FreeRTOS Interactive site. There is now an official port too]
The port automatically configures itself for 32-bit and 64-bit RISC-V architectures on basis of #defines set by GCC. The demo application runs on the spike simulator in 64-bit mode, and needs the riscv GCC compiler and spike simulator to be installed somewhere for the build to succeed.
Demos targeting SiFive products
SiFive HiFive1 RevB using Freedom Studio (GCC) and IAR
Two pre-configured projects that create demo applications for the RISC-V core on the HiFive1 RevB evaluation board - one project uses SiFive's Freedom Studio with GCC, the other IAR's Embedded Workbench for IAR.
A pre-configured SiFive Freedom Studio project that builds and runs a FreeRTOS RISC-V demo in the sifive_e QEMU model using GCC and GDB.
EFM Giant Gekco and Pearl Gecko using Simplicity Studio and GCC
The demos presented on this page demonstrate the FreeRTOS tick suppression feature being used to save power on both an EFM32 Giant Gecko and an EFM32 Pearl Gecko starter kit. Both demos build using the free Eclipse based Simplicity Studio IDE and GCC.
EFM32G890F128 (ARM Cortex-M3) using IAR
An older port and demo application that uses the IAR Embedded Workbench development tools, and targets the ARM Cortex-M3 based EFM32G890F128 microcontroller. [This demo has now been superseded by the Giant and Pearl Gecko starter kit demos, which also demonstrate the FreeRTOS tickless idle mode to save power]
Spansion MB91460 32bit MCU
A demo for the MB91460 series of 32bit MCUs from Spansion. The port is pre-configured to run on the SK-91F467-FLEXRAY starter kit and uses the Softune compiler, IDE and debugger.
16bit 16FX microcontrollers
Spansion MB96340 16bit MCU
A demo for the MB96340 series of 16bit MCUs from Spansion (16FX). The port is pre-configured to run on the SK-16FX-EUROScope starter kit and uses the Softune compiler and IDE along with the Euroscope debugger.
The demo is preconfigured to run on the STM32H745I Discovery Board and build with the IAR compiler and Embedded Workbench IDE. The STM32H7xx has one ARM Cortex-M4 core and one ARM Cortex-M7 core. Both cores run the same ARMv7-M FreeRTOS port.
STM32F407 demo using IAR EWARM
This application demonstrates the FreeRTOS ARM Cortex-M4F IAR port on the ARM Cortex-M4F based STM32F407. The demo is pre-configured to run on the STM32F407ZF-SK starter kit evaluation board. The demo includes a basic LED flashing configuration, and a comprehensive configuration. The comprehensive configuration creates more than 40 tasks, including tasks that test the FreeRTOS port itself.
STM32 ARM Cortex-M3 based microcontrollers
Extreme low power tickless operation on an STM32L
This project demonstrates how the FreeRTOS tick suppression features can be used to minimise the power consumption of an application running on an STM32L low power ARM Cortex-M3 microcontroller from ST. The STM32L is designed specifically for use in applications that require extremely low power consumption.
STM32F051 demo using IAR EWARM
This application demonstrates the FreeRTOS ARM Cortex-M0 IAR port on the STM320518-EVAL board from ST, which is fitted with an STM32F051 microcontroller.
The FreeRTOS download does not contain official ARC support, but the following options are available to users wishing to run the RTOS on DesignWare ARC microcontrollers:
The embARC Open Software Platform consists of software and documentation to accelerate the development of embedded and IoT systems based on DesignWare ARC processors.
The demo application targets the Texas Instruments MSP432 microcontroller - which is a variant of the MSP430 low power microcontroller that uses an ARM Cortex-M4F core. Pre-configured MSP432 projects that target the MSP432P401R Launchpad Development Kit are provided for the IAR, Keil and CCS development tools.
MSP430 Rowley CrossWorks
The demo is pre-configured to run on the ES449 prototyping board from SoftBaugh, with a MSP430F449 microcontroller. The prototyping board includes a built in LCD - which is great for debugging. The port uses the Rowley Associates CrossWorks tool suite along with a FETP JTAG debugger. Two slightly different port implementations are included.
FreeRTOS Demo for QEMU LM3S6965 Model
A pre-configured Eclipse project that builds and runs the FreeRTOS ARM Cortex-M3 GCC port in the LM3S6965 QEMU model.
LM3S102 with the Keil development tools
Port and demo application for Texas Instruments Stellaris ARM Cortex-M3 based processor that uses the new ARM Keil development tools (RVDS). The demo application is pre-configured for the DK-LMS102 development, and uses both co-routines and tasks.
LM3S811 with the Keil development tools
Another demo application for the Texas Instruments Stellaris ARM Cortex-M3 Keil port, this time target at an LM3S811 evaluation board.
LM3S102 with GCC
Another port and demo application for Texas Instruments Stellaris ARM Cortex-M3 based processor, but this time using the GCC development tools.
LM3S102 with CrossWorks
This port and demo application for Texas Instruments Stellaris ARM Cortex-M3 based processor includes two demos for the Texas Instruments development board, and a simple co-routine demo for the new low cost CrossFire LM3S102 from Rowley Associates. All demos can be compiled and debugged using CrossWorks for ARM.
RM48 and TMS570 Code Composer Studio
Two projects with identical functionality. One targets the RM48 USB stick evaluation platform, and the other the TMS570 USB stick. Both use the FreeRTOS ARM Cortex-R4F CCS port.
Zynq using the official FreeRTOS Cortex-A9 port
A demo that uses the official Cortex-A9 RTOS port to run FreeRTOS on a ZC702 evaluation board using the Xilinx SDK and GCC. This demo uses a stand alone BSP and builds FreeRTOS as part of the application.
Zynq using a FreeRTOS BSP
A demonstration of how the Xilinx SDK can be used to create a FreeRTOS BSP. Including FreeRTOS in the BSP presents the application writer with a pre-configured FreeRTOS environment that does not require any source files to be added manually, any callback functions to be provided by the application code, and allows FreeRTOSConfig.h to be edited within the IDE.
Zynq UltraScale MPSoC
Using FreeRTOS on an UltraScale ARM Cortex-A53 (64-bit) Core
The first FreeRTOS port and demo application to run native 64-bit! The demo is pre-configured to run on the ZCU102 evaluation board. FreeRTOS support is provided for all the cores (ARM and Microblaze) found on the many-core Xilinx Zynq UltraScale+ MPSoC.
Using FreeRTOS on an UltraScale ARM Cortex-R5 Core
Simply blinky and comprehensive demos that run on one of the ARM Cortex-R5 cores on the Zynq UltraScale+ MPSoC. The demo is pre-configured to run on the ZCU102 evaluation board. FreeRTOS support is provided for all the cores (ARM and Microblaze) found on the many-core Xilinx Zynq UltraScale+ MPSoC.
Xilinx Virtex-5 PowerPC (PPC440)
A PowerPC configurable processor core running on a Virtex5 FPGA. Configurations are provided with no FPU, single precision FPU and double precision FPU.
Demos targeting XMOS products
XCORE.AI Explorer
This demo uses the Symmetric Multiprocessing (SMP) version of the FreeRTOS kernel. It targets the
XCORE.AI, which has 16 cores. The demo project uses XMOS XTC Tools to build the FreeRTOS XCOREAI
port. It demonstrates support for FreeRTOS symmetric multiprocessing (SMP) in the kernel.
Industrial PC Single Board Computer
This will run on a huge variety of PC/AT compatible industrial and single board computers, including PC/104 systems. It can use the Open Watcom or Borland development tools, for both of which a pre-configured project file is provided. See the Tools page.
RDC8822 Based Single Board Computer
This runs on the very competitively priced Flashlite 186 single board computer from JK Microsystems. The RDC8822 is an AMD embedded 186 clone (AM186ED). It can use the Open Watcom or Borland development tools (see Tools). Again a pre-configured project file is provided for both compilers.
RDC R1120 Based Single Board Computer
Includes a simple web server demo running on a Tern E-Engine controller using a memory mapped WizNET TCP/IP co-processor. The RDC1120 is an AMD embedded 186 clone (AM186ES). The demo application builds with the Paradigm C/C++ compiler and can be remotely debugged from within the compiler IDE.
Simulators and emulators
Windows Simulator for Visual Studio and Eclipse with MingW (GCC)
This allows FreeRTOS to be run in a Windows environment - although true real time behaviour cannot be achieved. Demo projects are provided for both Eclipse with MingW (GCC) and Visual Studio community edition. Both these tool chains are free, although Visual Studio Express requires registration if it is to be used for anything other than evaluation purposes. The demo's documentation page describes the principle of the simulated operation.
POSIX port that runs on Linux (GCC)
This allows FreeRTOS to run on Linux - although true real time behaviour cannot be achieved. The demo's documentation page describes the principle of the simulated operation.
QEMU Cortex-M3 model using IAR or GCC (makefile and Eclipse)
A FreeRTOS kernel demo that targets the Arm Cortex-M3 mps2-an385 QEMU model. Preconfigured build projects are provided for both the IAR Embedded Workbench and arm-none-eabi-gcc (GNU GCC) compilers. The GCC project uses a simple makefile that can be built from the command line or the provided Eclipse CDT IDE project.
Copyright (C) Amazon Web Services, Inc. or its affiliates. All rights reserved.