diff --git a/index/em/embedded_stm32f0xx/embedded_stm32f0xx-15.0.1.toml b/index/em/embedded_stm32f0xx/embedded_stm32f0xx-15.0.1.toml new file mode 100644 index 00000000..26d42de6 --- /dev/null +++ b/index/em/embedded_stm32f0xx/embedded_stm32f0xx-15.0.1.toml @@ -0,0 +1,112 @@ +name = "embedded_stm32f0xx" +description = "embedded runtime for the STM32F0xx SoC" +version = "15.0.1" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `embedded_stm32f0xx` in the dependency list: + ```toml + [[depends-on]] + embedded_stm32f0xx = "*" + ``` + - if applicable, apply any runtime configuration variables (see below). + +Then edit your project file to add the following elements: + - "with" the run-time project files. With this, gprbuild will compile the run-time before your application + ```ada + with "runtime_build.gpr"; + with "ravenscar_build.gpr"; + ``` + - Specify the `Target` and `Runtime` attributes: + ```ada + for Target use runtime_build'Target; + for Runtime ("Ada") use runtime_build'Runtime ("Ada"); + ``` + - specify the `Linker` switches: + ```ada + package Linker is + for Switches ("Ada") use Runtime_Build.Linker_Switches; + end Linker; + ``` + +The runtime is configurable via Alire crate configuration variables. +See the project website for full details of the available options. + +By default, the runtime is configured for the STM32F072RB. If your board has +a different MCU, then you will need to specify which MCU you are using via +the crate configuration. For example, to configure the runtime for the +STM32F030F4, add the following to your `alire.toml`: +```toml +[configuration.values] +embedded_stm32f0xx.MCU_Sub_Family = "F030" +embedded_stm32f0xx.MCU_Pin_Count = "F" +embedded_stm32f0xx.MCU_User_Code_Memory_Size = "4" +``` + +By default, the runtime configures the clock tree for a 48 MHz system clock +from the high-speed internal (HSI) oscillator. If you want a different clock +configuration, then use the crate configuration variables to specify the +configuration you wish to use. For example, to configure the runtime to +generate a 32 MHz system clock from a 16 MHz HSE crystal oscillator: +```toml +[configuration.values] +# Configure a 16 MHz HSE crystal oscillator +embedded_stm32f0xx.HSE_Clock_Frequency = 16000000 +embedded_stm32f0xx.HSE_Bypass = false + +# Use the PLL as the SYSCLK source +embedded_stm32f0xx.SYSCLK_Src = "PLL" + +# Configure the PLL input for a 16 MHz input from the HSE +embedded_stm32f0xx.PLL_Src = "HSE_PREDIV" +embedded_stm32f0xx.PREDIV = 1 + +# Configure the PLL to output 32 MHz (16 MHz * 2) +embedded_stm32f0xx.PLLMUL = 2 + +# Configure the AHB an APB to also run at 32 MHz +embedded_stm32f0xx.AHB_Pre = "DIV1" +embedded_stm32f0xx.APB_Pre = "DIV1" +``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime", "stm32f0"] +website = "https://github.com/damaki/stm32f0xx-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +MCU_Sub_Family = { type = "Enum", values = ["F030", "F031", "F038", "F042", "F048", "F051", "F058", "F070", "F071", "F072", "F078", "F091", "F098"], default = "F072" } +MCU_Pin_Count = { type = "Enum", values = ["C", "E", "F", "G", "K", "R", "V"], default = "R" } +MCU_User_Code_Memory_Size = { type = "String", default = "B" } + +LSI_Enabled = { type = "Boolean", default = true } +HSE_Bypass = { type = "Boolean", default = false } +HSE_Clock_Frequency = { type = "Integer", first = 1, last = 32000000, default = 8000000 } +SYSCLK_Src = { type = "Enum", values = ["HSI", "HSE", "PLL", "HSI48"], default = "PLL" } +PLL_Src = { type = "Enum", values = ["HSI_2", "HSI_PREDIV", "HSE_PREDIV", "HSI48_PREDIV"], default = "HSI_2"} +PREDIV = { type = "Integer", first = 1, last = 16, default = 2 } +PLLMUL = { type = "Integer", first = 2, last = 16, default = 12 } +AHB_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16", "DIV64", "DIV128", "DIV256", "DIV512"], default = "DIV1" } +APB_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16"], default = "DIV2" } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:0b77c991031bfc1df2cddccbf19210f537456ace99498a245d9ef9ad9def668a", +"sha512:1feaec15c78c95b1f8d91007f8544cc10e7cd6fd4f4c30c753cabb00f9be354c233b31021d8e2bf09789f4f34083f63bb0792878a9fccbe504c577355dba605f", +] +url = "https://github.com/damaki/stm32f0xx-runtimes/releases/download/v15.0.1/embedded-stm32f0xx-15.0.1.tar.gz" + diff --git a/index/li/light_stm32f0xx/light_stm32f0xx-15.0.1.toml b/index/li/light_stm32f0xx/light_stm32f0xx-15.0.1.toml new file mode 100644 index 00000000..1e0fc2dc --- /dev/null +++ b/index/li/light_stm32f0xx/light_stm32f0xx-15.0.1.toml @@ -0,0 +1,111 @@ +name = "light_stm32f0xx" +description = "light runtime for the STM32F0xx SoC" +version = "15.0.1" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_stm32f0xx` in the dependency list: + ```toml + [[depends-on]] + light_stm32f0xx = "*" + ``` + - if applicable, apply any runtime configuration variables (see below). + +Then edit your project file to add the following elements: + - "with" the run-time project files. With this, gprbuild will compile the run-time before your application + ```ada + with "runtime_build.gpr"; + ``` + - Specify the `Target` and `Runtime` attributes: + ```ada + for Target use runtime_build'Target; + for Runtime ("Ada") use runtime_build'Runtime ("Ada"); + ``` + - specify the `Linker` switches: + ```ada + package Linker is + for Switches ("Ada") use Runtime_Build.Linker_Switches; + end Linker; + ``` + +The runtime is configurable via Alire crate configuration variables. +See the project website for full details of the available options. + +By default, the runtime is configured for the STM32F072RB. If your board has +a different MCU, then you will need to specify which MCU you are using via +the crate configuration. For example, to configure the runtime for the +STM32F030F4, add the following to your `alire.toml`: +```toml +[configuration.values] +light_stm32f0xx.MCU_Sub_Family = "F030" +light_stm32f0xx.MCU_Pin_Count = "F" +light_stm32f0xx.MCU_User_Code_Memory_Size = "4" +``` + +By default, the runtime configures the clock tree for a 48 MHz system clock +from the high-speed internal (HSI) oscillator. If you want a different clock +configuration, then use the crate configuration variables to specify the +configuration you wish to use. For example, to configure the runtime to +generate a 32 MHz system clock from a 16 MHz HSE crystal oscillator: +```toml +[configuration.values] +# Configure a 16 MHz HSE crystal oscillator +light_stm32f0xx.HSE_Clock_Frequency = 16000000 +light_stm32f0xx.HSE_Bypass = false + +# Use the PLL as the SYSCLK source +light_stm32f0xx.SYSCLK_Src = "PLL" + +# Configure the PLL input for a 16 MHz input from the HSE +light_stm32f0xx.PLL_Src = "HSE_PREDIV" +light_stm32f0xx.PREDIV = 1 + +# Configure the PLL to output 32 MHz (16 MHz * 2) +light_stm32f0xx.PLLMUL = 2 + +# Configure the AHB an APB to also run at 32 MHz +light_stm32f0xx.AHB_Pre = "DIV1" +light_stm32f0xx.APB_Pre = "DIV1" +``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime", "stm32f0"] +website = "https://github.com/damaki/stm32f0xx-runtimes" + +project-files = ['runtime_build.gpr'] + +[configuration] +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +MCU_Sub_Family = { type = "Enum", values = ["F030", "F031", "F038", "F042", "F048", "F051", "F058", "F070", "F071", "F072", "F078", "F091", "F098"], default = "F072" } +MCU_Pin_Count = { type = "Enum", values = ["C", "E", "F", "G", "K", "R", "V"], default = "R" } +MCU_User_Code_Memory_Size = { type = "String", default = "B" } + +LSI_Enabled = { type = "Boolean", default = true } +HSE_Bypass = { type = "Boolean", default = false } +HSE_Clock_Frequency = { type = "Integer", first = 1, last = 32000000, default = 8000000 } +SYSCLK_Src = { type = "Enum", values = ["HSI", "HSE", "PLL", "HSI48"], default = "PLL" } +PLL_Src = { type = "Enum", values = ["HSI_2", "HSI_PREDIV", "HSE_PREDIV", "HSI48_PREDIV"], default = "HSI_2"} +PREDIV = { type = "Integer", first = 1, last = 16, default = 2 } +PLLMUL = { type = "Integer", first = 2, last = 16, default = 12 } +AHB_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16", "DIV64", "DIV128", "DIV256", "DIV512"], default = "DIV1" } +APB_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16"], default = "DIV2" } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:7210142a748d436c3ed78a4152bfc6c3afaa9a0b1367d992899a560d5db171e2", +"sha512:427a2147011a6e5f390d93f9046b4cab420096f2634ccff94f3ae53dbc7b65cfd4b2d8f9d690e56e3066a17a0dba60c7e0d995d9ac5962868a14e37cc8a24c5e", +] +url = "https://github.com/damaki/stm32f0xx-runtimes/releases/download/v15.0.1/light-stm32f0xx-15.0.1.tar.gz" + diff --git a/index/li/light_tasking_stm32f0xx/light_tasking_stm32f0xx-15.0.1.toml b/index/li/light_tasking_stm32f0xx/light_tasking_stm32f0xx-15.0.1.toml new file mode 100644 index 00000000..1d0e5ceb --- /dev/null +++ b/index/li/light_tasking_stm32f0xx/light_tasking_stm32f0xx-15.0.1.toml @@ -0,0 +1,112 @@ +name = "light_tasking_stm32f0xx" +description = "light-tasking runtime for the STM32F0xx SoC" +version = "15.0.1" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_tasking_stm32f0xx` in the dependency list: + ```toml + [[depends-on]] + light_tasking_stm32f0xx = "*" + ``` + - if applicable, apply any runtime configuration variables (see below). + +Then edit your project file to add the following elements: + - "with" the run-time project files. With this, gprbuild will compile the run-time before your application + ```ada + with "runtime_build.gpr"; + with "ravenscar_build.gpr"; + ``` + - Specify the `Target` and `Runtime` attributes: + ```ada + for Target use runtime_build'Target; + for Runtime ("Ada") use runtime_build'Runtime ("Ada"); + ``` + - specify the `Linker` switches: + ```ada + package Linker is + for Switches ("Ada") use Runtime_Build.Linker_Switches; + end Linker; + ``` + +The runtime is configurable via Alire crate configuration variables. +See the project website for full details of the available options. + +By default, the runtime is configured for the STM32F072RB. If your board has +a different MCU, then you will need to specify which MCU you are using via +the crate configuration. For example, to configure the runtime for the +STM32F030F4, add the following to your `alire.toml`: +```toml +[configuration.values] +light_tasking_stm32f0xx.MCU_Sub_Family = "F030" +light_tasking_stm32f0xx.MCU_Pin_Count = "F" +light_tasking_stm32f0xx.MCU_User_Code_Memory_Size = "4" +``` + +By default, the runtime configures the clock tree for a 48 MHz system clock +from the high-speed internal (HSI) oscillator. If you want a different clock +configuration, then use the crate configuration variables to specify the +configuration you wish to use. For example, to configure the runtime to +generate a 32 MHz system clock from a 16 MHz HSE crystal oscillator: +```toml +[configuration.values] +# Configure a 16 MHz HSE crystal oscillator +light_tasking_stm32f0xx.HSE_Clock_Frequency = 16000000 +light_tasking_stm32f0xx.HSE_Bypass = false + +# Use the PLL as the SYSCLK source +light_tasking_stm32f0xx.SYSCLK_Src = "PLL" + +# Configure the PLL input for a 16 MHz input from the HSE +light_tasking_stm32f0xx.PLL_Src = "HSE_PREDIV" +light_tasking_stm32f0xx.PREDIV = 1 + +# Configure the PLL to output 32 MHz (16 MHz * 2) +light_tasking_stm32f0xx.PLLMUL = 2 + +# Configure the AHB an APB to also run at 32 MHz +light_tasking_stm32f0xx.AHB_Pre = "DIV1" +light_tasking_stm32f0xx.APB_Pre = "DIV1" +``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime", "stm32f0"] +website = "https://github.com/damaki/stm32f0xx-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +MCU_Sub_Family = { type = "Enum", values = ["F030", "F031", "F038", "F042", "F048", "F051", "F058", "F070", "F071", "F072", "F078", "F091", "F098"], default = "F072" } +MCU_Pin_Count = { type = "Enum", values = ["C", "E", "F", "G", "K", "R", "V"], default = "R" } +MCU_User_Code_Memory_Size = { type = "String", default = "B" } + +LSI_Enabled = { type = "Boolean", default = true } +HSE_Bypass = { type = "Boolean", default = false } +HSE_Clock_Frequency = { type = "Integer", first = 1, last = 32000000, default = 8000000 } +SYSCLK_Src = { type = "Enum", values = ["HSI", "HSE", "PLL", "HSI48"], default = "PLL" } +PLL_Src = { type = "Enum", values = ["HSI_2", "HSI_PREDIV", "HSE_PREDIV", "HSI48_PREDIV"], default = "HSI_2"} +PREDIV = { type = "Integer", first = 1, last = 16, default = 2 } +PLLMUL = { type = "Integer", first = 2, last = 16, default = 12 } +AHB_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16", "DIV64", "DIV128", "DIV256", "DIV512"], default = "DIV1" } +APB_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16"], default = "DIV2" } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:3f2a8c3653f3fa67f35f7c2b396df31341243b1d6dc670b3b8c730489e9d8bc3", +"sha512:4ac67baafe0c400345e828aa3d6759f46ce1fba3b7f20d9d4d7d36197953399724355f1741253bdb6df61447fdd97ab195fbf78147195851d5d34025a2d07caa", +] +url = "https://github.com/damaki/stm32f0xx-runtimes/releases/download/v15.0.1/light-tasking-stm32f0xx-15.0.1.tar.gz" +