Project Configuration#

Aliro example projects are assembled from Simplicity SDK Component (SLC) components rather than written as monolithic applications. Which components you install determines which transport the reader uses, whether a command-line interface (CLI) is present, how Bluetooth Low Energy (BLE) is shared with Matter, and how much power the device draws. This page describes the components that matter most in the stock examples, the BLE side-channel mechanism used by AliroMatterLock, and what it takes to move an example toward low-power operation.

Overview#

Components are managed from the Software Components tab of the Project Configurator in Simplicity Studio 6. Aliro components appear under the aliro package and Matter components under the matter package. Most components also contribute a configuration header that you edit through the Configuration Wizard or directly in the generated config/ directory.

The following best practices make component changes predictable:

Clean and rebuild after adding or removing components so that the generated catalog symbols, such as SL_CATALOG_ALIRO_SHELL_PRESENT and SL_CATALOG_ALIRO_TEST_TASK_PRESENT match the new configuration. Application code branches on these symbols.
Let Simplicity Studio resolve component conflicts rather than forcing a selection. Several power-related components in Enabling Low-Power Mode deliberately conflict with development components; accepting the proposed replacements is the intended path.

Configuration headers you are most likely to touch:


Header	Owning component	Controls
`aliro_reader_app_config.h`, `aliro_reader_transport.h`	`aliro_reader_app`	Reader application and transport selection
`aliro_reader_loop_config.h`	`aliro_reader_task`	Reader idle poll and inter-transaction delays
`aliro_nfc_config.h`	`aliro_nfc_driver_api`	Near Field Communication (NFC) task sizing and driver options
`aliro_nvm_config.h`	`aliro_actuator`	Credential and issuer key array capacities
`aliro_log_config.h`	`aliro_actuator`	Aliro log enable and level threshold
`platform_config.h`	`aliro_platform`	Board General-Purpose Input/Output (GPIO) and bus assignments
`sl_matter_icd_config.h`	`matter_icd_core`	Intermittently Connected Device (ICD) idle and active mode timing

Notable SLC Components in the Example Project#

The Aliro package components installed by the stock projects:


Component	Purpose	Used by	Optional
`aliro_actuator`	Core Aliro access protocol, cryptography, and transport logic	Both	No
`aliro_reader_app`	Reader application and transport configuration headers	Both	No
`aliro_reader_task`	Reader configuration model, config store, and shell command handlers	Both	No
`aliro_reader_transport_nfc` / `aliro_reader_transport_ble`	Selects the reader transport; mutually exclusive	Both (one of)	No — pick one
`aliro_nfc_driver_api`	Vendor-neutral `INfcFrontend` interface	NFC builds	No
`aliro_nfc_driver_st25r`	Reference ST25R frontend driver	NFC builds	Replaceable — see NFC Hardware and Porting
`st25r200` / `st25r300`	ST RF Abstraction Layer (RFAL) library for the chosen integrated circuit (IC)	NFC builds	Replaceable
`aliro_platform`	EFR32 GPIO and hardware abstraction	Both	No
`aliro_access_manager`	Access credential store and tap-time authorizer	Both	No
`aliro_credential_issuer_manager`	Issuer key store used by the step-up phase	Both	Yes, if the product does not support step-up
`tlv` / `tinycbor`	Basic Encoding Rules Tag-Length-Value (BER-TLV) and Concise Binary Object Representation (CBOR) encoding	Both	No
`aliro_shell_core`	Shell engine and Aliro command handlers	Both	Yes
`aliro_shell`	Standalone Universal Asynchronous Receiver-Transmitter (UART) CLI task and streamer	Aliro Minimal Reader	Yes
`aliro_test_task`	Certification test scenarios (`aliro test-case`)	Both	Yes
`aliro_matter_integration`	Matter BLE side-channel forwarder	AliroMatterLock	Required for BLE reader builds; inactive on NFC builds

Supporting Simplicity SDK and Matter components that the examples depend on:


Component	Role
`nvm3_default`	Non-volatile memory (NVM) backend for the Aliro storage layer (Aliro Minimal Reader; AliroMatterLock uses the Matter NVM path)
`uartdrv_eusart` (instance `vcom`)	Board debug UART used by the shell and logs
`spidrv_usart` (instance `exp`)	Serial Peripheral Interface (SPI) bus to the ST25R expansion board (NFC builds)
`bluetooth_feature_l2cap`	Logical Link Control and Adaptation Protocol channel used by the Aliro BLE transport
`matter_ble_side_channel`	Matter-side hook that lets a non-Matter BLE client share the stack
`matter_door_lock`, `matter_icd_management`	Door Lock and ICD Management clusters on AliroMatterLock
`ot_stack_ftd`	OpenThread Full Thread Device (FTD) stack in the stock AliroMatterLock projects
`matter_shell`, `matter_uart`, `matter_log_uart`, `matter_default_lcd_config`	Development conveniences on AliroMatterLock; removed by the low-power component

