laze-project.yml

contexts:
  # base context that all other contexts inherit from
  - name: default
    env:
      bindir: "${build-dir}/bin/${builder}/${app}"

  # base context for all RIOT-rs applications
  - name: riot-rs
    parent: default
    selects:
      - executor-default
      - ?defmt
    env:
      RUSTFLAGS:
        - "-Clink-arg=--nmagic"
        - "-Clink-arg=${LINK_ARG_PREFIX}--no-eh-frame-hdr"
        - --cfg builder=\"${builder}\"
        - --cfg context=\"${builder}\"
        - --cfg context=\"riot-rs\"
      FEATURES:
        - riot-rs-boards/${BOARD}
      SCRIPTS: ${relroot}/scripts
      # laze doesn't know the concept of "export" as make does, so each variable
      # that needs to be passed via environment needs to be listed in that rule
      # or task's command list.
      # "CARGO_ENV" is used for that.
      CARGO_ENV:
        - >-
          OPENOCD_ARGS="${OPENOCD_ARGS}"
          SCRIPTS=${SCRIPTS}
          CONFIG_BOARD=${builder}
          CARGO_BUILD_TARGET=${RUSTC_TARGET}
          ${CARGO_TARGET_PREFIX}_RUNNER=${CARGO_RUNNER}
          ${CARGO_TARGET_PREFIX}_RUSTFLAGS="${RUSTFLAGS}"
          CARGO_TARGET_DIR=${relroot}/${build-dir}/bin/${builder}/${app}/cargo
      BOARD: ${builder}
      PROFILE: release
      riot_binary: ${app}
      QEMU_SYSTEM_ARM: >-
        qemu-system-arm
        -machine ${QEMU_MACHINE}
        -nographic
        -serial mon:stdio
        -semihosting-config enable=on,target=native
        -kernel
      PROBE_RS_PROTOCOL: swd

    var_options:
      # this turns ${FEATURES} from a list to "--features=feature1,feature2"
      FEATURES:
        start: --features=
        joiner: ","
      LOG:
        joiner: ","

      # this prefixes `--protocol=` to `PROBE_RS_PROTOCOL`
      PROBE_RS_PROTOCOL:
        start: --protocol=

    rules:
      - name: LINK
        description: CARGO ${out}
        pool: console
        always: true
        cmd: >-
          cd ${relpath} && ${CARGO_ENV} cargo ${CARGO_ARGS} build --${PROFILE} ${FEATURES}
          && cp ${relroot}/${build-dir}/bin/${builder}/${app}/cargo/${RUSTC_TARGET}/${PROFILE}/${riot_binary} ${relroot}/${out}

      - name: GIT_DOWNLOAD
        cmd: "D=$$(dirname ${out}); rm -rf $$D && git clone ${url} $$D -n && git -C $$D reset --hard ${commit} && touch ${out}"

    tasks:
      exec:
        build: false
        cmd:
          - ${CARGO_ENV}

      cargo:
        cmd:
          - cd ${relpath} && ${CARGO_ENV} cargo ${CARGO_ARGS}
        build: false

      run:
        build: false
        cmd:
          - cd ${appdir} && ${CARGO_ENV} cargo ${CARGO_ARGS} run --${PROFILE} ${FEATURES}

      cargo-test:
        cmd:
          - cd ${relpath} && ${CARGO_ENV} cargo test --${PROFILE} --features=riot-rs-boards/${builder},riot-rs-rt/debug-console --manifest-path ${app}/Cargo.toml
        build: false

      debug:
        cmd:
          - cd ${appdir} && ${CARGO_ENV} cargo ${CARGO_ARGS} run --${PROFILE} ${FEATURES}
        build: false
        ignore_ctrl_c: true

      gdb:
        cmd:
          - arm-none-eabi-gdb -ex "target extended-remote localhost:1337" ${out}
        build: false
        ignore_ctrl_c: true

      bloat:
        cmd:
          - cd ${appdir} && ${CARGO_ENV} cargo ${CARGO_ARGS} bloat --${PROFILE} ${FEATURES}
        build: false

      tree:
        cmd:
          - cd ${appdir} && ${CARGO_ENV} cargo ${CARGO_ARGS} tree ${FEATURES}
        build: false

      flash:
        cmd:
          - >-
            _flash () { openocd
            ${OPENOCD_ADAPTER_INIT}
            ${OPENOCD_ARGS}
            -c 'init'
            -c 'targets'
            -c 'reset halt'
            -c "flash write_image erase \"${1}\" 0 elf"
            -c "verify_image \"${1}\" 0 elf"
            -c 'reset run'
            -c 'shutdown' ; } ;
            _flash ${out}

      flash-riotboot:
        required_vars:
          - FLASH_OFFSET
        cmd:
          - riotboot-genhdr generate ${out} $$(date +%s) $(${FLASH_OFFSET} + ${FLASH_SLOT_OFFSET}) ${FLASH_SLOT_OFFSET} - > ${out}.hdr.bin
          - ${OBJCOPY} -Obinary ${out} ${out}.bin
          - cat ${out}.hdr.bin ${out}.bin > ${out}.riotboot.bin
          - _flash () { openocd
            ${OPENOCD_ARGS}
            -c 'init'
            -c 'targets'
            -c 'reset halt'
            -c "flash write_image erase \"${1}.riotboot.bin\" ${FLASH_OFFSET} bin"
            -c "verify_image \"${1}.riotboot.bin\" ${FLASH_OFFSET} bin"
            -c 'reset run'
            -c 'shutdown' ; } ;
            _flash ${out}

      reset:
        build: false
        cmd:
          - >-
            openocd
            ${OPENOCD_ARGS}
            -c 'init'
            -c 'targets'
            -c 'reset'
            -c 'shutdown'

      size:
        cmd:
          - llvm-size ${out}

      objdump:
        cmd:
          - rust-objdump -S ${out}

  - name: nrf
    help: Nordic MCU support (based on embassy-nrf)
    parent: riot-rs
    selects:
      - ?probe-rs
    env:
      RUSTFLAGS:
        - --cfg context=\"nrf\"
    tasks:
      flash-erase-all:
        help: Erases the whole chip including user data. Unlocks it if locked.
        build: false
        cmd:
          - probe-rs erase --chip ${PROBE_RS_CHIP} --allow-erase-all


  - name: nrf51
    parent: nrf
    selects:
      - thumbv6m-none-eabi

  - name: microbit-base
    # this is a context, not a builder, to be used as parent by  "microbit" and
    # "microbit-qemu"
    parent: nrf51
    selects:
      - "microbit disabled due to missing nrf51 support in embassy"
    env:
      # override "${builder}"
      BOARD: microbit
      OPENOCD_ARGS:
        - "-f board/nordic_nrf52_dk.cfg"

  - name: nrf52
    parent: nrf
    selects:
      - thumbv7em-none-eabi  # actually eabihf, but riot-rs doesn't support hard float yet
    env:
      CARGO_RUNNER:
        - ${SCRIPTS}/debug-openocd.sh
      OPENOCD_ARGS:
        - "-f board/nordic_nrf52_dk.cfg"
      PROBE_RS_CHIP: nrf52832_xxAA
      RUSTFLAGS:
        - --cfg context=\"nrf52\"

  - name: nrf5340
    parent: nrf
    selects:
      - thumbv8m.main-none-eabi  # actually eabihf, but riot-rs doesn't support hard float yet
    env:
      PROBE_RS_CHIP: nrf5340_xxAA
      RUSTFLAGS:
        - --cfg context=\"nrf5340\"

  - name: nrf52832
    parent: nrf52
    env:
      RUSTFLAGS:
        - --cfg context=\"nrf52832\"

  - name: nrf52840
    parent: nrf52
    env:
      RUSTFLAGS:
        - --cfg context=\"nrf52840\"
      PROBE_RS_CHIP: nrf52840_xxAA

    tasks:
      flash-rs:
        cmd:
          - probe-rs download ${out} --chip ${PROBE_RS_CHIP}
          - probe-rs reset --chip ${PROBE_RS_CHIP}

      debug-rs:
        cmd:
          - probe-rs gdb --chip ${PROBE_RS_CHIP}

  - name: rp
    help: Raspberry Pi pico MCU support (based on embassy-rp)
    parent: riot-rs
    selects:
      - rp-link-arg
      - thumbv6m-none-eabi
    env:
      RUSTFLAGS:
        - --cfg context=\"rp\"

  - name: rp2040
    parent: rp
    selects:
      - ?probe-rs
    env:
      RUSTFLAGS:
        - --cfg context=\"rp2040\"
      PROBE_RS_CHIP: RP2040
      CARGO_RUNNER:
        - ${SCRIPTS}/debug-openocd.sh
      OPENOCD_ARGS:
        - "-f interface/cmsis-dap.cfg -f target/rp2040.cfg"
    tasks:
      debug-rs:
        cmd:
          - probe-rs debug --chip ${PROBE_RS_CHIP} --exe ${out}

  - name: esp
    parent: riot-rs
    selects:
      - ?debug-console
    env:
      RUSTFLAGS:
        - --cfg context=\"esp\"
        # linkall first
        - -Clink-arg=-Tlinkall.x
        - -Clink-arg=-Tlinkme-esp-fixup.x
        - -Clink-arg=-Tlinkme.x
        # this might be needed for backtraces
        # - -C force-frame-pointers
      CARGO_ARGS:
        - -Zbuild-std=core
      CARGO_RUNNER: '"espflash flash --monitor ${ESPFLASH_LOG_FORMAT}"'

  - name: esp32c3
    parent: esp
    env:
      RUSTFLAGS:
        - --cfg context=\"esp32c3\"
      RUSTC_TARGET: riscv32imc-unknown-none-elf
      CARGO_TARGET_PREFIX: CARGO_TARGET_RISCV32IMC_UNKNOWN_NONE_ELF

  - name: esp32c6
    parent: esp
    env:
      RUSTFLAGS:
        - --cfg context=\"esp32c6\"
      RUSTC_TARGET: riscv32imac-unknown-none-elf
      CARGO_TARGET_PREFIX: CARGO_TARGET_RISCV32IMAC_UNKNOWN_NONE_ELF

  - name: stm32
    help: STM32 support (based on embassy-stm32)
    parent: riot-rs
    selects:
      - ?probe-rs
    env:
      OPENOCD_ARGS: foo
      RUSTFLAGS:
        - --cfg context=\"stm32\"

  - name: stm32f401retx
    parent: stm32
    selects:
      - thumbv7em-none-eabi  # actually eabihf, but riot-rs doesn't support hard float yet
    env:
      PROBE_RS_CHIP: STM32F401RETx
      PROBE_RS_PROTOCOL: swd
      RUSTFLAGS:
        - --cfg context=\"stm32f401retx\"
      CARGO_ENV:
        # This ISR is unused on a naked board. Configured here for testing.
        - CONFIG_SWI=USART2

  - name: stm32wb55rgvx
    parent: stm32
    selects:
      - thumbv7em-none-eabi  # actually eabihf, but riot-rs doesn't support hard float yet
    env:
      PROBE_RS_CHIP: STM32WB55RGVx
      PROBE_RS_PROTOCOL: swd
      RUSTFLAGS:
        - --cfg context=\"stm32wb55rgvx\"
      CARGO_ENV:
        # This ISR is unused on a naked board. Configured here for testing.
        - CONFIG_SWI=LPUART1

  - name: stm32h755zitx
    parent: stm32
    selects:
      - thumbv7em-none-eabi  # actually eabihf, but riot-rs doesn't support hard float yet
    env:
      PROBE_RS_CHIP: STM32H755ZITx
      PROBE_RS_PROTOCOL: swd
      RUSTFLAGS:
        - --cfg context=\"stm32h755zitx\"
        - --cfg capability=\"hw/stm32-dual-core\"
      CARGO_ENV:
        # This ISR is unused on a naked board. Configured here for testing.
        - CONFIG_SWI=UART5

