CyPhOS - Real-time operating system for cyber-physical systems
The system supports the ARMv7 (Cortex-A9) and AMD64 processor architecture.
To compile this operating system you need an arm (arm-none-eabi) toolchain. Currently supported is gcc 5.3 (newer/older versions might also work). Make sure your compiler is in your $PATH.
Also version 2 of AspectC++ is required to compile the operating system. Make sure that ag++ and ac++ is within you $PATH
variable.
- 6.2 (or newer 6 series)
- 7.3
- 8.1, 8.2
Although older GCC versions might work CyPhOS is only developed and tested with the newest released GCC version (8.2).
- 6.1 Does not work because of a bug where volatile is ignored. Bugreport
First you need to configure the build environment with some variables.
export TARGET=arm-none-eabi
export PREFIX="$HOME/cross-compiler/$TARGET"
export PATH="$PREFIX/bin:$PATH"
$PREFIX is set to the installation directory of the cross-compiler toolchain.
- Download the binutils sourcecode here to some directory
- Change into the directory of the sourcecode:
cd $somedirectory
- Extract the sourcecode:
tar xf binutils-$VERSION.tar.bz2
- Create the build directory:
mkdir binutils-build
- Change into the build directory:
cd binutils-build
- Configure the binutils sources:
../binutils-$VERSION/configure --target=$TARGET --prefix="$PREFIX" --with-sysroot --disable-nls --disable-werror
- Compile the sources:
make
- Install the compiled tools:
make install
- Download the gcc sourcecode here to some directory
- Change into the directory of the sourcecode:
cd $somedirectory
- Extract the sourcecode:
tar xf gcc-$VERSION.tar.bz2
- Create the build directory:
mkdir gcc-build
- Change into the build directory:
cd gcc-build
- Configure the gcc sources:
../gcc-$VERSION/configure --target=$TARGET --prefix="$PREFIX" --disable-nls --enable-languages=c,c++ --without-headers
- Compile the bootstrap gcc:
make all-gcc
- Compile the additional libgcc:
make all-target-libgcc
- Install the compiler and libgcc:
make install-gcc; make install-target-libgcc
You must also include the path of your installed compiler to your $PATH variable.
To compile the OS the specific board needs to be set. This can be done by setting the CYPHOS_ARCH
environment variable.
export CYPHOS_ARCH="BOARDVALUE"
where BOARDVALUE is one of the targets below.
After setting the variable you can just call make -jN (where N is the number of threads to compiler)
During the compilation a script is started to generate parts of the linker script which enables the operating system to preload components during runtime.
make -j4
(for example)
This will result in an elf binary under build/boot
and a raw binary under build/boot.img
To boot this image look under the board specific documentation.
Currently there is only support for ARM systems with Cortex-A9 processors and AMD64 system.
List of currently supported platforms:
- PandaBoard ES
- Hardkernel ODroid U3+
- Wandboard (www.wandboard.org)
The board specific value for the architecture variable (BOARDVALUE above) is armv7/exynos4412
To boot the operating system you need a bootloader with support for baremetal booting and without the MMU enabled already. You can use a modified version of u-boot for exynos from:
Github which can boot baremetal images via fastboot
The board specific value for the architecture variable (BOARDVALUE above) is armv7/omap4460
To boot the operating system from USB you need the usbboot bootloader.
Github (Booting with usb3 ports is a bit unstable)
As an alternative I recommend setting up network based PXEboot with U-boot.
The board specific value for the architecture variable (BOARDVALUE above) is armv7/imx6
The generated image file is best booted via u-boot direct loading. You can use loady to load the binary build/boot.img
To load this image use the following command sequence in u-boot:
loady
- This will listen for a ymodem file transfer (can be initiated via minicom for example)- Send the build/boot.img to the serial console of u-boot.
go 0x12000000
this needs to be the address of the file transfer. This instructs u-boot to branch(jump) the cpu to the startup code of CyPhOS.
As an alternative I recommend setting up network based PXEboot with U-boot.
You only need gcc with g++ and ag++ installed on your system.
Compilation can be done via:
export CYPHOS_ARCH=x86
make iso
- This will result in an .iso file that you can dd on an USB stick or boot via qemu directly. Also the generated ELF image is multiboot compliant.