From 883cc887ff7ed2405fd6365c461ca85642cde5ca Mon Sep 17 00:00:00 2001 From: Daniel King Date: Tue, 14 Apr 2026 14:35:01 +0100 Subject: [PATCH] community-bb-runtimes 15.3.0 (#1864) --- .../embedded_nrf52832-15.3.0.toml | 56 +++++++ .../embedded_nrf52833-15.3.0.toml | 56 +++++++ .../embedded_nrf52840-15.3.0.toml | 56 +++++++ .../embedded_nrf54l_app-15.3.0.toml | 70 +++++++++ .../embedded_rp2040-15.3.0.toml | 92 +++++++++++ .../embedded_rp2350-15.3.0.toml | 96 ++++++++++++ .../embedded_stm32f0xx-15.3.0.toml | 112 ++++++++++++++ .../embedded_stm32g0xx-15.3.0.toml | 145 ++++++++++++++++++ .../embedded_stm32g4xx-15.3.0.toml | 144 +++++++++++++++++ .../light_nrf52832/light_nrf52832-15.3.0.toml | 56 +++++++ .../light_nrf52833/light_nrf52833-15.3.0.toml | 56 +++++++ .../light_nrf52840/light_nrf52840-15.3.0.toml | 56 +++++++ .../light_nrf54l_app-15.3.0.toml | 69 +++++++++ .../li/light_rp2040/light_rp2040-15.3.0.toml | 91 +++++++++++ .../li/light_rp2350/light_rp2350-15.3.0.toml | 95 ++++++++++++ .../light_stm32f0xx-15.3.0.toml | 111 ++++++++++++++ .../light_stm32g0xx-15.3.0.toml | 144 +++++++++++++++++ .../light_stm32g4xx-15.3.0.toml | 143 +++++++++++++++++ .../light_tasking_nrf52832-15.3.0.toml | 56 +++++++ .../light_tasking_nrf52833-15.3.0.toml | 56 +++++++ .../light_tasking_nrf52840-15.3.0.toml | 56 +++++++ .../light_tasking_nrf54l_app-15.3.0.toml | 70 +++++++++ .../light_tasking_rp2040-15.3.0.toml | 92 +++++++++++ .../light_tasking_rp2350-15.3.0.toml | 96 ++++++++++++ .../light_tasking_stm32f0xx-15.3.0.toml | 112 ++++++++++++++ .../light_tasking_stm32g0xx-15.3.0.toml | 145 ++++++++++++++++++ .../light_tasking_stm32g4xx-15.3.0.toml | 144 +++++++++++++++++ 27 files changed, 2475 insertions(+) create mode 100644 index/em/embedded_nrf52832/embedded_nrf52832-15.3.0.toml create mode 100644 index/em/embedded_nrf52833/embedded_nrf52833-15.3.0.toml create mode 100644 index/em/embedded_nrf52840/embedded_nrf52840-15.3.0.toml create mode 100644 index/em/embedded_nrf54l_app/embedded_nrf54l_app-15.3.0.toml create mode 100644 index/em/embedded_rp2040/embedded_rp2040-15.3.0.toml create mode 100644 index/em/embedded_rp2350/embedded_rp2350-15.3.0.toml create mode 100644 index/em/embedded_stm32f0xx/embedded_stm32f0xx-15.3.0.toml create mode 100644 index/em/embedded_stm32g0xx/embedded_stm32g0xx-15.3.0.toml create mode 100644 index/em/embedded_stm32g4xx/embedded_stm32g4xx-15.3.0.toml create mode 100644 index/li/light_nrf52832/light_nrf52832-15.3.0.toml create mode 100644 index/li/light_nrf52833/light_nrf52833-15.3.0.toml create mode 100644 index/li/light_nrf52840/light_nrf52840-15.3.0.toml create mode 100644 index/li/light_nrf54l_app/light_nrf54l_app-15.3.0.toml create mode 100644 index/li/light_rp2040/light_rp2040-15.3.0.toml create mode 100644 index/li/light_rp2350/light_rp2350-15.3.0.toml create mode 100644 index/li/light_stm32f0xx/light_stm32f0xx-15.3.0.toml create mode 100644 index/li/light_stm32g0xx/light_stm32g0xx-15.3.0.toml create mode 100644 index/li/light_stm32g4xx/light_stm32g4xx-15.3.0.toml create mode 100644 index/li/light_tasking_nrf52832/light_tasking_nrf52832-15.3.0.toml create mode 100644 index/li/light_tasking_nrf52833/light_tasking_nrf52833-15.3.0.toml create mode 100644 index/li/light_tasking_nrf52840/light_tasking_nrf52840-15.3.0.toml create mode 100644 index/li/light_tasking_nrf54l_app/light_tasking_nrf54l_app-15.3.0.toml create mode 100644 index/li/light_tasking_rp2040/light_tasking_rp2040-15.3.0.toml create mode 100644 index/li/light_tasking_rp2350/light_tasking_rp2350-15.3.0.toml create mode 100644 index/li/light_tasking_stm32f0xx/light_tasking_stm32f0xx-15.3.0.toml create mode 100644 index/li/light_tasking_stm32g0xx/light_tasking_stm32g0xx-15.3.0.toml create mode 100644 index/li/light_tasking_stm32g4xx/light_tasking_stm32g4xx-15.3.0.toml diff --git a/index/em/embedded_nrf52832/embedded_nrf52832-15.3.0.toml b/index/em/embedded_nrf52832/embedded_nrf52832-15.3.0.toml new file mode 100644 index 00000000..ce885c1b --- /dev/null +++ b/index/em/embedded_nrf52832/embedded_nrf52832-15.3.0.toml @@ -0,0 +1,56 @@ +name = "embedded_nrf52832" +description = "embedded runtime for the NRF52832 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `embedded_nrf52832` in the dependency list: + ```toml + [[depends-on]] + embedded_nrf52832 = "*" + ``` + +Then edit your project file to add the following elements: + - "with" the run-time project file. With this, gprbuild will compile the run-time before your application + ```ada + with "$(runtime_proj_prefix)_build.gpr"; + ``` + - Specify the `Target` and `Runtime` attributes: + ```ada + for Target use $(runtime_proj_prefix)_build'Target; + for Runtime ("Ada") use $(runtime_proj_prefix)_build'Runtime ("Ada"); + ``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +generate_gpr = false +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +Time_Base = { type = "Enum", values = ["RTC0", "RTC1", "RTC2"], default = "RTC2" } +LFCLK_Src = { type = "Enum", values = ["Xtal", "RC", "Synth"], default = "Xtal" } +Use_SWO_Trace = { type = "Boolean", default = true } +Use_Reset_Pin = { type = "Boolean", default = true } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:3b05d8df5c1d34f670a7602d39e46f0a5bbfbced19cee6511bd4da4c3c3e978c", +"sha512:9979db5bc19203fb91722f4511ab9c771350d4720256739265a995b1c89ddffa75e585cdae94bc0cd030a51cab179ee5515e01ec113843cc2b654f21c346aeec", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/embedded-nrf52832-15.3.0.tar.gz" + diff --git a/index/em/embedded_nrf52833/embedded_nrf52833-15.3.0.toml b/index/em/embedded_nrf52833/embedded_nrf52833-15.3.0.toml new file mode 100644 index 00000000..86774092 --- /dev/null +++ b/index/em/embedded_nrf52833/embedded_nrf52833-15.3.0.toml @@ -0,0 +1,56 @@ +name = "embedded_nrf52833" +description = "embedded runtime for the NRF52833 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `embedded_nrf52833` in the dependency list: + ```toml + [[depends-on]] + embedded_nrf52833 = "*" + ``` + +Then edit your project file to add the following elements: + - "with" the run-time project file. With this, gprbuild will compile the run-time before your application + ```ada + with "$(runtime_proj_prefix)_build.gpr"; + ``` + - Specify the `Target` and `Runtime` attributes: + ```ada + for Target use $(runtime_proj_prefix)_build'Target; + for Runtime ("Ada") use $(runtime_proj_prefix)_build'Runtime ("Ada"); + ``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +generate_gpr = false +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +Time_Base = { type = "Enum", values = ["RTC0", "RTC1", "RTC2"], default = "RTC2" } +LFCLK_Src = { type = "Enum", values = ["Xtal", "RC", "Synth"], default = "Xtal" } +Use_SWO_Trace = { type = "Boolean", default = true } +Use_Reset_Pin = { type = "Boolean", default = true } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:02ee675a6d9fd2588f7f600b2272dca062b6bc369f48774d27e294df2b3d1669", +"sha512:b9c59bd0687dd75bfd257817f46669c04e38106ecba79c34cc402111f829210ee20418590b4799ca9cc3db7eff3bb83bb2a3902f3647ed55f93fb61bba502b27", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/embedded-nrf52833-15.3.0.tar.gz" + diff --git a/index/em/embedded_nrf52840/embedded_nrf52840-15.3.0.toml b/index/em/embedded_nrf52840/embedded_nrf52840-15.3.0.toml new file mode 100644 index 00000000..a149979c --- /dev/null +++ b/index/em/embedded_nrf52840/embedded_nrf52840-15.3.0.toml @@ -0,0 +1,56 @@ +name = "embedded_nrf52840" +description = "embedded runtime for the NRF52840 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `embedded_nrf52840` in the dependency list: + ```toml + [[depends-on]] + embedded_nrf52840 = "*" + ``` + +Then edit your project file to add the following elements: + - "with" the run-time project file. With this, gprbuild will compile the run-time before your application + ```ada + with "$(runtime_proj_prefix)_build.gpr"; + ``` + - Specify the `Target` and `Runtime` attributes: + ```ada + for Target use $(runtime_proj_prefix)_build'Target; + for Runtime ("Ada") use $(runtime_proj_prefix)_build'Runtime ("Ada"); + ``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +generate_gpr = false +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +Time_Base = { type = "Enum", values = ["RTC0", "RTC1", "RTC2"], default = "RTC2" } +LFCLK_Src = { type = "Enum", values = ["Xtal", "RC", "Synth"], default = "Xtal" } +Use_SWO_Trace = { type = "Boolean", default = true } +Use_Reset_Pin = { type = "Boolean", default = true } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:04efb41b61ffbf8cc7064de7222c996c168312679ec7d1f322e5fe491652e49a", +"sha512:05978f9aced89a024ee7ac06f76a9c315170360dfc20d9a1323772fe9822c5ed7b6a232626fcae077159facfb4d5b7583b21c9772d3000c7c89b4899b8866e47", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/embedded-nrf52840-15.3.0.tar.gz" + diff --git a/index/em/embedded_nrf54l_app/embedded_nrf54l_app-15.3.0.toml b/index/em/embedded_nrf54l_app/embedded_nrf54l_app-15.3.0.toml new file mode 100644 index 00000000..2a54245e --- /dev/null +++ b/index/em/embedded_nrf54l_app/embedded_nrf54l_app-15.3.0.toml @@ -0,0 +1,70 @@ +name = "embedded_nrf54l_app" +description = "embedded runtime for the nRF54L series" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `embedded_nrf54l_app` in the dependency list: + ```toml + [[depends-on]] + embedded_nrf54l_app = "*" + ``` + +Then edit your project file to add the following elements: + - "with" the run-time project files: + ```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 & ("-Wl,--gc-sections"); + end Linker; + ``` + +Note that the linker switch `-Wl,--gc-sections` is optional, but its use is +recommended since it reduces the final size of the executable by removing +unused code. +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +output_dir = "gnat_user" + +[configuration.variables] +Device = { type = "Enum", values = ["nRF54L05", "nRF54L10", "nRF54L15", "nRF54LS05A", "nRF54LS05B", "nRF54LV10A", "nRF54LM20A", "nRF54LM20B"], default = "nRF54L15" } +MCU_Domain_Speed = { type = "Enum", values = ["CK64M", "CK128M"], default = "CK64M" } +Time_Base_GRTC_IRQ = { type = "Integer", first = 0, last = 3, default = 3 } +Time_Base_GRTC_CCn = { type = "Integer", first = 0, last = 11, default = 11} +Security_Level = { type = "Enum", values = [ "Secure", "Non_Secure" ], default = "Secure" } +LFCLK_Src = { type = "Enum", values = ["LFXO", "LFRC", "LFSYNT"], default = "LFXO" } +Enable_SWO = { type = "Boolean", default = true } +Enable_Trace = { type = "Boolean", default = false } +Enable_Glitch_Detector = { type = "Boolean", default = true } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:c224326c773bef608ffc94bd4112b18601ea350cd1e0322d035aa71ae3024770", +"sha512:dfb937797ad578a12b01fd3729ac32a314c21e0cf7805cbcd703255492b15c682d9247e38c9c8f3175f7319c1cb35fb4c7c1d5c21b21df490a9a8237935073d3", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/embedded-nrf54l_app-15.3.0.tar.gz" + diff --git a/index/em/embedded_rp2040/embedded_rp2040-15.3.0.toml b/index/em/embedded_rp2040/embedded_rp2040-15.3.0.toml new file mode 100644 index 00000000..edff49e4 --- /dev/null +++ b/index/em/embedded_rp2040/embedded_rp2040-15.3.0.toml @@ -0,0 +1,92 @@ +name = "embedded_rp2040" +description = "embedded runtime for the RP2040 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `embedded_rp2040` in the dependency list: + ```toml + [[depends-on]] + embedded_rp2040 = "*" + ``` + +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 & ("-Wl,--gc-sections"); + end Linker; + ``` + Note that `--gc-switches` is recommended as it reduces flash and RAM usage + by removing unused code and data, but it is not mandatory. + +See the project website for details on configuring the runtime. +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +output_dir = "gnat_user" + +[configuration.variables] + +# Configures how many of the two cores the runtime uses +Max_CPUs = { type = "Integer", first = 1, last = 2, default = 2 } + +# Configures which ALARM the runtime uses to implement the semantics of +# Ada.Real_Time +Time_Base = { type = "Enum", values = ["ALARM0", "ALARM1", "ALARM2", "ALARM3"], default = "ALARM3" } + +# Configures the runtime for a specific board. +# For "generic" boards, the board characteristics (flash chip, XOSC frequency) +# can be configured manually. +Board = { type = "Enum", values = [ "generic_board", "rpi_pico", "adafruit_feather_rp2040", "adafruit_itsybitsy_rp2040", "adafruit_macropad_rp2040", "adafruit_qt2040_trinkey", "adafruit_qtpy_rp2040", "arduino_nano_rp2040_connect", "pimoroni_interstate75", "pimoroni_keybow2040", "pimoroni_pga2040", "pimoroni_picolipo_4m", "pimoroni_picolipo_16m", "pimoroni_picosystem", "pimoroni_plasma2040", "pimoroni_tiny2040", "sparkfun_micromod", "sparkfun_promicro", "sparkfun_thingplus" ], default = "rpi_pico" } + +# These configure the board parameters for when Board is "generic_board". +# These are ignored when Board is not "generic_board". +XOSC_Frequency = { type = "Integer", first = 0, default = 12000000 } +XOSC_Startup_Delay_Mult = { type = "Integer", first = 1, last = 16383, default = 64 } +Flash_Chip = { type = "Enum", values = [ "generic_qspi_128", "at25sf128a", "gd25q64c", "w25q16jv", "w25q32jv", "w25q64jv", "w25q128jv"], default = "generic_qspi_128" } + +# Clock configuration +PLL_Sys_Reference_Div = { type = "Integer", first = 1, last = 63, default = 1 } +PLL_Sys_VCO_Multiple = { type = "Integer", first = 16, last = 320, default = 125 } +PLL_Sys_Post_Div_1 = { type = "Integer", first = 1, last = 7, default = 6 } +PLL_Sys_Post_Div_2 = { type = "Integer", first = 1, last = 7, default = 2 } +PLL_USB_Reference_Div = { type = "Integer", first = 1, last = 63, default = 1 } +PLL_USB_VCO_Multiple = { type = "Integer", first = 16, last = 320, default = 40 } +PLL_USB_Post_Div_1 = { type = "Integer", first = 1, last = 7, default = 5 } +PLL_USB_Post_Div_2 = { type = "Integer", first = 1, last = 7, default = 2 } + +Interrupt_Stack_Size = { type = "Integer", first = 1, default = 1024 } +Interrupt_Secondary_Stack_Size = { type = "Integer", first = 1, default = 128 } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:860ea34add08105ee3ee2caf558060cd516e3e607a865eccbf10fff65748b3a4", +"sha512:15f02b9bd4998f90e4b2019e8c30d8b5dbd5f2a84445d6806289fba47adda366b861a03026943d0caa8c1581aff95e1602301d8c861f61e5f45703e38e6da4ca", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/embedded-rp2040-15.3.0.tar.gz" + diff --git a/index/em/embedded_rp2350/embedded_rp2350-15.3.0.toml b/index/em/embedded_rp2350/embedded_rp2350-15.3.0.toml new file mode 100644 index 00000000..0329fd73 --- /dev/null +++ b/index/em/embedded_rp2350/embedded_rp2350-15.3.0.toml @@ -0,0 +1,96 @@ +name = "embedded_rp2350" +description = "embedded runtime for the RP2350 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `embedded_rp2350` in the dependency list: + ```toml + [[depends-on]] + embedded_rp2350 = "*" + ``` + +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 & ("-Wl,--gc-sections"); + end Linker; + ``` + Note that `--gc-switches` is recommended as it reduces flash and RAM usage + by removing unused code and data, but it is not mandatory. + +See the project website for details on configuring the runtime. +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +output_dir = "gnat_user" + +[configuration.variables] + +# Configures how many of the two cores the runtime uses +Max_CPUs = { type = "Integer", first = 1, last = 2, default = 2 } + +# Configures the Arm security level that the partition will run at (Secure or Non-Secure) +Security_Level = { type = "Enum", values = [ "Secure", "Non_Secure" ], default = "Secure" } + +# Configures which ALARM the runtime uses to implement the semantics of +# Ada.Real_Time +Time_Base_Timer = { type = "Enum", values = [ "TIMER0", "TIMER1" ], default = "TIMER0" } +Time_Base_Alarm = { type = "Enum", values = [ "ALARM0", "ALARM1", "ALARM2", "ALARM3" ], default = "ALARM3" } + +# Configures the runtime for a specific board. +# For "generic" boards, the board characteristics (flash chip, XOSC frequency) +# can be configured manually. +Board = { type = "Enum", values = [ "generic_board", "rpi_pico2", "pimoroni_pico_lipo_2_xl_w", "pimoroni_pico_plus_2", "pimoroni_plasma_2350", "pimoroni_tiny_2350", "pimoroni_rp2350_stamp_xl", "pimoroni_rp2350_stamp", "pimoroni_pga2350", "adafruit_feather_rp2350", "adafruit_metro_rp2350", "adafruit_fruit_jam" ], default = "rpi_pico2" } + +# These configure the board parameters for when Board is "generic_board". +# These are ignored when Board is not "generic_board". +XOSC_Frequency = { type = "Integer", first = 0, default = 12000000 } +XOSC_Startup_Delay_Mult = { type = "Integer", first = 1, last = 16383, default = 64 } +Flash_Size = { type = "Integer", first = 2, last = 16, default = 2 } + +# Clock configuration +PLL_Sys_Reference_Div = { type = "Integer", first = 1, last = 63, default = 1 } +PLL_Sys_VCO_Multiple = { type = "Integer", first = 16, last = 320, default = 125 } +PLL_Sys_Post_Div_1 = { type = "Integer", first = 1, last = 7, default = 5 } +PLL_Sys_Post_Div_2 = { type = "Integer", first = 1, last = 7, default = 2 } +PLL_USB_Reference_Div = { type = "Integer", first = 1, last = 63, default = 1 } +PLL_USB_VCO_Multiple = { type = "Integer", first = 16, last = 320, default = 40 } +PLL_USB_Post_Div_1 = { type = "Integer", first = 1, last = 7, default = 5 } +PLL_USB_Post_Div_2 = { type = "Integer", first = 1, last = 7, default = 2 } + +Interrupt_Stack_Size = { type = "Integer", first = 1, default = 1024 } +Interrupt_Secondary_Stack_Size = { type = "Integer", first = 1, default = 128 } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:d190b6f7d72682900f2984ecef7d25a45035a1fd92c04cd6bb6ddd84404e2165", +"sha512:cf9ccedbeb31aebd5e3862057b7fd44d23e451eb681f563fa276e96207a61602c28ce874a130be0c53cbddc43217aa306f0ba28aad77eb0c72c1f56f6e19dd16", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/embedded-rp2350-15.3.0.tar.gz" + diff --git a/index/em/embedded_stm32f0xx/embedded_stm32f0xx-15.3.0.toml b/index/em/embedded_stm32f0xx/embedded_stm32f0xx-15.3.0.toml new file mode 100644 index 00000000..0edf709d --- /dev/null +++ b/index/em/embedded_stm32f0xx/embedded_stm32f0xx-15.3.0.toml @@ -0,0 +1,112 @@ +name = "embedded_stm32f0xx" +description = "embedded runtime for the STM32F0XX SoC" +version = "15.3.0" + +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/community-bb-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:9c1019077712c2a83f79797ca56b008ce2d867cecd27e0f9d809f20549b0d185", +"sha512:a8474cb63cdb73d42eead10eaaab1a445338c5e1fc0bc925a98410788280852d0ad6b21d5551a4b4eec1ce1bf03637a49f67681020ec509e5a6264ac18bee383", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/embedded-stm32f0xx-15.3.0.tar.gz" + diff --git a/index/em/embedded_stm32g0xx/embedded_stm32g0xx-15.3.0.toml b/index/em/embedded_stm32g0xx/embedded_stm32g0xx-15.3.0.toml new file mode 100644 index 00000000..8b1f8358 --- /dev/null +++ b/index/em/embedded_stm32g0xx/embedded_stm32g0xx-15.3.0.toml @@ -0,0 +1,145 @@ +name = "embedded_stm32g0xx" +description = "embedded runtime for the STM32G0XX SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `embedded_stm32g0xx` in the dependency list: + ```toml + [[depends-on]] + embedded_stm32g0xx = "*" + ``` + - 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 STM32G0B1RE. 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 +STM32G031J4, add the following to your `alire.toml`: +```toml +[configuration.values] +embedded_stm32g0xx.MCU_Sub_Family = "G031" +embedded_stm32g0xx.MCU_Flash_Memory_Size = "4" +``` + +By default, the runtime configures the clock tree for a 64 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 64 MHz system clock from a 24 MHz HSE crystal oscillator: +```toml +[configuration.values] +# Configure a 24 MHz HSE crystal oscillator +light_tasking_stm32g0xx.HSE_Clock_Frequency = 24000000 +light_tasking_stm32g0xx.HSE_Bypass = false + +# Select PLLRCLK as the SYSCLK source +light_tasking_stm32g0xx.SYSCLK_Src = "PLLRCLK" + +# Configure the PLL VCO to run at 128 MHz from the 24 MHz HSE (fVCO = fHSE * (N/M)) +light_tasking_stm32g0xx.PLL_Src = "HSE" +light_tasking_stm32g0xx.PLL_N_Mul = 10 +light_tasking_stm32g0xx.PLL_M_Div = 2 + +# Configure the PLLRCLK to run at 64 MHz from the 128 MHz VCO. +light_tasking_stm32g0xx.PLL_R_Div = 2 + +# Configure the AHB an APB to also run at 64 MHz +light_tasking_stm32g0xx.AHB_Pre = "DIV1" +light_tasking_stm32g0xx.APB_Pre = "DIV1" +``` + +The runtime will generate a compile time error when an invalid PLL configuration +is set. + +By default the PLL's Q and P clocks are enabled. If you don't need them, then you +can disable them via the crate configuration: +```toml +[configuration.values] +embedded_stm32g0xx.PLL_Q_Enable = false +embedded_stm32g0xx.PLL_P_Enable = false +``` + +The runtime will enable the PLL only when either `PLL_Q_Enable` or `PLL_P_Enable` +is `true`, or when `SYSCLK_Src = "PLLRCLK"`. + +The interrupt stack sizes are also configurable: +```toml +[configuration.values] +embedded_stm32g0xx.Interrupt_Stack_Size = 1024 +embedded_stm32g0xx.Interrupt_Secondary_Stack_Size = 128 +``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime", "stm32g0"] +website = "https://github.com/damaki/community-bb-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 = ["G030", "G031", "G041", "G050", "G051", "G061", "G070", "G071", "G081", "G0B0", "G0B1", "G0C1"], default = "G0B1" } +MCU_Flash_Memory_Size = { type = "String", default = "B" } + +RAM_Parity_Check = { type = "Enum", values = ["Disabled", "Enabled"], default = "Disabled" } + +LSI_Enabled = { type = "Boolean", default = true } +LSE_Enabled = { type = "Boolean", default = false } +LSE_Bypass = { type = "Boolean", default = false } +HSE_Bypass = { type = "Boolean", default = false } +HSE_Clock_Frequency = { type = "Integer", first = 1, last = 48000000, default = 8000000 } +PLL_Src = { type = "Enum", values = ["HSE", "HSI16"], default = "HSI16" } +PLL_M_Div = { type = "Integer", first = 1, last = 8, default = 2 } +PLL_N_Mul = { type = "Integer", first = 8, last = 86, default = 16 } +PLL_R_Div = { type = "Integer", first = 2, last = 8, default = 2 } +PLL_Q_Div = { type = "Integer", first = 2, last = 8, default = 2 } +PLL_P_Div = { type = "Integer", first = 2, last = 32, default = 2 } +PLL_Q_Enable = { type = "Boolean", default = true } +PLL_P_Enable = { type = "Boolean", default = true } +HSI_Div = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16", "DIV32", "DIV64", "DIV128"], default = "DIV1" } +SYSCLK_Src = { type = "Enum", values = ["LSE", "LSI", "HSE", "PLLRCLK", "HSISYS"], default = "PLLRCLK" } +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 = "DIV1" } + +Interrupt_Stack_Size = { type = "Integer", first = 1, default = 1024 } +Interrupt_Secondary_Stack_Size = { type = "Integer", first = 1, default = 128 } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:60b0a159ccd65a9b4dcc543285627e3307fbba26a3b9a28b57d87234129fd28a", +"sha512:1a80a393335bdc0ac9358503b11df28190175f9e0cf61d112276ac9e4b57b6fb0e3c3ae21c70bfc2f4f0dc65355be3736e545f19c1676c2ead8456485b67d925", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/embedded-stm32g0xx-15.3.0.tar.gz" + diff --git a/index/em/embedded_stm32g4xx/embedded_stm32g4xx-15.3.0.toml b/index/em/embedded_stm32g4xx/embedded_stm32g4xx-15.3.0.toml new file mode 100644 index 00000000..dcef9db4 --- /dev/null +++ b/index/em/embedded_stm32g4xx/embedded_stm32g4xx-15.3.0.toml @@ -0,0 +1,144 @@ +name = "embedded_stm32g4xx" +description = "embedded runtime for the STM32G4XX SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `embedded_stm32g4xx` in the dependency list: + ```toml + [[depends-on]] + embedded_stm32g4xx = "*" + ``` + - 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 STM32G474RE. If you are using +a different MCU, then you will need to configure the runtime by adding the +following to your `alire.toml`. For example, to configure the runtime for the +STM32G431K6: +```toml +[configuration.values] +embedded_stm32g4xx.MCU_Sub_Family = "G431" +embedded_stm32g4xx.MCU_Flash_Memory_Size = "6" +``` + +By default, the runtime configures the clock tree for a 170 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 170 MHz system clock from a 24 MHz HSE crystal oscillator: +```toml +[configuration.values] +# Configure a 24 MHz HSE crystal oscillator +embedded_stm32g4xx.HSE_Clock_Frequency = 24000000 +embedded_stm32g4xx.HSE_Bypass = false + +# Select PLLRCLK as the SYSCLK source +embedded_stm32g4xx.SYSCLK_Src = "PLLRCLK" + +# Configure the PLL VCO to run at 340 MHz from the 24 MHz HSE (fVCO = fHSE * (N/M)) +embedded_stm32g4xx.PLL_Src = "HSE" +embedded_stm32g4xx.PLL_N_Mul = 85 +embedded_stm32g4xx.PLL_M_Div = 6 + +# Configure the PLLRCLK to run at 170 MHz from the 340 MHz VCO. +embedded_stm32g4xx.PLL_R_Div = 2 + +# Configure the AHB and APB to also run at 170 MHz +embedded_stm32g4xx.AHB_Pre = "DIV1" +embedded_stm32g4xx.APB1_Pre = "DIV1" +embedded_stm32g4xx.APB2_Pre = "DIV1" +``` + +The runtime will generate a compile time error when an invalid PLL configuration +is set. + +By default the PLL's Q and P clocks are enabled. If you don't need them, then you +can disable them via the crate configuration: +```toml +[configuration.values] +embedded_stm32g4xx.PLL_Q_Enable = false +embedded_stm32g4xx.PLL_P_Enable = false +``` + +The runtime will enable the PLL only when either `PLL_Q_Enable` or `PLL_P_Enable` +is `true`, or when `SYSCLK_Src = "PLLRCLK"`. + +The interrupt stack sizes are also configurable: +```toml +[configuration.values] +embedded_stm32g4xx.Interrupt_Stack_Size = 1024 +embedded_stm32g4xx.Interrupt_Secondary_Stack_Size = 128 +``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime", "stm32g4"] +website = "https://github.com/damaki/community-bb-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 = ["G431", "G441", "G491", "G4A1", "G473", "G483", "G474", "G484"], default = "G474" } +MCU_Flash_Memory_Size = { type = "String", default = "E" } + +LSI_Enabled = { type = "Boolean", default = true } +LSE_Enabled = { type = "Boolean", default = false } +LSE_Bypass = { type = "Boolean", default = false } +HSE_Bypass = { type = "Boolean", default = false } +HSE_Clock_Frequency = { type = "Integer", first = 4000000, last = 48000000, default = 24000000 } +PLL_Src = { type = "Enum", values = ["HSE", "HSI16"], default = "HSI16" } +PLL_M_Div = { type = "Integer", first = 1, last = 16, default = 4 } +PLL_N_Mul = { type = "Integer", first = 8, last = 127, default = 85 } +PLL_R_Div = { type = "Enum", values = ["DIV2", "DIV4", "DIV6", "DIV8"], default = "DIV2" } +PLL_Q_Div = { type = "Enum", values = ["DIV2", "DIV4", "DIV6", "DIV8"], default = "DIV2" } +PLL_P_Div = { type = "Integer", first = 2, last = 31, default = 2 } +PLL_Q_Enable = { type = "Boolean", default = true } +PLL_P_Enable = { type = "Boolean", default = true } +SYSCLK_Src = { type = "Enum", values = ["HSI16", "HSE", "PLLRCLK"], default = "PLLRCLK" } +AHB_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16", "DIV64", "DIV128", "DIV256", "DIV512"], default = "DIV1" } +APB1_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16"], default = "DIV1" } +APB2_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16"], default = "DIV1" } + +Interrupt_Stack_Size = { type = "Integer", first = 1, default = 1024 } +Interrupt_Secondary_Stack_Size = { type = "Integer", first = 1, default = 128 } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:1ecdb8868960ae9586ef1f30956ca8d754a46cb4145272767a6bfce03cf280b2", +"sha512:33acee5060c38caf320da34a839c851f8860a1874e9604993b061b2dbf9ef3780b83ebe79dccc1c8641d02e7491fb79128655d4ee2c8d6210f1f6e230c14095f", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/embedded-stm32g4xx-15.3.0.tar.gz" + diff --git a/index/li/light_nrf52832/light_nrf52832-15.3.0.toml b/index/li/light_nrf52832/light_nrf52832-15.3.0.toml new file mode 100644 index 00000000..2b1b53fc --- /dev/null +++ b/index/li/light_nrf52832/light_nrf52832-15.3.0.toml @@ -0,0 +1,56 @@ +name = "light_nrf52832" +description = "light runtime for the NRF52832 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_nrf52832` in the dependency list: + ```toml + [[depends-on]] + light_nrf52832 = "*" + ``` + +Then edit your project file to add the following elements: + - "with" the run-time project file. With this, gprbuild will compile the run-time before your application + ```ada + with "$(runtime_proj_prefix)_build.gpr"; + ``` + - Specify the `Target` and `Runtime` attributes: + ```ada + for Target use $(runtime_proj_prefix)_build'Target; + for Runtime ("Ada") use $(runtime_proj_prefix)_build'Runtime ("Ada"); + ``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr'] + +[configuration] +generate_gpr = false +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +Time_Base = { type = "Enum", values = ["RTC0", "RTC1", "RTC2"], default = "RTC2" } +LFCLK_Src = { type = "Enum", values = ["Xtal", "RC", "Synth"], default = "Xtal" } +Use_SWO_Trace = { type = "Boolean", default = true } +Use_Reset_Pin = { type = "Boolean", default = true } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:c77b0bc8665db47ab46aaa9d83209155d2981b3155c32b9158eba3b5f491b8d2", +"sha512:bed6b3150bc55c73a1414a4acfdd92c915199b22589f0567dcf02c00fbfacc1d4a8039c4c0c33b812a75282b8eaf253b8abaa558567d75160f0387328294fa09", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-nrf52832-15.3.0.tar.gz" + diff --git a/index/li/light_nrf52833/light_nrf52833-15.3.0.toml b/index/li/light_nrf52833/light_nrf52833-15.3.0.toml new file mode 100644 index 00000000..7125b98b --- /dev/null +++ b/index/li/light_nrf52833/light_nrf52833-15.3.0.toml @@ -0,0 +1,56 @@ +name = "light_nrf52833" +description = "light runtime for the NRF52833 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_nrf52833` in the dependency list: + ```toml + [[depends-on]] + light_nrf52833 = "*" + ``` + +Then edit your project file to add the following elements: + - "with" the run-time project file. With this, gprbuild will compile the run-time before your application + ```ada + with "$(runtime_proj_prefix)_build.gpr"; + ``` + - Specify the `Target` and `Runtime` attributes: + ```ada + for Target use $(runtime_proj_prefix)_build'Target; + for Runtime ("Ada") use $(runtime_proj_prefix)_build'Runtime ("Ada"); + ``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr'] + +[configuration] +generate_gpr = false +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +Time_Base = { type = "Enum", values = ["RTC0", "RTC1", "RTC2"], default = "RTC2" } +LFCLK_Src = { type = "Enum", values = ["Xtal", "RC", "Synth"], default = "Xtal" } +Use_SWO_Trace = { type = "Boolean", default = true } +Use_Reset_Pin = { type = "Boolean", default = true } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:5c33a5715e41b758aae71e3b8130a16afc9be340e115bdc620d6f1a9fff5a4a9", +"sha512:1306013a95a8b0bc6f80a317a268f6b37608310f61e8f292044ad9867c8eb25a5d27e45b2f8bb9c38832e8f7b6076701c265ec76dde58200af648366fc446522", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-nrf52833-15.3.0.tar.gz" + diff --git a/index/li/light_nrf52840/light_nrf52840-15.3.0.toml b/index/li/light_nrf52840/light_nrf52840-15.3.0.toml new file mode 100644 index 00000000..e9ab1391 --- /dev/null +++ b/index/li/light_nrf52840/light_nrf52840-15.3.0.toml @@ -0,0 +1,56 @@ +name = "light_nrf52840" +description = "light runtime for the NRF52840 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_nrf52840` in the dependency list: + ```toml + [[depends-on]] + light_nrf52840 = "*" + ``` + +Then edit your project file to add the following elements: + - "with" the run-time project file. With this, gprbuild will compile the run-time before your application + ```ada + with "$(runtime_proj_prefix)_build.gpr"; + ``` + - Specify the `Target` and `Runtime` attributes: + ```ada + for Target use $(runtime_proj_prefix)_build'Target; + for Runtime ("Ada") use $(runtime_proj_prefix)_build'Runtime ("Ada"); + ``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr'] + +[configuration] +generate_gpr = false +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +Time_Base = { type = "Enum", values = ["RTC0", "RTC1", "RTC2"], default = "RTC2" } +LFCLK_Src = { type = "Enum", values = ["Xtal", "RC", "Synth"], default = "Xtal" } +Use_SWO_Trace = { type = "Boolean", default = true } +Use_Reset_Pin = { type = "Boolean", default = true } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:d4cfa1f0685e538d3d67c3f17dc49cee03a8a8012271b46bb4bd46db940a585a", +"sha512:cc980e1af0a723a5f19ce2d94e7465623d82a575b2f0927c71a6db05218aac22fa04088df96d9ca5c6fc4138ae3d6144470552dc1879703a274be37beb3fb191", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-nrf52840-15.3.0.tar.gz" + diff --git a/index/li/light_nrf54l_app/light_nrf54l_app-15.3.0.toml b/index/li/light_nrf54l_app/light_nrf54l_app-15.3.0.toml new file mode 100644 index 00000000..19bce4f2 --- /dev/null +++ b/index/li/light_nrf54l_app/light_nrf54l_app-15.3.0.toml @@ -0,0 +1,69 @@ +name = "light_nrf54l_app" +description = "light runtime for the nRF54L series" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_nrf54l_app` in the dependency list: + ```toml + [[depends-on]] + light_nrf54l_app = "*" + ``` + +Then edit your project file to add the following elements: + - "with" the run-time project files: + ```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 & ("-Wl,--gc-sections"); + end Linker; + ``` + +Note that the linker switch `-Wl,--gc-sections` is optional, but its use is +recommended since it reduces the final size of the executable by removing +unused code. +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr'] + +[configuration] +output_dir = "gnat_user" + +[configuration.variables] +Device = { type = "Enum", values = ["nRF54L05", "nRF54L10", "nRF54L15", "nRF54LS05A", "nRF54LS05B", "nRF54LV10A", "nRF54LM20A", "nRF54LM20B"], default = "nRF54L15" } +MCU_Domain_Speed = { type = "Enum", values = ["CK64M", "CK128M"], default = "CK64M" } +Time_Base_GRTC_IRQ = { type = "Integer", first = 0, last = 3, default = 3 } +Time_Base_GRTC_CCn = { type = "Integer", first = 0, last = 11, default = 11} +Security_Level = { type = "Enum", values = [ "Secure", "Non_Secure" ], default = "Secure" } +LFCLK_Src = { type = "Enum", values = ["LFXO", "LFRC", "LFSYNT"], default = "LFXO" } +Enable_SWO = { type = "Boolean", default = true } +Enable_Trace = { type = "Boolean", default = false } +Enable_Glitch_Detector = { type = "Boolean", default = true } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:6ad9aa9e64303361cb281aca681597bc3b5346f0e40236c2e63c1fde5d3eb8d1", +"sha512:725e7dbf3571876c0c54bba7fae15aba0a5d38939f150ff550c72d97b6e13c5a898f5fde4e80fc6984a602e47b4ed8327db35204c75a6250344c358c3611c817", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-nrf54l_app-15.3.0.tar.gz" + diff --git a/index/li/light_rp2040/light_rp2040-15.3.0.toml b/index/li/light_rp2040/light_rp2040-15.3.0.toml new file mode 100644 index 00000000..0e860b22 --- /dev/null +++ b/index/li/light_rp2040/light_rp2040-15.3.0.toml @@ -0,0 +1,91 @@ +name = "light_rp2040" +description = "light runtime for the RP2040 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_rp2040` in the dependency list: + ```toml + [[depends-on]] + light_rp2040 = "*" + ``` + +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 & ("-Wl,--gc-sections"); + end Linker; + ``` + Note that `--gc-switches` is recommended as it reduces flash and RAM usage + by removing unused code and data, but it is not mandatory. + +See the project website for details on configuring the runtime. +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr'] + +[configuration] +output_dir = "gnat_user" + +[configuration.variables] + +# Configures how many of the two cores the runtime uses +Max_CPUs = { type = "Integer", first = 1, last = 1, default = 1 } + +# Configures which ALARM the runtime uses to implement the semantics of +# Ada.Real_Time +Time_Base = { type = "Enum", values = ["ALARM0", "ALARM1", "ALARM2", "ALARM3"], default = "ALARM3" } + +# Configures the runtime for a specific board. +# For "generic" boards, the board characteristics (flash chip, XOSC frequency) +# can be configured manually. +Board = { type = "Enum", values = [ "generic_board", "rpi_pico", "adafruit_feather_rp2040", "adafruit_itsybitsy_rp2040", "adafruit_macropad_rp2040", "adafruit_qt2040_trinkey", "adafruit_qtpy_rp2040", "arduino_nano_rp2040_connect", "pimoroni_interstate75", "pimoroni_keybow2040", "pimoroni_pga2040", "pimoroni_picolipo_4m", "pimoroni_picolipo_16m", "pimoroni_picosystem", "pimoroni_plasma2040", "pimoroni_tiny2040", "sparkfun_micromod", "sparkfun_promicro", "sparkfun_thingplus" ], default = "rpi_pico" } + +# These configure the board parameters for when Board is "generic_board". +# These are ignored when Board is not "generic_board". +XOSC_Frequency = { type = "Integer", first = 0, default = 12000000 } +XOSC_Startup_Delay_Mult = { type = "Integer", first = 1, last = 16383, default = 64 } +Flash_Chip = { type = "Enum", values = [ "generic_qspi_128", "at25sf128a", "gd25q64c", "w25q16jv", "w25q32jv", "w25q64jv", "w25q128jv"], default = "generic_qspi_128" } + +# Clock configuration +PLL_Sys_Reference_Div = { type = "Integer", first = 1, last = 63, default = 1 } +PLL_Sys_VCO_Multiple = { type = "Integer", first = 16, last = 320, default = 125 } +PLL_Sys_Post_Div_1 = { type = "Integer", first = 1, last = 7, default = 6 } +PLL_Sys_Post_Div_2 = { type = "Integer", first = 1, last = 7, default = 2 } +PLL_USB_Reference_Div = { type = "Integer", first = 1, last = 63, default = 1 } +PLL_USB_VCO_Multiple = { type = "Integer", first = 16, last = 320, default = 40 } +PLL_USB_Post_Div_1 = { type = "Integer", first = 1, last = 7, default = 5 } +PLL_USB_Post_Div_2 = { type = "Integer", first = 1, last = 7, default = 2 } + +Interrupt_Stack_Size = { type = "Integer", first = 1, default = 1024 } +Interrupt_Secondary_Stack_Size = { type = "Integer", first = 1, default = 128 } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:13bfc37fde4f0dc674a566a4b48bbd606d29c4d3c64c93e0ac6d80ddc8bc3a5a", +"sha512:a05f4a27db3ef1a6e0754fc87a6157c30f580dc80a19e1ae9ddee16843e192685fccdc89e87788e42335884600b2ebbe0573320a7a3647146ce340e54fe10482", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-rp2040-15.3.0.tar.gz" + diff --git a/index/li/light_rp2350/light_rp2350-15.3.0.toml b/index/li/light_rp2350/light_rp2350-15.3.0.toml new file mode 100644 index 00000000..6929d45f --- /dev/null +++ b/index/li/light_rp2350/light_rp2350-15.3.0.toml @@ -0,0 +1,95 @@ +name = "light_rp2350" +description = "light runtime for the RP2350 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_rp2350` in the dependency list: + ```toml + [[depends-on]] + light_rp2350 = "*" + ``` + +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 & ("-Wl,--gc-sections"); + end Linker; + ``` + Note that `--gc-switches` is recommended as it reduces flash and RAM usage + by removing unused code and data, but it is not mandatory. + +See the project website for details on configuring the runtime. +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr'] + +[configuration] +output_dir = "gnat_user" + +[configuration.variables] + +# Configures how many of the two cores the runtime uses +Max_CPUs = { type = "Integer", first = 1, last = 1, default = 1 } + +# Configures the Arm security level that the partition will run at (Secure or Non-Secure) +Security_Level = { type = "Enum", values = [ "Secure", "Non_Secure" ], default = "Secure" } + +# Configures which ALARM the runtime uses to implement the semantics of +# Ada.Real_Time +Time_Base_Timer = { type = "Enum", values = [ "TIMER0", "TIMER1" ], default = "TIMER0" } +Time_Base_Alarm = { type = "Enum", values = [ "ALARM0", "ALARM1", "ALARM2", "ALARM3" ], default = "ALARM3" } + +# Configures the runtime for a specific board. +# For "generic" boards, the board characteristics (flash chip, XOSC frequency) +# can be configured manually. +Board = { type = "Enum", values = [ "generic_board", "rpi_pico2", "pimoroni_pico_lipo_2_xl_w", "pimoroni_pico_plus_2", "pimoroni_plasma_2350", "pimoroni_tiny_2350", "pimoroni_rp2350_stamp_xl", "pimoroni_rp2350_stamp", "pimoroni_pga2350", "adafruit_feather_rp2350", "adafruit_metro_rp2350", "adafruit_fruit_jam" ], default = "rpi_pico2" } + +# These configure the board parameters for when Board is "generic_board". +# These are ignored when Board is not "generic_board". +XOSC_Frequency = { type = "Integer", first = 0, default = 12000000 } +XOSC_Startup_Delay_Mult = { type = "Integer", first = 1, last = 16383, default = 64 } +Flash_Size = { type = "Integer", first = 2, last = 16, default = 2 } + +# Clock configuration +PLL_Sys_Reference_Div = { type = "Integer", first = 1, last = 63, default = 1 } +PLL_Sys_VCO_Multiple = { type = "Integer", first = 16, last = 320, default = 125 } +PLL_Sys_Post_Div_1 = { type = "Integer", first = 1, last = 7, default = 5 } +PLL_Sys_Post_Div_2 = { type = "Integer", first = 1, last = 7, default = 2 } +PLL_USB_Reference_Div = { type = "Integer", first = 1, last = 63, default = 1 } +PLL_USB_VCO_Multiple = { type = "Integer", first = 16, last = 320, default = 40 } +PLL_USB_Post_Div_1 = { type = "Integer", first = 1, last = 7, default = 5 } +PLL_USB_Post_Div_2 = { type = "Integer", first = 1, last = 7, default = 2 } + +Interrupt_Stack_Size = { type = "Integer", first = 1, default = 1024 } +Interrupt_Secondary_Stack_Size = { type = "Integer", first = 1, default = 128 } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:d1dd15f82f7ff8a54007f9f2b9d8941790c769bb5216d8286b79d1fe413e4744", +"sha512:69b47448d8574561194c7dfa36f93da3435d273d76c5f4b05c288828c7aa2e1f4d10b1ebdf18ff08514f8f82b5084f03e80fe236968ae8fdd66aaeb71f927067", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-rp2350-15.3.0.tar.gz" + diff --git a/index/li/light_stm32f0xx/light_stm32f0xx-15.3.0.toml b/index/li/light_stm32f0xx/light_stm32f0xx-15.3.0.toml new file mode 100644 index 00000000..4cd6f3ba --- /dev/null +++ b/index/li/light_stm32f0xx/light_stm32f0xx-15.3.0.toml @@ -0,0 +1,111 @@ +name = "light_stm32f0xx" +description = "light runtime for the STM32F0XX SoC" +version = "15.3.0" + +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/community-bb-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:ac15c7dc4141381bbc4649fb62b111010cbd8ddc3fce8eaa10e9513768777e62", +"sha512:84b14d5ae51dc7ab79c404b5d9265f12ccf6ecd8be0c8eef5e99b5e56c7eb1876ff3b3a7345eb9ea82b5124a527f5b2cee187b2be98d326fdb3c4b05b03db1a5", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-stm32f0xx-15.3.0.tar.gz" + diff --git a/index/li/light_stm32g0xx/light_stm32g0xx-15.3.0.toml b/index/li/light_stm32g0xx/light_stm32g0xx-15.3.0.toml new file mode 100644 index 00000000..00ca10c7 --- /dev/null +++ b/index/li/light_stm32g0xx/light_stm32g0xx-15.3.0.toml @@ -0,0 +1,144 @@ +name = "light_stm32g0xx" +description = "light runtime for the STM32G0XX SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_stm32g0xx` in the dependency list: + ```toml + [[depends-on]] + light_stm32g0xx = "*" + ``` + - 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 STM32G0B1RE. 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 +STM32G031J4, add the following to your `alire.toml`: +```toml +[configuration.values] +light_stm32g0xx.MCU_Sub_Family = "G031" +light_stm32g0xx.MCU_Flash_Memory_Size = "4" +``` + +By default, the runtime configures the clock tree for a 64 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 64 MHz system clock from a 24 MHz HSE crystal oscillator: +```toml +[configuration.values] +# Configure a 24 MHz HSE crystal oscillator +light_tasking_stm32g0xx.HSE_Clock_Frequency = 24000000 +light_tasking_stm32g0xx.HSE_Bypass = false + +# Select PLLRCLK as the SYSCLK source +light_tasking_stm32g0xx.SYSCLK_Src = "PLLRCLK" + +# Configure the PLL VCO to run at 128 MHz from the 24 MHz HSE (fVCO = fHSE * (N/M)) +light_tasking_stm32g0xx.PLL_Src = "HSE" +light_tasking_stm32g0xx.PLL_N_Mul = 10 +light_tasking_stm32g0xx.PLL_M_Div = 2 + +# Configure the PLLRCLK to run at 64 MHz from the 128 MHz VCO. +light_tasking_stm32g0xx.PLL_R_Div = 2 + +# Configure the AHB an APB to also run at 64 MHz +light_tasking_stm32g0xx.AHB_Pre = "DIV1" +light_tasking_stm32g0xx.APB_Pre = "DIV1" +``` + +The runtime will generate a compile time error when an invalid PLL configuration +is set. + +By default the PLL's Q and P clocks are enabled. If you don't need them, then you +can disable them via the crate configuration: +```toml +[configuration.values] +light_stm32g0xx.PLL_Q_Enable = false +light_stm32g0xx.PLL_P_Enable = false +``` + +The runtime will enable the PLL only when either `PLL_Q_Enable` or `PLL_P_Enable` +is `true`, or when `SYSCLK_Src = "PLLRCLK"`. + +The interrupt stack sizes are also configurable: +```toml +[configuration.values] +light_stm32g0xx.Interrupt_Stack_Size = 1024 +light_stm32g0xx.Interrupt_Secondary_Stack_Size = 128 +``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime", "stm32g0"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr'] + +[configuration] +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +MCU_Sub_Family = { type = "Enum", values = ["G030", "G031", "G041", "G050", "G051", "G061", "G070", "G071", "G081", "G0B0", "G0B1", "G0C1"], default = "G0B1" } +MCU_Flash_Memory_Size = { type = "String", default = "B" } + +RAM_Parity_Check = { type = "Enum", values = ["Disabled", "Enabled"], default = "Disabled" } + +LSI_Enabled = { type = "Boolean", default = true } +LSE_Enabled = { type = "Boolean", default = false } +LSE_Bypass = { type = "Boolean", default = false } +HSE_Bypass = { type = "Boolean", default = false } +HSE_Clock_Frequency = { type = "Integer", first = 1, last = 48000000, default = 8000000 } +PLL_Src = { type = "Enum", values = ["HSE", "HSI16"], default = "HSI16" } +PLL_M_Div = { type = "Integer", first = 1, last = 8, default = 2 } +PLL_N_Mul = { type = "Integer", first = 8, last = 86, default = 16 } +PLL_R_Div = { type = "Integer", first = 2, last = 8, default = 2 } +PLL_Q_Div = { type = "Integer", first = 2, last = 8, default = 2 } +PLL_P_Div = { type = "Integer", first = 2, last = 32, default = 2 } +PLL_Q_Enable = { type = "Boolean", default = true } +PLL_P_Enable = { type = "Boolean", default = true } +HSI_Div = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16", "DIV32", "DIV64", "DIV128"], default = "DIV1" } +SYSCLK_Src = { type = "Enum", values = ["LSE", "LSI", "HSE", "PLLRCLK", "HSISYS"], default = "PLLRCLK" } +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 = "DIV1" } + +Interrupt_Stack_Size = { type = "Integer", first = 1, default = 1024 } +Interrupt_Secondary_Stack_Size = { type = "Integer", first = 1, default = 128 } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:d95d5b6b1d41397d5061cc339d4a06124cdaab1d386c005b9ed376959122bc78", +"sha512:7b50ee3f7ec4136565b6b5180a3bf766f196a149641705aa7bcee92b086543ee19eec8fa82c79d80b1b1494ad0380b2f8cc746cf1d604e6f729937876be98f1c", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-stm32g0xx-15.3.0.tar.gz" + diff --git a/index/li/light_stm32g4xx/light_stm32g4xx-15.3.0.toml b/index/li/light_stm32g4xx/light_stm32g4xx-15.3.0.toml new file mode 100644 index 00000000..eadf045d --- /dev/null +++ b/index/li/light_stm32g4xx/light_stm32g4xx-15.3.0.toml @@ -0,0 +1,143 @@ +name = "light_stm32g4xx" +description = "light runtime for the STM32G4XX SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_stm32g4xx` in the dependency list: + ```toml + [[depends-on]] + light_stm32g4xx = "*" + ``` + - 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 STM32G474RE. If you are using +a different MCU, then you will need to configure the runtime by adding the +following to your `alire.toml`. For example, to configure the runtime for the +STM32G431K6: +```toml +[configuration.values] +light_stm32g4xx.MCU_Sub_Family = "G431" +light_stm32g4xx.MCU_Flash_Memory_Size = "6" +``` + +By default, the runtime configures the clock tree for a 170 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 170 MHz system clock from a 24 MHz HSE crystal oscillator: +```toml +[configuration.values] +# Configure a 24 MHz HSE crystal oscillator +light_stm32g4xx.HSE_Clock_Frequency = 24000000 +light_stm32g4xx.HSE_Bypass = false + +# Select PLLRCLK as the SYSCLK source +light_stm32g4xx.SYSCLK_Src = "PLLRCLK" + +# Configure the PLL VCO to run at 340 MHz from the 24 MHz HSE (fVCO = fHSE * (N/M)) +light_stm32g4xx.PLL_Src = "HSE" +light_stm32g4xx.PLL_N_Mul = 85 +light_stm32g4xx.PLL_M_Div = 6 + +# Configure the PLLRCLK to run at 170 MHz from the 340 MHz VCO. +light_stm32g4xx.PLL_R_Div = 2 + +# Configure the AHB and APB to also run at 170 MHz +light_stm32g4xx.AHB_Pre = "DIV1" +light_stm32g4xx.APB1_Pre = "DIV1" +light_stm32g4xx.APB2_Pre = "DIV1" +``` + +The runtime will generate a compile time error when an invalid PLL configuration +is set. + +By default the PLL's Q and P clocks are enabled. If you don't need them, then you +can disable them via the crate configuration: +```toml +[configuration.values] +light_stm32g4xx.PLL_Q_Enable = false +light_stm32g4xx.PLL_P_Enable = false +``` + +The runtime will enable the PLL only when either `PLL_Q_Enable` or `PLL_P_Enable` +is `true`, or when `SYSCLK_Src = "PLLRCLK"`. + +The interrupt stack sizes are also configurable: +```toml +[configuration.values] +light_stm32g4xx.Interrupt_Stack_Size = 1024 +light_stm32g4xx.Interrupt_Secondary_Stack_Size = 128 +``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime", "stm32g4"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr'] + +[configuration] +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +MCU_Sub_Family = { type = "Enum", values = ["G431", "G441", "G491", "G4A1", "G473", "G483", "G474", "G484"], default = "G474" } +MCU_Flash_Memory_Size = { type = "String", default = "E" } + +LSI_Enabled = { type = "Boolean", default = true } +LSE_Enabled = { type = "Boolean", default = false } +LSE_Bypass = { type = "Boolean", default = false } +HSE_Bypass = { type = "Boolean", default = false } +HSE_Clock_Frequency = { type = "Integer", first = 4000000, last = 48000000, default = 24000000 } +PLL_Src = { type = "Enum", values = ["HSE", "HSI16"], default = "HSI16" } +PLL_M_Div = { type = "Integer", first = 1, last = 16, default = 4 } +PLL_N_Mul = { type = "Integer", first = 8, last = 127, default = 85 } +PLL_R_Div = { type = "Enum", values = ["DIV2", "DIV4", "DIV6", "DIV8"], default = "DIV2" } +PLL_Q_Div = { type = "Enum", values = ["DIV2", "DIV4", "DIV6", "DIV8"], default = "DIV2" } +PLL_P_Div = { type = "Integer", first = 2, last = 31, default = 2 } +PLL_Q_Enable = { type = "Boolean", default = true } +PLL_P_Enable = { type = "Boolean", default = true } +SYSCLK_Src = { type = "Enum", values = ["HSI16", "HSE", "PLLRCLK"], default = "PLLRCLK" } +AHB_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16", "DIV64", "DIV128", "DIV256", "DIV512"], default = "DIV1" } +APB1_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16"], default = "DIV1" } +APB2_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16"], default = "DIV1" } + +Interrupt_Stack_Size = { type = "Integer", first = 1, default = 1024 } +Interrupt_Secondary_Stack_Size = { type = "Integer", first = 1, default = 128 } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:cccbdf20c8945e2a28b8b545b4c603f28eed8a7d11a780d33e33c29c0c1f7af4", +"sha512:23a86d4c72072b04aba0ef4b06cc70bf6cb453f00736132b958a12c573393d82329921143ebc1a44b5324b40e7615b7cf09b9de69f332c3391616a34c4ca727f", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-stm32g4xx-15.3.0.tar.gz" + diff --git a/index/li/light_tasking_nrf52832/light_tasking_nrf52832-15.3.0.toml b/index/li/light_tasking_nrf52832/light_tasking_nrf52832-15.3.0.toml new file mode 100644 index 00000000..0ac60cbf --- /dev/null +++ b/index/li/light_tasking_nrf52832/light_tasking_nrf52832-15.3.0.toml @@ -0,0 +1,56 @@ +name = "light_tasking_nrf52832" +description = "light-tasking runtime for the NRF52832 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_tasking_nrf52832` in the dependency list: + ```toml + [[depends-on]] + light_tasking_nrf52832 = "*" + ``` + +Then edit your project file to add the following elements: + - "with" the run-time project file. With this, gprbuild will compile the run-time before your application + ```ada + with "$(runtime_proj_prefix)_build.gpr"; + ``` + - Specify the `Target` and `Runtime` attributes: + ```ada + for Target use $(runtime_proj_prefix)_build'Target; + for Runtime ("Ada") use $(runtime_proj_prefix)_build'Runtime ("Ada"); + ``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +generate_gpr = false +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +Time_Base = { type = "Enum", values = ["RTC0", "RTC1", "RTC2"], default = "RTC2" } +LFCLK_Src = { type = "Enum", values = ["Xtal", "RC", "Synth"], default = "Xtal" } +Use_SWO_Trace = { type = "Boolean", default = true } +Use_Reset_Pin = { type = "Boolean", default = true } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:2e6b6e5a23b0e0932805f2cc3a4e138597850dc07d14b887b54e1bc8b640e859", +"sha512:f8ddc847856e3c5d8b0d56f7fe92081024cdd6b557447f8b5877b9869bd5d84cd24025ea86825808b8e625cb0482e0f6550c3096d0cf6189024bfcc16f0f72cf", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-tasking-nrf52832-15.3.0.tar.gz" + diff --git a/index/li/light_tasking_nrf52833/light_tasking_nrf52833-15.3.0.toml b/index/li/light_tasking_nrf52833/light_tasking_nrf52833-15.3.0.toml new file mode 100644 index 00000000..3a975c33 --- /dev/null +++ b/index/li/light_tasking_nrf52833/light_tasking_nrf52833-15.3.0.toml @@ -0,0 +1,56 @@ +name = "light_tasking_nrf52833" +description = "light-tasking runtime for the NRF52833 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_tasking_nrf52833` in the dependency list: + ```toml + [[depends-on]] + light_tasking_nrf52833 = "*" + ``` + +Then edit your project file to add the following elements: + - "with" the run-time project file. With this, gprbuild will compile the run-time before your application + ```ada + with "$(runtime_proj_prefix)_build.gpr"; + ``` + - Specify the `Target` and `Runtime` attributes: + ```ada + for Target use $(runtime_proj_prefix)_build'Target; + for Runtime ("Ada") use $(runtime_proj_prefix)_build'Runtime ("Ada"); + ``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +generate_gpr = false +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +Time_Base = { type = "Enum", values = ["RTC0", "RTC1", "RTC2"], default = "RTC2" } +LFCLK_Src = { type = "Enum", values = ["Xtal", "RC", "Synth"], default = "Xtal" } +Use_SWO_Trace = { type = "Boolean", default = true } +Use_Reset_Pin = { type = "Boolean", default = true } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:8543d80e0ef3951f354024f25c827fe357d92b0d34b771f407d6691a0184f236", +"sha512:a1e9095d3b7919b10c82d068c4752da336601b8f8f9794c276c3f6db3234e1ec3125df0447e67ef6cf8f1ed17395c97efabb6d52182631d55950048c64ee97db", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-tasking-nrf52833-15.3.0.tar.gz" + diff --git a/index/li/light_tasking_nrf52840/light_tasking_nrf52840-15.3.0.toml b/index/li/light_tasking_nrf52840/light_tasking_nrf52840-15.3.0.toml new file mode 100644 index 00000000..f8c0217f --- /dev/null +++ b/index/li/light_tasking_nrf52840/light_tasking_nrf52840-15.3.0.toml @@ -0,0 +1,56 @@ +name = "light_tasking_nrf52840" +description = "light-tasking runtime for the NRF52840 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_tasking_nrf52840` in the dependency list: + ```toml + [[depends-on]] + light_tasking_nrf52840 = "*" + ``` + +Then edit your project file to add the following elements: + - "with" the run-time project file. With this, gprbuild will compile the run-time before your application + ```ada + with "$(runtime_proj_prefix)_build.gpr"; + ``` + - Specify the `Target` and `Runtime` attributes: + ```ada + for Target use $(runtime_proj_prefix)_build'Target; + for Runtime ("Ada") use $(runtime_proj_prefix)_build'Runtime ("Ada"); + ``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +generate_gpr = false +generate_c = false +output_dir = "gnat_user" + +[configuration.variables] +Time_Base = { type = "Enum", values = ["RTC0", "RTC1", "RTC2"], default = "RTC2" } +LFCLK_Src = { type = "Enum", values = ["Xtal", "RC", "Synth"], default = "Xtal" } +Use_SWO_Trace = { type = "Boolean", default = true } +Use_Reset_Pin = { type = "Boolean", default = true } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:420c3224eb7e0dbeeecc7f4075989cd45ef4618bd0fb801687488f61542646eb", +"sha512:ad60c853cf4160b6f6571b10c1692c0aa59dfe89197a2c36041e65130e61a7e85eba07fe14d46028445747d8d8bf8b222c2bdcbcce5d5415fb7a9054eb52d33e", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-tasking-nrf52840-15.3.0.tar.gz" + diff --git a/index/li/light_tasking_nrf54l_app/light_tasking_nrf54l_app-15.3.0.toml b/index/li/light_tasking_nrf54l_app/light_tasking_nrf54l_app-15.3.0.toml new file mode 100644 index 00000000..13a8646d --- /dev/null +++ b/index/li/light_tasking_nrf54l_app/light_tasking_nrf54l_app-15.3.0.toml @@ -0,0 +1,70 @@ +name = "light_tasking_nrf54l_app" +description = "light-tasking runtime for the nRF54L series" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_tasking_nrf54l_app` in the dependency list: + ```toml + [[depends-on]] + light_tasking_nrf54l_app = "*" + ``` + +Then edit your project file to add the following elements: + - "with" the run-time project files: + ```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 & ("-Wl,--gc-sections"); + end Linker; + ``` + +Note that the linker switch `-Wl,--gc-sections` is optional, but its use is +recommended since it reduces the final size of the executable by removing +unused code. +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +output_dir = "gnat_user" + +[configuration.variables] +Device = { type = "Enum", values = ["nRF54L05", "nRF54L10", "nRF54L15", "nRF54LS05A", "nRF54LS05B", "nRF54LV10A", "nRF54LM20A", "nRF54LM20B"], default = "nRF54L15" } +MCU_Domain_Speed = { type = "Enum", values = ["CK64M", "CK128M"], default = "CK64M" } +Time_Base_GRTC_IRQ = { type = "Integer", first = 0, last = 3, default = 3 } +Time_Base_GRTC_CCn = { type = "Integer", first = 0, last = 11, default = 11} +Security_Level = { type = "Enum", values = [ "Secure", "Non_Secure" ], default = "Secure" } +LFCLK_Src = { type = "Enum", values = ["LFXO", "LFRC", "LFSYNT"], default = "LFXO" } +Enable_SWO = { type = "Boolean", default = true } +Enable_Trace = { type = "Boolean", default = false } +Enable_Glitch_Detector = { type = "Boolean", default = true } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:b0b2ec4f5e94a93bda45ae84f2a559df95876ca2e723af73479a193926fa4d18", +"sha512:0ecaf4c17a5d979dc03e2219b8992405001a8a761b4384ae349bcb4e5b9f893c57a4f3ee19378faafe7d106c210a333a0ca826d41530f23952232f717e6e5a57", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-tasking-nrf54l_app-15.3.0.tar.gz" + diff --git a/index/li/light_tasking_rp2040/light_tasking_rp2040-15.3.0.toml b/index/li/light_tasking_rp2040/light_tasking_rp2040-15.3.0.toml new file mode 100644 index 00000000..f0f33012 --- /dev/null +++ b/index/li/light_tasking_rp2040/light_tasking_rp2040-15.3.0.toml @@ -0,0 +1,92 @@ +name = "light_tasking_rp2040" +description = "light-tasking runtime for the RP2040 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_tasking_rp2040` in the dependency list: + ```toml + [[depends-on]] + light_tasking_rp2040 = "*" + ``` + +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 & ("-Wl,--gc-sections"); + end Linker; + ``` + Note that `--gc-switches` is recommended as it reduces flash and RAM usage + by removing unused code and data, but it is not mandatory. + +See the project website for details on configuring the runtime. +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +output_dir = "gnat_user" + +[configuration.variables] + +# Configures how many of the two cores the runtime uses +Max_CPUs = { type = "Integer", first = 1, last = 2, default = 2 } + +# Configures which ALARM the runtime uses to implement the semantics of +# Ada.Real_Time +Time_Base = { type = "Enum", values = ["ALARM0", "ALARM1", "ALARM2", "ALARM3"], default = "ALARM3" } + +# Configures the runtime for a specific board. +# For "generic" boards, the board characteristics (flash chip, XOSC frequency) +# can be configured manually. +Board = { type = "Enum", values = [ "generic_board", "rpi_pico", "adafruit_feather_rp2040", "adafruit_itsybitsy_rp2040", "adafruit_macropad_rp2040", "adafruit_qt2040_trinkey", "adafruit_qtpy_rp2040", "arduino_nano_rp2040_connect", "pimoroni_interstate75", "pimoroni_keybow2040", "pimoroni_pga2040", "pimoroni_picolipo_4m", "pimoroni_picolipo_16m", "pimoroni_picosystem", "pimoroni_plasma2040", "pimoroni_tiny2040", "sparkfun_micromod", "sparkfun_promicro", "sparkfun_thingplus" ], default = "rpi_pico" } + +# These configure the board parameters for when Board is "generic_board". +# These are ignored when Board is not "generic_board". +XOSC_Frequency = { type = "Integer", first = 0, default = 12000000 } +XOSC_Startup_Delay_Mult = { type = "Integer", first = 1, last = 16383, default = 64 } +Flash_Chip = { type = "Enum", values = [ "generic_qspi_128", "at25sf128a", "gd25q64c", "w25q16jv", "w25q32jv", "w25q64jv", "w25q128jv"], default = "generic_qspi_128" } + +# Clock configuration +PLL_Sys_Reference_Div = { type = "Integer", first = 1, last = 63, default = 1 } +PLL_Sys_VCO_Multiple = { type = "Integer", first = 16, last = 320, default = 125 } +PLL_Sys_Post_Div_1 = { type = "Integer", first = 1, last = 7, default = 6 } +PLL_Sys_Post_Div_2 = { type = "Integer", first = 1, last = 7, default = 2 } +PLL_USB_Reference_Div = { type = "Integer", first = 1, last = 63, default = 1 } +PLL_USB_VCO_Multiple = { type = "Integer", first = 16, last = 320, default = 40 } +PLL_USB_Post_Div_1 = { type = "Integer", first = 1, last = 7, default = 5 } +PLL_USB_Post_Div_2 = { type = "Integer", first = 1, last = 7, default = 2 } + +Interrupt_Stack_Size = { type = "Integer", first = 1, default = 1024 } +Interrupt_Secondary_Stack_Size = { type = "Integer", first = 1, default = 128 } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:c9c04aed054a908b9754afa252efd7d8b32b06e6ceb86e2d264b452442240de3", +"sha512:7c40cff5459bbbfe41f4d68ce56524499418577ba5dca03f5ed6dd85adf8da051e8c8b4490d9bb8928fe3f876874beffa7ee8074029c84b18fb5342a0c6fe6bb", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-tasking-rp2040-15.3.0.tar.gz" + diff --git a/index/li/light_tasking_rp2350/light_tasking_rp2350-15.3.0.toml b/index/li/light_tasking_rp2350/light_tasking_rp2350-15.3.0.toml new file mode 100644 index 00000000..5074a00a --- /dev/null +++ b/index/li/light_tasking_rp2350/light_tasking_rp2350-15.3.0.toml @@ -0,0 +1,96 @@ +name = "light_tasking_rp2350" +description = "light-tasking runtime for the RP2350 SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_tasking_rp2350` in the dependency list: + ```toml + [[depends-on]] + light_tasking_rp2350 = "*" + ``` + +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 & ("-Wl,--gc-sections"); + end Linker; + ``` + Note that `--gc-switches` is recommended as it reduces flash and RAM usage + by removing unused code and data, but it is not mandatory. + +See the project website for details on configuring the runtime. +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime"] +website = "https://github.com/damaki/community-bb-runtimes" + +project-files = ['runtime_build.gpr', 'ravenscar_build.gpr'] + +[configuration] +output_dir = "gnat_user" + +[configuration.variables] + +# Configures how many of the two cores the runtime uses +Max_CPUs = { type = "Integer", first = 1, last = 2, default = 2 } + +# Configures the Arm security level that the partition will run at (Secure or Non-Secure) +Security_Level = { type = "Enum", values = [ "Secure", "Non_Secure" ], default = "Secure" } + +# Configures which ALARM the runtime uses to implement the semantics of +# Ada.Real_Time +Time_Base_Timer = { type = "Enum", values = [ "TIMER0", "TIMER1" ], default = "TIMER0" } +Time_Base_Alarm = { type = "Enum", values = [ "ALARM0", "ALARM1", "ALARM2", "ALARM3" ], default = "ALARM3" } + +# Configures the runtime for a specific board. +# For "generic" boards, the board characteristics (flash chip, XOSC frequency) +# can be configured manually. +Board = { type = "Enum", values = [ "generic_board", "rpi_pico2", "pimoroni_pico_lipo_2_xl_w", "pimoroni_pico_plus_2", "pimoroni_plasma_2350", "pimoroni_tiny_2350", "pimoroni_rp2350_stamp_xl", "pimoroni_rp2350_stamp", "pimoroni_pga2350", "adafruit_feather_rp2350", "adafruit_metro_rp2350", "adafruit_fruit_jam" ], default = "rpi_pico2" } + +# These configure the board parameters for when Board is "generic_board". +# These are ignored when Board is not "generic_board". +XOSC_Frequency = { type = "Integer", first = 0, default = 12000000 } +XOSC_Startup_Delay_Mult = { type = "Integer", first = 1, last = 16383, default = 64 } +Flash_Size = { type = "Integer", first = 2, last = 16, default = 2 } + +# Clock configuration +PLL_Sys_Reference_Div = { type = "Integer", first = 1, last = 63, default = 1 } +PLL_Sys_VCO_Multiple = { type = "Integer", first = 16, last = 320, default = 125 } +PLL_Sys_Post_Div_1 = { type = "Integer", first = 1, last = 7, default = 5 } +PLL_Sys_Post_Div_2 = { type = "Integer", first = 1, last = 7, default = 2 } +PLL_USB_Reference_Div = { type = "Integer", first = 1, last = 63, default = 1 } +PLL_USB_VCO_Multiple = { type = "Integer", first = 16, last = 320, default = 40 } +PLL_USB_Post_Div_1 = { type = "Integer", first = 1, last = 7, default = 5 } +PLL_USB_Post_Div_2 = { type = "Integer", first = 1, last = 7, default = 2 } + +Interrupt_Stack_Size = { type = "Integer", first = 1, default = 1024 } +Interrupt_Secondary_Stack_Size = { type = "Integer", first = 1, default = 128 } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:00bc28d52b3b01d74e4ac1069d8f632d27c035a909317f0cd5bffc659f3a4fd5", +"sha512:cd36ad0bb130102bc251b0dee8e0da3bc5b8001c3d3cfb71381e17f0eecb6aa9d595e99659411d09a3e4788f7d56a0a1a58058117fbe2e734a2d0fbf8f6a40a2", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-tasking-rp2350-15.3.0.tar.gz" + diff --git a/index/li/light_tasking_stm32f0xx/light_tasking_stm32f0xx-15.3.0.toml b/index/li/light_tasking_stm32f0xx/light_tasking_stm32f0xx-15.3.0.toml new file mode 100644 index 00000000..68dc6347 --- /dev/null +++ b/index/li/light_tasking_stm32f0xx/light_tasking_stm32f0xx-15.3.0.toml @@ -0,0 +1,112 @@ +name = "light_tasking_stm32f0xx" +description = "light-tasking runtime for the STM32F0XX SoC" +version = "15.3.0" + +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/community-bb-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:f0028fb23cd6a7078a844c951ea2b76a5e71c033833abd45711e7ccffc72d052", +"sha512:8eaaa87c86058360c525a47e0baea97067bad0a81dee65487506e9596046ae592e5bd15e4d3b75a2af910d0b9a122a4b0f83e6be77cf4bce43435a68b110c397", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-tasking-stm32f0xx-15.3.0.tar.gz" + diff --git a/index/li/light_tasking_stm32g0xx/light_tasking_stm32g0xx-15.3.0.toml b/index/li/light_tasking_stm32g0xx/light_tasking_stm32g0xx-15.3.0.toml new file mode 100644 index 00000000..6aa15b6d --- /dev/null +++ b/index/li/light_tasking_stm32g0xx/light_tasking_stm32g0xx-15.3.0.toml @@ -0,0 +1,145 @@ +name = "light_tasking_stm32g0xx" +description = "light-tasking runtime for the STM32G0XX SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_tasking_stm32g0xx` in the dependency list: + ```toml + [[depends-on]] + light_tasking_stm32g0xx = "*" + ``` + - 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 STM32G0B1RE. 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 +STM32G031J4, add the following to your `alire.toml`: +```toml +[configuration.values] +light_tasking_stm32g0xx.MCU_Sub_Family = "G031" +light_tasking_stm32g0xx.MCU_Flash_Memory_Size = "4" +``` + +By default, the runtime configures the clock tree for a 64 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 64 MHz system clock from a 24 MHz HSE crystal oscillator: +```toml +[configuration.values] +# Configure a 24 MHz HSE crystal oscillator +light_tasking_stm32g0xx.HSE_Clock_Frequency = 24000000 +light_tasking_stm32g0xx.HSE_Bypass = false + +# Select PLLRCLK as the SYSCLK source +light_tasking_stm32g0xx.SYSCLK_Src = "PLLRCLK" + +# Configure the PLL VCO to run at 128 MHz from the 24 MHz HSE (fVCO = fHSE * (N/M)) +light_tasking_stm32g0xx.PLL_Src = "HSE" +light_tasking_stm32g0xx.PLL_N_Mul = 10 +light_tasking_stm32g0xx.PLL_M_Div = 2 + +# Configure the PLLRCLK to run at 64 MHz from the 128 MHz VCO. +light_tasking_stm32g0xx.PLL_R_Div = 2 + +# Configure the AHB an APB to also run at 64 MHz +light_tasking_stm32g0xx.AHB_Pre = "DIV1" +light_tasking_stm32g0xx.APB_Pre = "DIV1" +``` + +The runtime will generate a compile time error when an invalid PLL configuration +is set. + +By default the PLL's Q and P clocks are enabled. If you don't need them, then you +can disable them via the crate configuration: +```toml +[configuration.values] +light_tasking_stm32g0xx.PLL_Q_Enable = false +light_tasking_stm32g0xx.PLL_P_Enable = false +``` + +The runtime will enable the PLL only when either `PLL_Q_Enable` or `PLL_P_Enable` +is `true`, or when `SYSCLK_Src = "PLLRCLK"`. + +The interrupt stack sizes are also configurable: +```toml +[configuration.values] +light_tasking_stm32g0xx.Interrupt_Stack_Size = 1024 +light_tasking_stm32g0xx.Interrupt_Secondary_Stack_Size = 128 +``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime", "stm32g0"] +website = "https://github.com/damaki/community-bb-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 = ["G030", "G031", "G041", "G050", "G051", "G061", "G070", "G071", "G081", "G0B0", "G0B1", "G0C1"], default = "G0B1" } +MCU_Flash_Memory_Size = { type = "String", default = "B" } + +RAM_Parity_Check = { type = "Enum", values = ["Disabled", "Enabled"], default = "Disabled" } + +LSI_Enabled = { type = "Boolean", default = true } +LSE_Enabled = { type = "Boolean", default = false } +LSE_Bypass = { type = "Boolean", default = false } +HSE_Bypass = { type = "Boolean", default = false } +HSE_Clock_Frequency = { type = "Integer", first = 1, last = 48000000, default = 8000000 } +PLL_Src = { type = "Enum", values = ["HSE", "HSI16"], default = "HSI16" } +PLL_M_Div = { type = "Integer", first = 1, last = 8, default = 2 } +PLL_N_Mul = { type = "Integer", first = 8, last = 86, default = 16 } +PLL_R_Div = { type = "Integer", first = 2, last = 8, default = 2 } +PLL_Q_Div = { type = "Integer", first = 2, last = 8, default = 2 } +PLL_P_Div = { type = "Integer", first = 2, last = 32, default = 2 } +PLL_Q_Enable = { type = "Boolean", default = true } +PLL_P_Enable = { type = "Boolean", default = true } +HSI_Div = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16", "DIV32", "DIV64", "DIV128"], default = "DIV1" } +SYSCLK_Src = { type = "Enum", values = ["LSE", "LSI", "HSE", "PLLRCLK", "HSISYS"], default = "PLLRCLK" } +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 = "DIV1" } + +Interrupt_Stack_Size = { type = "Integer", first = 1, default = 1024 } +Interrupt_Secondary_Stack_Size = { type = "Integer", first = 1, default = 128 } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:ba2a1d471aefa93317863e5a8b666d433e61c3aedf5d9381fd3fd91cee1a1899", +"sha512:190a7d697fcd14a4c26ffd921413b79ef8a0dd9d141f0c765e6353cf68e7334427ed4f4aff331743b68c88f18406bd35ab06279180afc6e27ee21fdf72f28e04", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-tasking-stm32g0xx-15.3.0.tar.gz" + diff --git a/index/li/light_tasking_stm32g4xx/light_tasking_stm32g4xx-15.3.0.toml b/index/li/light_tasking_stm32g4xx/light_tasking_stm32g4xx-15.3.0.toml new file mode 100644 index 00000000..361910ab --- /dev/null +++ b/index/li/light_tasking_stm32g4xx/light_tasking_stm32g4xx-15.3.0.toml @@ -0,0 +1,144 @@ +name = "light_tasking_stm32g4xx" +description = "light-tasking runtime for the STM32G4XX SoC" +version = "15.3.0" + +long-description = """ +## Usage + +First edit your `alire.toml` file and add the following elements: + - Add `light_tasking_stm32g4xx` in the dependency list: + ```toml + [[depends-on]] + light_tasking_stm32g4xx = "*" + ``` + - 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 STM32G474RE. If you are using +a different MCU, then you will need to configure the runtime by adding the +following to your `alire.toml`. For example, to configure the runtime for the +STM32G431K6: +```toml +[configuration.values] +light_tasking_stm32g4xx.MCU_Sub_Family = "G431" +light_tasking_stm32g4xx.MCU_Flash_Memory_Size = "6" +``` + +By default, the runtime configures the clock tree for a 170 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 170 MHz system clock from a 24 MHz HSE crystal oscillator: +```toml +[configuration.values] +# Configure a 24 MHz HSE crystal oscillator +light_tasking_stm32g4xx.HSE_Clock_Frequency = 24000000 +light_tasking_stm32g4xx.HSE_Bypass = false + +# Select PLLRCLK as the SYSCLK source +light_tasking_stm32g4xx.SYSCLK_Src = "PLLRCLK" + +# Configure the PLL VCO to run at 340 MHz from the 24 MHz HSE (fVCO = fHSE * (N/M)) +light_tasking_stm32g4xx.PLL_Src = "HSE" +light_tasking_stm32g4xx.PLL_N_Mul = 85 +light_tasking_stm32g4xx.PLL_M_Div = 6 + +# Configure the PLLRCLK to run at 170 MHz from the 340 MHz VCO. +light_tasking_stm32g4xx.PLL_R_Div = 2 + +# Configure the AHB and APB to also run at 170 MHz +light_tasking_stm32g4xx.AHB_Pre = "DIV1" +light_tasking_stm32g4xx.APB1_Pre = "DIV1" +light_tasking_stm32g4xx.APB2_Pre = "DIV1" +``` + +The runtime will generate a compile time error when an invalid PLL configuration +is set. + +By default the PLL's Q and P clocks are enabled. If you don't need them, then you +can disable them via the crate configuration: +```toml +[configuration.values] +light_tasking_stm32g4xx.PLL_Q_Enable = false +light_tasking_stm32g4xx.PLL_P_Enable = false +``` + +The runtime will enable the PLL only when either `PLL_Q_Enable` or `PLL_P_Enable` +is `true`, or when `SYSCLK_Src = "PLLRCLK"`. + +The interrupt stack sizes are also configurable: +```toml +[configuration.values] +light_tasking_stm32g4xx.Interrupt_Stack_Size = 1024 +light_tasking_stm32g4xx.Interrupt_Secondary_Stack_Size = 128 +``` +""" + +authors = ["AdaCore", "Daniel King"] +maintainers = ["Daniel King "] +maintainers-logins = ["damaki"] +licenses = "GPL-3.0-or-later WITH GCC-exception-3.1" +tags = ["embedded", "runtime", "stm32g4"] +website = "https://github.com/damaki/community-bb-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 = ["G431", "G441", "G491", "G4A1", "G473", "G483", "G474", "G484"], default = "G474" } +MCU_Flash_Memory_Size = { type = "String", default = "E" } + +LSI_Enabled = { type = "Boolean", default = true } +LSE_Enabled = { type = "Boolean", default = false } +LSE_Bypass = { type = "Boolean", default = false } +HSE_Bypass = { type = "Boolean", default = false } +HSE_Clock_Frequency = { type = "Integer", first = 4000000, last = 48000000, default = 24000000 } +PLL_Src = { type = "Enum", values = ["HSE", "HSI16"], default = "HSI16" } +PLL_M_Div = { type = "Integer", first = 1, last = 16, default = 4 } +PLL_N_Mul = { type = "Integer", first = 8, last = 127, default = 85 } +PLL_R_Div = { type = "Enum", values = ["DIV2", "DIV4", "DIV6", "DIV8"], default = "DIV2" } +PLL_Q_Div = { type = "Enum", values = ["DIV2", "DIV4", "DIV6", "DIV8"], default = "DIV2" } +PLL_P_Div = { type = "Integer", first = 2, last = 31, default = 2 } +PLL_Q_Enable = { type = "Boolean", default = true } +PLL_P_Enable = { type = "Boolean", default = true } +SYSCLK_Src = { type = "Enum", values = ["HSI16", "HSE", "PLLRCLK"], default = "PLLRCLK" } +AHB_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16", "DIV64", "DIV128", "DIV256", "DIV512"], default = "DIV1" } +APB1_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16"], default = "DIV1" } +APB2_Pre = { type = "Enum", values = ["DIV1", "DIV2", "DIV4", "DIV8", "DIV16"], default = "DIV1" } + +Interrupt_Stack_Size = { type = "Integer", first = 1, default = 1024 } +Interrupt_Secondary_Stack_Size = { type = "Integer", first = 1, default = 128 } + +[[depends-on]] +gnat_arm_elf = "^15" + +[origin] +hashes = [ +"sha256:3e6a43ffe043712ab6302dbf5ea8dbab96c2d4f65d00704ea8e5c9b37f2903a1", +"sha512:ff0e363a96fd9f56f884c9438efb377b38abf518bf44da6faa9cd42eb0ac3df32be18730cccfc2d5bf40c4bdc1f375079b6bcb3211e79b7b5b9f957a9f3cf87a", +] +url = "https://github.com/damaki/community-bb-runtimes/releases/download/v15.3.0/light-tasking-stm32g4xx-15.3.0.tar.gz" +