modules:
  - name: cortex-m
    env:
      global:
        OBJCOPY: arm-none-eabi-objcopy
        RUSTFLAGS:
          - -Clink-arg=-Tlinkme.x
          - -Clink-arg=-Tlink.x
          - -Clink-arg=-Tdevice.x
          - -Clink-arg=-Tisr_stack.x
          - --cfg context=\"cortex-m\"

  - name: thumbv6m-none-eabi
    depends:
      - cortex-m
    env:
      global:
        RUSTC_TARGET: thumbv6m-none-eabi
        CARGO_TARGET_PREFIX: CARGO_TARGET_THUMBV6M_NONE_EABI
        RUSTFLAGS:
          - --cfg armv6m

  - name: thumbv7em-none-eabi
    depends:
      - cortex-m
    env:
      global:
        RUSTC_TARGET: thumbv7em-none-eabi
        CARGO_TARGET_PREFIX: CARGO_TARGET_THUMBV7EM_NONE_EABI
        RUSTFLAGS:
          - --cfg armv7m

  - name: thumbv7m-none-eabi
    depends:
      - cortex-m
    env:
      global:
        RUSTC_TARGET: thumbv7m-none-eabi
        CARGO_TARGET_PREFIX: CARGO_TARGET_THUMBV7M_NONE_EABI
        RUSTFLAGS:
          - --cfg armv7m

  - name: thumbv8m.main-none-eabi
    depends:
      - cortex-m
    env:
      global:
        RUSTC_TARGET: thumbv8m.main-none-eabi
        CARGO_TARGET_PREFIX: CARGO_TARGET_THUMBV8M_MAIN_NONE_EABI
        RUSTFLAGS:
          - --cfg armv8m

  - name: thumbv7em-none-eabihf
    depends:
      - cortex-m
    env:
      global:
        RUSTC_TARGET: thumbv7em-none-eabihf
        CARGO_ENV_TARGET: CARGO_TARGET_THUMBV7EM_NONE_EABIHF
        RUSTFLAGS:
          - --cfg armv7m

  - name: rp-link-arg
    help: helper module that ensures link-rp.x is added behind cortex-m ld scripts
    env:
      global:
        RUSTFLAGS:
          - "-Clink-arg=-Tlink-rp.x"

  - name: release
    selects:
      - ?lto

  - name: debug-console
    context: riot-rs
    env:
      global:
        FEATURES:
          - riot-rs/debug-console

  - name: defmt
    help: Enable use of defmt
    context: riot-rs
    env:
      global:
        FEATURES:
          - riot-rs/defmt
        RUSTFLAGS:
          - -Clink-arg=-Tdefmt.x
        ESPFLASH_LOG_FORMAT: '--log-format defmt'
        CARGO_ENV:
          # For some reason, `sccache` makes the build not realize changes to
          # `DEFMT_LOG`. Painful as it is, hard-disable `sccache` here.
          - RUSTC_WRAPPER=""
          - DEFMT_LOG=info,${LOG}

  - name: silent-panic
    context: riot-rs
    env:
      global:
        FEATURES:
          - riot-rs/silent-panic

  - name: lto
    context: riot-rs
    env:
      global:
        RUSTFLAGS:
          - -Cembed-bitcode=yes
          - -Clto=fat
          - -Ccodegen-units=1

  - name: inline225
    context: riot-rs
    env:
      global:
        RUSTFLAGS:
          - -Cllvm-args=-inline-threshold -Cllvm-args=225

  - name: build_std
    context: riot-rs
    env:
      global:
        CARGO_ARGS:
          - -Zbuild-std

  - name: no_overflow_checks
    context: riot-rs
    env:
      global:
        RUSTFLAGS:
          - -Coverflow-checks=off

  - name: opt_speed
    context: riot-rs
    env:
      global:
        RUSTFLAGS:
          - -Copt-level=3
        # note: this overrides CFLAGS_OPT in riot-rs context
        CFLAGS_OPT: -O3

  - name: opt_size
    context: riot-rs
    env:
      global:
        RUSTFLAGS:
          - -Copt-level=z
        # note: this overrides CFLAGS_OPT in riot-rs context
        CFLAGS_OPT: -Oz

  - name: thread_info
    # enable thread names & stack info
    context: riot-rs
    env:
      global:
        FEATURES:
          - riot-rs/thread_info

  - name: cross-language-lto
    # use clang/lld to link, enables cross-language LTO.
    # This requires rustc's llvm and clang's llvm version to match.
    context: riot-rs
    depends:
      - lto
    env:
      global:
        RUSTFLAGS:
          - "-Clinker-plugin-lto"
          - "-Clinker=clang"
          - "-Clink-arg=-fuse-ld=lld"
          - "-Clink-arg=--target=${RUSTC_TARGET}"
          - "-Clink-arg=-v"
        LINK_ARG_PREFIX: -Wl,

  - name: riotboot
    context: nrf52840
    env:
      global:
        FLASH_OFFSET: "0x2000"
        FLASH_SLOT_OFFSET: "0x400"
        CARGO_ENV:
          - NRF52840_FLASH_OFFSET=${FLASH_OFFSET}
          - NRF52840_FLASH_SLOT_OFFSET=${FLASH_SLOT_OFFSET}
          - NRF52840_FLASH_SLOT=0

  - name: probe-rs
    help: use probe-rs as runner
    selects:
      - ?debug-console
    env:
      global:
        CARGO_RUNNER: "'probe-rs run ${PROBE_RS_PROTOCOL} --chip ${PROBE_RS_CHIP}'"

  - name: probe-rs-run
    help: "deprecated alias for `probe-rs`"
    selects:
      - probe-rs

  - name: network
    selects:
      - network_device

  - name: sw/threading
    conflicts:
      - executor-single-thread

  - name: wifi-cyw43
    context:
      - rpi-pico-w
    provides_unique:
      - network_device
    env:
      global:
        FEATURES:
          - riot-rs/wifi-cyw43

  - name: usb-ethernet
    provides_unique:
      - network_device
    selects:
      - hw/usb-device-port
    env:
      global:
        FEATURES:
          - riot-rs/usb-ethernet

  - name: hw/usb-device-port
    help: provided if a device has a USB device port wired up
    context:
      - nrf5340dk
      - nrf52840dk
      - rpi-pico
      - rpi-pico-w
      - particle-xenon
      - st-nucleo-h755zi-q
      - st-nucleo-wb55
    env:
      global:
        RUSTFLAGS:
          - --cfg capability=\"hw/usb-device-port\"

  - name: hwrng
    help: The board's peripherals are suitable for passing into riot_rs_random::construct_rng.
    context:
      # these are precisely those for which the hwrng feature of
      # riot-rs-embassy builds, which would fail if the big if(context=...)
      # doesn't have an entry in the cfg(feature = "hwrng") part of init_task
      - nrf51
      - nrf52
      - rp
      - stm32h755zitx
      - stm32wb55rgvx
    env:
      global:
        FEATURES:
          - riot-rs/hwrng

  - name: random
    help: A system-wide RNG is available (through the riot_rs::random module).

      As the riot_rs::random module will refuse operation at run time if not
      properly initialized, this depends on sources of original entropy.
    depends:
      # could later alternatively depend on mutable config storage
      - hwrng
    env:
      global:
        FEATURES:
          - riot-rs/random

  - name: sw/benchmark
    help: provided if a target supports `benchmark()`
    # Currently there's only one implementation based on Systick, so Cortex-M only.
    context:
      - nrf
      - rp
      - stm32

  - name: wifi-esp
    context:
      - esp
    provides_unique:
      - network_device
    env:
      global:
        RUSTFLAGS:
          - -Clink-arg=-Trom_functions.x
        FEATURES:
          - riot-rs/wifi-esp

  - name: executor-thread
    help: use embassy executor within riot-rs-threads thread
    provides_unique:
      - executor
    env:
      global:
        FEATURES:
          - riot-rs/executor-thread

  - name: executor-single-thread
    help: use Embassy executor within single "thread mode" thread
    context:
      - esp
    provides_unique:
      - executor
    env:
      global:
        FEATURES:
          - riot-rs/executor-single-thread

  - name: executor-interrupt
    help: use the Embassy interrupt executor
    context:
      - nrf
      - rp
    provides_unique:
      - executor
    env:
      global:
        FEATURES:
          - riot-rs/executor-interrupt

  - name: executor-default
    help: executor preference
    selects:
      # This is order dependent.
      # Unless otherwise selected (by application, context, on cli, or by other
      # dependencies), the interrupt executor is preferred.
      - ?executor-interrupt
      - ?executor-single-thread
      - ?executor-thread

