AMiRo-OS

include $(AMIROOS)/hal/hal.mk

include $(AMIROOS)/hal/ports/STM32/platform.mk

BOARDLD = $(AMIROOS)/hal/ports

include $(AMIROOS)/hal/hal.mk

include $(AMIROOS)/hal/ports/STM32/platform.mk

BOARDLD = $(AMIROOS)/hal/ports

include $(AMIROOS)/hal/hal.mk

include $(AMIROOS)/hal/ports/STM32/platform.mk

BOARDLD = $(AMIROOS)/hal/ports

################################################################################

# AMiRo-OS is an operating system designed for the Autonomous Mini Robot       #

# (AMiRo) platform.                                                            #

# Copyright (C) 2016..2018  Thomas Schöpping et al.                            #

#                                                                              #

# This program is free software: you can redistribute it and/or modify         #

# it under the terms of the GNU General Public License as published by         #

# the Free Software Foundation, either version 3 of the License, or            #

# (at your option) any later version.                                          #

#                                                                              #

# This program is distributed in the hope that it will be useful,              #

# but WITHOUT ANY WARRANTY; without even the implied warranty of               #

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #

# GNU General Public License for more details.                                 #

#                                                                              #

# You should have received a copy of the GNU General Public License            #

# along with this program.  If not, see <http://www.gnu.org/licenses/>.        #

#                                                                              #

# This research/work was supported by the Cluster of Excellence Cognitive      #

# Interaction Technology 'CITEC' (EXC 277) at Bielefeld University, which is   #

# funded by the German Research Foundation (DFG).                              #

################################################################################

# absolute path to this directory

HAL_DIR := $(dir $(lastword $(MAKEFILE_LIST)))

# add include path

HALINC += $(HAL_DIR)include

# add sources

HALSRC += 

################################################################################

# AMiRo-OS is an operating system designed for the Autonomous Mini Robot       #

# (AMiRo) platform.                                                            #

# Copyright (C) 2016..2018  Thomas Schöpping et al.                            #

#                                                                              #

# This program is free software: you can redistribute it and/or modify         #

# it under the terms of the GNU General Public License as published by         #

# the Free Software Foundation, either version 3 of the License, or            #

# (at your option) any later version.                                          #

#                                                                              #

# This program is distributed in the hope that it will be useful,              #

# but WITHOUT ANY WARRANTY; without even the implied warranty of               #

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #

# GNU General Public License for more details.                                 #

#                                                                              #

# You should have received a copy of the GNU General Public License            #

# along with this program.  If not, see <http://www.gnu.org/licenses/>.        #

#                                                                              #

# This research/work was supported by the Cluster of Excellence Cognitive      #

# Interaction Technology 'CITEC' (EXC 277) at Bielefeld University, which is   #

# funded by the German Research Foundation (DFG).                              #

################################################################################

# absolute path to this directory

PLATFORM_DIR := $(dir $(lastword $(MAKEFILE_LIST)))

# add include path

PLATFORMINC += 

# add C sources

PLATFORMSRC += 

/*

AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.

Copyright (C) 2016..2018  Thomas Schöpping et al.

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

/*

 * ST32F103xE memory setup.

 */

MEMORY

{

    flash0  : org = 0x08006000, len = 512k-24k

    flash1  : org = 0x00000000, len = 0

    flash2  : org = 0x00000000, len = 0

    flash3  : org = 0x00000000, len = 0

    flash4  : org = 0x00000000, len = 0

    flash5  : org = 0x00000000, len = 0

    flash6  : org = 0x00000000, len = 0

    flash7  : org = 0x00000000, len = 0

    ram0    : org = 0x20000000, len = 64k

    ram1    : org = 0x00000000, len = 0

    ram2    : org = 0x00000000, len = 0

    ram3    : org = 0x00000000, len = 0

    ram4    : org = 0x00000000, len = 0

    ram5    : org = 0x00000000, len = 0

    ram6    : org = 0x00000000, len = 0

    ram7    : org = 0x00000000, len = 0

}

/* For each data/text section two region are defined, a virtual region

   and a load region (_LMA suffix).*/

/* Flash region to be used for exception vectors.*/

REGION_ALIAS("VECTORS_FLASH", flash0);

REGION_ALIAS("VECTORS_FLASH_LMA", flash0);