For guidance on which application source files you own and where product logic belongs, see Customizing the Application.

BLE Side Channel#

On AliroMatterLock, both Matter and the Aliro reader need the same Bluetooth radio and stack for different purposes. Matter uses BLE for commissioning. An Aliro BLE reader needs its own advertising, GATT attribute traffic, and an L2CAP credit-based channel to the credential device. The Matter extension resolves the shared-radio requirement with a BLE side channel: Matter remains the owner of the Bluetooth stack, and events it does not reserve for itself are offered to an injected side-channel implementation.

The mechanism is selected by installing the matter_ble_side_channel component from the Matter package. The Aliro side of it lives in aliro_matter_integration, which supplies the side-channel implementation and injects it into the Matter BLE manager during application startup. Both stock AliroMatterLock projects install the pair, but only BLE reader builds actually inject the channel — the call in app_init() is guarded on the BLE transport, so an NFC build carries the components without activating them.

Event routing is narrow by design. The Aliro side channel claims only the events the reader needs — connection opened and closed, the L2CAP channel open request, credit, and data events, and GATT server attribute writes — and forwards them to the Aliro reader BLE driver. Everything else stays with Matter. Aliro advertising and its GATT database remain owned by the Aliro reader driver rather than being configured through the side channel, so the side channel is a forwarder, not a second BLE stack.

Note: Sharing the radio requires a second advertising set, so the stock projects raise SL_BT_CONFIG_USER_ADVERTISERS to 2 whenever matter_ble_side_channel is present. The bluetooth_feature_l2cap component is also required.

The standalone Aliro Minimal Reader has no Matter stack and therefore no side channel. The reader owns the Bluetooth stack outright, and neither matter_ble_side_channel nor aliro_matter_integration applies.

Enabling Low-Power Mode#

Neither example ships configured for low power. Both keep a debug UART active, run a shell, and, on AliroMatterLock, join the Thread network as a Full Thread Device (FTD) that must stay awake to route. Moving to low power is mostly a matter of component selection, and the work differs by application.

AliroMatterLock#

Three changes move the lock toward a battery-friendly configuration:

Switch the Thread stack to a Minimal Thread Device. Replace ot_stack_ftd with ot_stack_mtd. A sleepy device cannot act as a Thread router, so this change is a prerequisite rather than an optimization.
Install ICD server support. Add matter_icd_core (ICD Server Configuration). It requires the ICD Management cluster — already present in the stock projects — and ot_stack_mtd, and it conflicts with ot_stack_ftd, so installing it drives the MTD switch in step 1. It contributes sl_matter_icd_config.h, where the idle and active mode timing lives. The stock projects already carry the related values in their configuration (SL_IDLE_MODE_DURATION_S, SL_ACTIVE_MODE_DURATION_MS, SL_ACTIVE_MODE_THRESHOLD, SL_TRANSPORT_IDLE_INTERVAL, SL_TRANSPORT_ACTIVE_INTERVAL); they apply once ICD is enabled.
Install the low-power component. Add matter_platform_low_power (Low Power Mode). This component works by conflicting with the development components that keep peripherals awake, so installing it removes Matter Shell, the OpenThread CLI, the display and QR code components, Matter UART, and logging to UART.

Plan for what installing matter_platform_low_power takes away. Removing Matter Shell also removes the host for the Aliro CLI commands that aliro_shell_core bridges into it, and removing the display removes the commissioning QR code and status screens. Provisioning and commissioning therefore need a different path — a manufacturing-time NVM record, or commissioning from a QR code obtained another way. Because it makes debugging considerably harder, treat installing matter_platform_low_power as the last step before power measurement rather than a default.

For ICD behavior, check-in protocol, and the trade-off between idle duration and responsiveness, see the Silicon Labs Matter ICD documentation.

Aliro Minimal Reader#

The standalone reader has no Thread stack or ICD concept, so the reductions are simpler:

Remove the CLI. Uninstall aliro_shell and the aliro_shell_core engine it pulls in, plus aliro_test_task if you no longer need the certification commands. This removes the shell task, its UART streamer, and the interactive provisioning path — so provision the reader configuration and credentials into NVM by other means first.
Disable Aliro logging. Set ALIRO_LOG_ENABLE to 0 in aliro_log_config.h, or raise APP_LOG_LEVEL_FILTER_THRESHOLD to ALIRO_LOG_LEVEL_ERROR if you want to keep errors. Aliro logs are emitted on the same Virtual COM Port (VCOM) UART as the shell, so leaving them on keeps that peripheral busy after the shell is gone.

With both removed, nothing in the Aliro application drives the debug UART, so uartdrv_eusart can normally be dropped as well — confirm first that no other component in your project uses the VCOM instance.