builders:
  # host builder (for housekeeping tasks)
  - name: host
    rules:
      # currently, laze requires a LINK rule for every context/builder
      # that gets an application configured.
      # so, provide a dummy one for `host`
      - name: LINK
        description: "HOST LINK (no-op)"
        cmd: "true"

    tasks:
      install-toolchain:
        build: false
        cmd:
          - rustup target add thumbv6m-none-eabi
          - rustup target add thumbv7m-none-eabi
          - rustup target add thumbv7em-none-eabi
          - rustup target add thumbv7em-none-eabihf
          - rustup target add thumbv8m.main-none-eabi
          - rustup target add riscv32imc-unknown-none-elf
          - rustup target add riscv32imac-unknown-none-elf
          - rustup component add rust-src

      install-c2rust:
        build: false
        cmd:
          - echo "Installing c2rust..."
          - 'echo "WARNING: This uses *a lot* of memory!"'
          - cargo install c2rust

  - name: nrf52dk
    parent: nrf52832

  - name: nrf52840dk
    parent: nrf52840

  - name: dwm1001
    parent: nrf52832

  - name: nrf52840-mdk
    parent: nrf52840
    env:
      OPENOCD_ADAPTER_INIT:
        - " -c 'source [find interface/cmsis-dap.cfg]'"

  - name: microbit
    parent: microbit-base
    env:
      CARGO_RUNNER:
        - ${relroot}/${SCRIPTS}/debug-openocd.sh
      OPENOCD_ARGS:
        - "-f board/nordic_nrf52_dk.cfg"

  - name: microbit-qemu
    parent: microbit-base
    env:
      CARGO_RUNNER:
        - '"qemu-system-arm -machine microbit -nographic -semihosting-config enable=on,target=native -s -S -kernel"'
      QEMU_MACHINE: microbit
    tasks:
      qemu:
        build: true
        cmd:
          - ${QEMU_SYSTEM_ARM} ${out}

    disables:
      - periph_rtt

  - name: microbit-v2
    parent: nrf52840

  - name: particle-xenon
    parent: nrf52840

  - name: rpi-pico
    parent: rp2040
    env:
      BOARD: rpi-pico

  - name: rpi-pico-w
    parent: rpi-pico
    env:
      BOARD: rpi-pico-w

  - name: ai-c3
    parent: esp32c3

  - name: espressif-esp32-c6-devkitc-1
    parent: esp32c6

  - name: nrf5340dk
    parent: nrf5340

  - name: st-nucleo-f401re
    parent: stm32f401retx

  - name: st-nucleo-h755zi-q
    parent: stm32h755zitx

  - name: st-nucleo-wb55
    parent: stm32wb55rgvx

apps:
  # define a dummy host application so the host tasks work
  - name: host
    context: host

subdirs:
  - examples
  - src
  - tests