/* Flash region to be used for constructors and destructors.*/

REGION_ALIAS("XTORS_FLASH", flash0);

REGION_ALIAS("XTORS_FLASH_LMA", flash0);

/* Flash region to be used for code text.*/

REGION_ALIAS("TEXT_FLASH", flash0);

REGION_ALIAS("TEXT_FLASH_LMA", flash0);

/* Flash region to be used for read only data.*/

REGION_ALIAS("RODATA_FLASH", flash0);

REGION_ALIAS("RODATA_FLASH_LMA", flash0);

/* Flash region to be used for various.*/

REGION_ALIAS("VARIOUS_FLASH", flash0);

REGION_ALIAS("VARIOUS_FLASH_LMA", flash0);

/* Flash region to be used for RAM(n) initialization data.*/

REGION_ALIAS("RAM_INIT_FLASH_LMA", flash0);

/* RAM region to be used for Main stack. This stack accommodates the processing

   of all exceptions and interrupts.*/

REGION_ALIAS("MAIN_STACK_RAM", ram0);

/* RAM region to be used for the process stack. This is the stack used by

   the main() function.*/

REGION_ALIAS("PROCESS_STACK_RAM", ram0);

/* RAM region to be used for data segment.*/

REGION_ALIAS("DATA_RAM", ram0);

REGION_ALIAS("DATA_RAM_LMA", flash0);

/* RAM region to be used for BSS segment.*/

REGION_ALIAS("BSS_RAM", ram0);

/* RAM region to be used for the default heap.*/

REGION_ALIAS("HEAP_RAM", ram0);

/* Generic rules inclusion.*/

INCLUDE rules.ld

/*

AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.

Copyright (C) 2016..2018  Thomas Schöpping et al.

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

/*

 * STM32F405xG memory setup.

 * Note: Use of ram1 and ram2 is mutually exclusive with use of ram0.

 */

MEMORY

{

    flash0  : org = 0x08008000, len = 1M-32k

    flash1  : org = 0x00000000, len = 0

    flash2  : org = 0x00000000, len = 0

    flash3  : org = 0x00000000, len = 0

    flash4  : org = 0x00000000, len = 0

    flash5  : org = 0x00000000, len = 0

    flash6  : org = 0x00000000, len = 0

    flash7  : org = 0x00000000, len = 0

    ram0    : org = 0x20000000, len = 128k      /* SRAM1 + SRAM2 */

    ram1    : org = 0x20000000, len = 112k      /* SRAM1 */

    ram2    : org = 0x2001C000, len = 16k       /* SRAM2 */

    ram3    : org = 0x00000000, len = 0

    ram4    : org = 0x10000000, len = 64k       /* CCM SRAM */

    ram5    : org = 0x40024000, len = 4k        /* BCKP SRAM */

    ram6    : org = 0x00000000, len = 0

    ram7    : org = 0x00000000, len = 0

}

/* For each data/text section two region are defined, a virtual region

   and a load region (_LMA suffix).*/

/* Flash region to be used for exception vectors.*/

REGION_ALIAS("VECTORS_FLASH", flash0);

REGION_ALIAS("VECTORS_FLASH_LMA", flash0);

/* Flash region to be used for constructors and destructors.*/

REGION_ALIAS("XTORS_FLASH", flash0);

REGION_ALIAS("XTORS_FLASH_LMA", flash0);

/* Flash region to be used for code text.*/

REGION_ALIAS("TEXT_FLASH", flash0);

REGION_ALIAS("TEXT_FLASH_LMA", flash0);

/* Flash region to be used for read only data.*/

REGION_ALIAS("RODATA_FLASH", flash0);

REGION_ALIAS("RODATA_FLASH_LMA", flash0);

/* Flash region to be used for various.*/

REGION_ALIAS("VARIOUS_FLASH", flash0);

REGION_ALIAS("VARIOUS_FLASH_LMA", flash0);

/* Flash region to be used for RAM(n) initialization data.*/

REGION_ALIAS("RAM_INIT_FLASH_LMA", flash0);

/* RAM region to be used for Main stack. This stack accommodates the processing

   of all exceptions and interrupts.*/

REGION_ALIAS("MAIN_STACK_RAM", ram0);

/* RAM region to be used for the process stack. This is the stack used by

   the main() function.*/

REGION_ALIAS("PROCESS_STACK_RAM", ram0);

/* RAM region to be used for data segment.*/

REGION_ALIAS("DATA_RAM", ram0);

REGION_ALIAS("DATA_RAM_LMA", flash0);

/* RAM region to be used for BSS segment.*/

REGION_ALIAS("BSS_RAM", ram0);

/* RAM region to be used for the default heap.*/

REGION_ALIAS("HEAP_RAM", ram0);

/* Generic rules inclusion.*/

INCLUDE rules.ld

/*

AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.

Copyright (C) 2016..2018  Thomas Schöpping et al.

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

/* Stack rules inclusion.*/

INCLUDE rules_stacks.ld

/* Code rules inclusion.*/

INCLUDE rules_code.ld

/* Data rules inclusion.*/

INCLUDE rules_data.ld

# ARM Cortex-Mx common makefile scripts and rules.

##############################################################################

# Processing options coming from the upper Makefile.

#

# Output directory and files

SRECFILE = $(BUILDDIR)/$(PROJECT).srec

#

# Makefile rules

#

blt: $(SRECFILE)

MAKE_ALL_RULE_HOOK: blt

%.srec: %.elf $(LDSCRIPT)

ifeq ($(USE_VERBOSE_COMPILE),yes)

	$(SREC) $< $@

else

	@echo Creating $@

	@$(SREC) $< $@

endif

# *** EOF ***

/*

AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.

Copyright (C) 2016..2018  Thomas Schöpping et al.

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

ENTRY(Reset_Handler)

SECTIONS

{

    .vectors : ALIGN(16)

    {

        KEEP(*(.vectors))

    } > VECTORS_FLASH AT > VECTORS_FLASH_LMA

    .xtors : ALIGN(4)

    {

        __init_array_start = .;

        KEEP(*(SORT(.init_array.*)))

        KEEP(*(.init_array))

        __init_array_end = .;

        __fini_array_start = .;

        KEEP(*(.fini_array))

        KEEP(*(SORT(.fini_array.*)))

        __fini_array_end = .;

    } > XTORS_FLASH AT > XTORS_FLASH_LMA

    .text ALIGN(16) : ALIGN(16)

    {

        *(.text)

        *(.text.*)

        *(.glue_7t)

        *(.glue_7)

        *(.gcc*)

    } > TEXT_FLASH AT > TEXT_FLASH_LMA

    .rodata : ALIGN(4)

    {

        . = ALIGN(4);

        __rodata_base__ = .;

        *(.rodata)

        *(.rodata.*)

        . = ALIGN(4);

        __rodata_end__ = .;

    } > RODATA_FLASH AT > RODATA_FLASH_LMA

    .ARM.extab :

    {

        *(.ARM.extab* .gnu.linkonce.armextab.*)

    } > VARIOUS_FLASH AT > VARIOUS_FLASH_LMA

    .ARM.exidx : {

        __exidx_start = .;

        *(.ARM.exidx* .gnu.linkonce.armexidx.*)

        __exidx_end = .;

     } > VARIOUS_FLASH AT > VARIOUS_FLASH_LMA

    .eh_frame_hdr :

    {

        *(.eh_frame_hdr)

    } > VARIOUS_FLASH AT > VARIOUS_FLASH_LMA

    .eh_frame : ONLY_IF_RO

    {

        *(.eh_frame)

    } > VARIOUS_FLASH AT > VARIOUS_FLASH_LMA

}

/*

AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.

Copyright (C) 2016..2018  Thomas Schöpping et al.

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

__ram0_start__          = ORIGIN(ram0);

__ram0_size__           = LENGTH(ram0);

__ram0_end__            = __ram0_start__ + __ram0_size__;

__ram1_start__          = ORIGIN(ram1);

__ram1_size__           = LENGTH(ram1);

__ram1_end__            = __ram1_start__ + __ram1_size__;

__ram2_start__          = ORIGIN(ram2);

__ram2_size__           = LENGTH(ram2);

__ram2_end__            = __ram2_start__ + __ram2_size__;

__ram3_start__          = ORIGIN(ram3);

__ram3_size__           = LENGTH(ram3);

__ram3_end__            = __ram3_start__ + __ram3_size__;

__ram4_start__          = ORIGIN(ram4);

__ram4_size__           = LENGTH(ram4);

__ram4_end__            = __ram4_start__ + __ram4_size__;

__ram5_start__          = ORIGIN(ram5);

__ram5_size__           = LENGTH(ram5);

__ram5_end__            = __ram5_start__ + __ram5_size__;

__ram6_start__          = ORIGIN(ram6);

__ram6_size__           = LENGTH(ram6);

__ram6_end__            = __ram6_start__ + __ram6_size__;

__ram7_start__          = ORIGIN(ram7);

__ram7_size__           = LENGTH(ram7);

__ram7_end__            = __ram7_start__ + __ram7_size__;

ENTRY(Reset_Handler)

SECTIONS

{

    .data : ALIGN(4)

    {

        . = ALIGN(4);

        PROVIDE(_textdata = LOADADDR(.data));

        PROVIDE(_data = .);

        _textdata_start = LOADADDR(.data);

        _data_start = .;

        *(.data)

        *(.data.*)

        *(.ramtext)

        . = ALIGN(4);

        PROVIDE(_edata = .);

        _data_end = .;

    } > DATA_RAM AT > DATA_RAM_LMA

    .bss (NOLOAD) : ALIGN(4)

    {

        . = ALIGN(4);

        _bss_start = .;

        *(.bss)

        *(.bss.*)

        *(COMMON)

        . = ALIGN(4);

        _bss_end = .;

        PROVIDE(end = .);

    } > BSS_RAM

    .ram0_init : ALIGN(4)

    {

        . = ALIGN(4);

        __ram0_init_text__ = LOADADDR(.ram0_init);

        __ram0_init__ = .;

        KEEP(*(.ram0_init))

        KEEP(*(.ram0_init.*))

        . = ALIGN(4);

    } > ram0 AT > RAM_INIT_FLASH_LMA

    .ram0 (NOLOAD) : ALIGN(4)

    {

        . = ALIGN(4);

        __ram0_clear__ = .;

        *(.ram0_clear)

        *(.ram0_clear.*)

        . = ALIGN(4);

        __ram0_noinit__ = .;

        *(.ram0)

        *(.ram0.*)

        . = ALIGN(4);

        __ram0_free__ = .;

    } > ram0

    .ram1_init : ALIGN(4)

    {

        . = ALIGN(4);

        __ram1_init_text__ = LOADADDR(.ram1_init);

        __ram1_init__ = .;

        KEEP(*(.ram1_init))

        KEEP(*(.ram1_init.*))

        . = ALIGN(4);

    } > ram1 AT > RAM_INIT_FLASH_LMA

    .ram1 (NOLOAD) : ALIGN(4)

    {

        . = ALIGN(4);

        __ram1_clear__ = .;

        *(.ram1_clear)

        *(.ram1_clear.*)

        . = ALIGN(4);

        __ram1_noinit__ = .;

        *(.ram1)

        *(.ram1.*)

        . = ALIGN(4);

        __ram1_free__ = .;

    } > ram1

    .ram2_init : ALIGN(4)

    {

        . = ALIGN(4);

        __ram2_init_text__ = LOADADDR(.ram2_init);

        __ram2_init__ = .;

        KEEP(*(.ram2_init))

        KEEP(*(.ram2_init.*))

        . = ALIGN(4);

    } > ram2 AT > RAM_INIT_FLASH_LMA

    .ram2 (NOLOAD) : ALIGN(4)

    {

        . = ALIGN(4);

        __ram2_clear__ = .;

        *(.ram2_clear)

        *(.ram2_clear.*)

        . = ALIGN(4);

        __ram2_noinit__ = .;

        *(.ram2)

        *(.ram2.*)

        . = ALIGN(4);

        __ram2_free__ = .;

    } > ram2

    .ram3_init : ALIGN(4)

    {

        . = ALIGN(4);

        __ram3_init_text__ = LOADADDR(.ram3_init);

        __ram3_init__ = .;

        KEEP(*(.ram3_init))

        KEEP(*(.ram3_init.*))

        . = ALIGN(4);

    } > ram3 AT > RAM_INIT_FLASH_LMA

    .ram3 (NOLOAD) : ALIGN(4)

    {

        . = ALIGN(4);

        __ram3_clear__ = .;

        *(.ram3_clear)

        *(.ram3_clear.*)

        . = ALIGN(4);

        __ram3_noinit__ = .;

        *(.ram3)

        *(.ram3.*)

        . = ALIGN(4);

        __ram3_free__ = .;

    } > ram3

    .ram4_init : ALIGN(4)

    {

        . = ALIGN(4);

        __ram4_init_text__ = LOADADDR(.ram4_init);

        __ram4_init__ = .;

        KEEP(*(.ram4_init))

        KEEP(*(.ram4_init.*))

        . = ALIGN(4);

    } > ram4 AT > RAM_INIT_FLASH_LMA

    .ram4 (NOLOAD) : ALIGN(4)

    {

        . = ALIGN(4);

        __ram4_clear__ = .;

        *(.ram4_clear)

        *(.ram4_clear.*)

        . = ALIGN(4);

        __ram4_noinit__ = .;

        *(.ram4)

        *(.ram4.*)

        . = ALIGN(4);

        __ram4_free__ = .;

    } > ram4

    .ram5_init : ALIGN(4)

    {

        . = ALIGN(4);

        __ram5_init_text__ = LOADADDR(.ram5_init);

        __ram5_init__ = .;

        KEEP(*(.ram5_init))

        KEEP(*(.ram5_init.*))

        . = ALIGN(4);

    } > ram5 AT > RAM_INIT_FLASH_LMA

    .ram5 (NOLOAD) : ALIGN(4)

    {

        . = ALIGN(4);

        __ram5_clear__ = .;

        *(.ram5_clear)

        *(.ram5_clear.*)

        . = ALIGN(4);

        __ram5_noinit__ = .;

        *(.ram5)

        *(.ram5.*)

        . = ALIGN(4);

        __ram5_free__ = .;

    } > ram5

    .ram6_init : ALIGN(4)

    {

        . = ALIGN(4);

        __ram6_init_text__ = LOADADDR(.ram6_init);

        __ram6_init__ = .;

        KEEP(*(.ram6_init))

        KEEP(*(.ram6_init.*))

        . = ALIGN(4);

    } > ram6 AT > RAM_INIT_FLASH_LMA

    .ram6 (NOLOAD) : ALIGN(4)

    {

        . = ALIGN(4);

        __ram6_clear__ = .;

        *(.ram6_clear)

        *(.ram6_clear.*)

        . = ALIGN(4);

        __ram6_noinit__ = .;

        *(.ram6)

        *(.ram6.*)

        . = ALIGN(4);

        __ram6_free__ = .;

    } > ram6

    .ram7_init : ALIGN(4)

    {

        . = ALIGN(4);

        __ram7_init_text__ = LOADADDR(.ram7_init);

        __ram7_init__ = .;

        KEEP(*(.ram7_init))

        KEEP(*(.ram7_init.*))

        . = ALIGN(4);

    } > ram7 AT > RAM_INIT_FLASH_LMA

    .ram7 (NOLOAD) : ALIGN(4)

    {

        . = ALIGN(4);

        __ram7_clear__ = .;

        *(.ram7_clear)

        *(.ram7_clear.*)

        . = ALIGN(4);

        __ram7_noinit__ = .;

        *(.ram7)

        *(.ram7.*)

        . = ALIGN(4);

        __ram7_free__ = .;

    } > ram7

    /* The default heap uses the (statically) unused part of a RAM section.*/

    .heap (NOLOAD) :

    {

        . = ALIGN(8);

        __heap_base__ = .;

        . = ORIGIN(HEAP_RAM) + LENGTH(HEAP_RAM);

        __heap_end__ = .;

    } > HEAP_RAM

}

/*

AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.

Copyright (C) 2016..2018  Thomas Schöpping et al.

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

SECTIONS

{

    /* Special section for exceptions stack.*/

    .mstack :

    {

        . = ALIGN(8);

        __main_stack_base__ = .;

        . += __main_stack_size__;

        . = ALIGN(8);

        __main_stack_end__ = .;

    } > MAIN_STACK_RAM

    /* Special section for process stack.*/

    .pstack :

    {

        __process_stack_base__ = .;

        __main_thread_stack_base__ = .;

        . += __process_stack_size__;

        . = ALIGN(8);

        __process_stack_end__ = .;

        __main_thread_stack_end__ = .;

    } > PROCESS_STACK_RAM

}