Wireless & BLE Controller¶

Radio start-up and the IPRO BLE controller interfaces for bring-up, HCI transport, low power and NVDS.

hal_wireless.h¶

#include "hal_wireless.h" (Source)

Radio settings for BLE and IEEE 802.15.4: MAC address, default TX power, TX power offsets and the crystal capcode temperature table.

The values live in one RAM structure inside the HAL (all zero at start-up) and are returned unchanged by the matching _get function. Of these settings, the BLE controller reads the default TX power, at RF initialization and whenever the host gives no TX power preference, so call hal_wireless_default_tx_power_set() before initializing the BLE controller. The functions do no locking; set the values during initialization.

hal_wireless_mac_addr_set¶

int hal_wireless_mac_addr_set(uint8_t mac[8]);

Store the radio MAC address.

Returns: 0 (always).

hal_wireless_mac_addr_get¶

int hal_wireless_mac_addr_get(uint8_t mac[8]);

Read the stored radio MAC address.

Returns: 0 (always).

hal_wireless_power_offset_set¶

int hal_wireless_power_offset_set(int8_t poweroffset_zigbee[16], int8_t poweroffset_ble[4]);

Store the TX power offset tables.

Returns: 0 (always).

hal_wireless_power_offset_get¶

int hal_wireless_power_offset_get(int8_t poweroffset_zigbee[16], int8_t poweroffset_ble[4]);

Read the stored TX power offset tables.

Returns: 0 (always).

hal_wireless_capcode_offset_table_set¶

int hal_wireless_capcode_offset_table_set(int8_t temp[], int8_t offset[], uint8_t size);

Store the crystal capcode offset table indexed by temperature.

Entry i applies from temperature temp[i] up to, but not including, temp[i + 1]; see hal_wireless_capcode_offset_get().

hal_wireless_capcode_offset_table_get¶

int hal_wireless_capcode_offset_table_get(int8_t temp[], int8_t offset[], uint8_t *size);

Read the stored capcode offset table.

Returns: 0 (always).

hal_wireless_capcode_offset_get¶

int8_t hal_wireless_capcode_offset_get(int8_t temp);

Look up the capcode offset for a temperature.

With T the stored thresholds, returns the stored offset i - 1 for the first i (from 1) with temp below T[i], otherwise the last stored offset. A temperature below the second threshold therefore gets the first offset.

Returns: Capcode offset from the stored table; the first stored offset when the table has fewer than two entries (0 if no table was ever stored).

hal_wireless_default_tx_power_set¶

void hal_wireless_default_tx_power_set(int8_t power);

Set the default (maximum) radio TX power.

The BLE controller reads this value at RF initialization and as the TX power of activities for which the host gives no preference. The IPRO7 BLE controller supports -9 to +10 dBm; the value is not range-checked here.

hal_wireless_default_tx_power_get¶

int8_t hal_wireless_default_tx_power_get(void);

Read the default radio TX power.

Returns: TX power in dBm (0 if never set).

hal_wireless_power_tcal_en_set¶

void hal_wireless_power_tcal_en_set(uint8_t en);

Store the enable flag of TX power temperature calibration.

hal_wireless_power_tcal_en_get¶

uint8_t hal_wireless_power_tcal_en_get(void);

Read the stored TX power temperature calibration flag.

Returns: The value last passed to hal_wireless_power_tcal_en_set() (0 if never set).

hal_wireless_capcode_tcal_en_set¶

void hal_wireless_capcode_tcal_en_set(uint8_t en);

Store the enable flag of capcode temperature calibration.

hal_wireless_capcode_tcal_en_get¶

uint8_t hal_wireless_capcode_tcal_en_get(void);

Read the stored capcode temperature calibration flag.

Returns: The value last passed to hal_wireless_capcode_tcal_en_set() (0 if never set).

Macros¶

ipro_ble_controller.h¶

#include "ipro_ble_controller.h" (Source)

BLE controller entry point: start the controller and reach its HCI transport.

The BLE controller is delivered as a prebuilt library. It runs in its own FreeRTOS task and exchanges standard H4 HCI packets with the Bluetooth host through an in-memory byte stream, the same packets a UART HCI link would carry.

Include this header instead of a platform directory. On IPRO7 it provides ipro_ble_ctlr_arch.h (controller start-up and task control) and ipro_ble_ctlr_hcitl.h (the HCI byte-stream transport). IPRO6S builds (CONFIG_BTDM_ENABLE or CONFIG_IPRO6) get the btdm_sdk.h compatibility API together with the same HCI transport header.

Typical IPRO7 bring-up with the bundled Bluetooth host:

1. ipro_platform_init() (freertos_app_hooks.h), create the application task and start the scheduler.
2. ipro_ble_ctlr_controller_init() with a priority above the application tasks, or ipro_pm_ble_controller_init() (ipro_pm_ble.h) when the power manager should also run connected platform PDS.
3. hci_driver_ipro_ble_ctlr_init() and bt_enable() to start the host.
4. Once bt_enable() reports ready, ipro_ble_ctlr_hcitl_host_ready(). Until then the controller keeps the BLE core awake.

Further IPRO7 headers: ipro_ble_ctlr_lowpower.h (32 kHz sleep clock), ipro_ble_ctlr_pds_snapshot.h (connected platform PDS) and ipro_ble_ctlr_nvds.h (device address).

ipro_ble_ctlr_arch.h¶

#include "ipro_ble_ctlr_arch.h" (Source)

IPRO7 BLE controller start-up, task control and connected low-power windows.

ipro_ble_ctlr_controller_init() brings the controller up and creates its FreeRTOS task. The task blocks whenever it has nothing to do and is woken by the BLE interrupt and by ipro_ble_ctlr_ctrl_notify(), which the HCI transport (ipro_ble_ctlr_hcitl.h) calls when the host sends bytes or makes room for the controller's output.

For connected platform PDS, the controller also publishes after each connection event the idle window until the next radio event (ipro_ble_ctlr_pds_candidate_token, ipro_ble_ctlr_pds_candidate_slack_hus, ipro_ble_ctlr_pds_full_generation). An RTOS idle policy checks a window with ipro_ble_ctlr_pds_candidate_revalidate() and grants it with ipro_ble_ctlr_pds_tickless_grant() (ipro_ble_ctlr_pds_snapshot.h). The ipro_pm power manager implements such a policy; see ipro_ble_ctlr_pds_snapshot.h for the full sequence.

Time values with the suffix _hus are in half-microseconds (units of 0.5 us).

ipro_ble_ctlr_controller_init¶

int ipro_ble_ctlr_controller_init(unsigned int task_priority);

Start the BLE controller.

Enables the BLE clock, resets the BLE core, qualifies the 32 kHz sleep clock (ipro_ble_ctlr_lowpower_init()), prepares the HCI transport, loads the device address and clock accuracies (ipro_ble_ctlr_nvds_init()), initializes the controller, creates the controller task and finally enables the BLE interrupt. The FreeRTOS scheduler does not have to be running yet. Call it once.

ipro_ble_ctlr_ctrl_notify¶

void ipro_ble_ctlr_ctrl_notify(void);

Wake the controller task.

The controller task blocks while it has nothing to do. Every external event that gives it work must wake it; otherwise it sleeps until the next radio interrupt. The HCI transport functions (ipro_ble_ctlr_hcitl.h) already call this when the host sends bytes or makes room for a stalled transfer, so applications rarely need it.

Wake-ups are latched: a wake-up sent just before the task blocks is not lost.

ipro_ble_ctlr_controller_task_handle¶

TaskHandle_t ipro_ble_ctlr_controller_task_handle(void);

Get the controller task handle.

An RTOS idle policy can pass it to xTaskGetExpectedIdleTimeExcludingTask() to look past the controller's 1 ms connection poll while a link is in the low-power profile (ipro_ble_ctlr_tickless_connection_active_set()).

Returns: FreeRTOS handle of the controller task, or NULL before ipro_ble_ctlr_controller_init() has created it.

ipro_ble_ctlr_controller_kick¶

void ipro_ble_ctlr_controller_kick(void);

Wake the controller task from task context.

Same as ipro_ble_ctlr_ctrl_notify() for callers that are known to run in a task. Does nothing before ipro_ble_ctlr_controller_init().

ipro_ble_ctlr_tickless_connection_active_set¶

void ipro_ble_ctlr_tickless_connection_active_set(bool active);

Mark whether the current connection uses the connected low-power (PDS) profile.

While set, the controller publishes after each connection event the idle window until the next radio event (ipro_ble_ctlr_pds_candidate_slack_hus, ipro_ble_ctlr_pds_candidate_token, ipro_ble_ctlr_pds_full_generation) and polls the link every millisecond, so that an RTOS idle policy can grant the window with ipro_ble_ctlr_pds_tickless_grant(). Setting it also resets the window statistics. Clear it when the link leaves the profile or disconnects.

ipro_ble_ctlr_tickless_connection_active_get¶

bool ipro_ble_ctlr_tickless_connection_active_get(void);

Report whether the connected low-power profile is set.

Returns: The value last set with ipro_ble_ctlr_tickless_connection_active_set(); false after ipro_ble_ctlr_controller_init().

ipro_ble_ctlr_clock_drift_uses_active¶

bool ipro_ble_ctlr_clock_drift_uses_active(void);

Report whether receive windows are sized with the active-clock accuracy only.

Returns: true when neither the controller's own BLE-core deep sleep nor the platform sleep-drift mode (ipro_ble_ctlr_platform_sleep_drift_enable()) is enabled, so the controller times connection events with the accuracy of the 32 MHz crystal.

ipro_ble_ctlr_platform_sleep_drift_enable¶

void ipro_ble_ctlr_platform_sleep_drift_enable(bool enable);

Use the sleep-clock accuracy for the receive windows after a platform PDS.

When enabled, the receive windows that follow a platform PDS, until the link has re-synchronized, are widened for the 32 kHz sleep-clock accuracy (ipro_ble_ctlr_lowpower_sleep_drift_ppm_get()), and never for less than the floor set with ipro_ble_ctlr_platform_sleep_drift_floor_set(). Ordinary connection events keep the active-clock accuracy. Disabled by default; enable it when connected PDS is used.

ipro_ble_ctlr_platform_sleep_drift_floor_set¶

void ipro_ble_ctlr_platform_sleep_drift_floor_set(uint32_t ppm);

Set the minimum clock drift assumed for the first receive window after a platform PDS.

ipro_ble_ctlr_pds_candidate_revalidate¶

bool ipro_ble_ctlr_pds_candidate_revalidate(uint32_t token, uint32_t *fresh_slack_hus);

Check that a published idle window can still be granted and get what is left of it.

Succeeds only if token is still the current window identifier (ipro_ble_ctlr_pds_candidate_token), the connection is in the low-power profile, no HCI bytes are in flight and the HCI hold-off (ipro_ble_ctlr_hcitl_awake_guard_ms) has expired, the link is neither guarded nor recovering from a previous PDS, the BLE core is not in its own deep sleep, and the window has not run out. After a failure, ipro_ble_ctlr_pds_reval_last_reason (ipro_ble_ctlr_pds_snapshot.h) tells a transient HCI hold-up from any other cause.

Returns: true if the window can still be granted, false otherwise.

Typedefs¶

ipro_ble_ctlr_hcitl.h¶

#include "ipro_ble_ctlr_hcitl.h" (Source)

HCI byte-stream transport between the Bluetooth host and the on-chip BLE controller.

Host and controller exchange standard H4 packets (a packet-type byte followed by the HCI packet) through two in-memory ring buffers, exactly as they would over a UART HCI link. The controller cannot tell the difference, and the host never touches controller memory:

• host to controller (h2c): written by the host with ipro_ble_ctlr_hcitl_host_write(), read by the controller task;
• controller to host (c2h): written by the controller task, read by the host with ipro_ble_ctlr_hcitl_host_read().

Each ring has exactly one producer and one consumer and needs no lock. On the host side this means one writer and one reader at a time: serialize ipro_ble_ctlr_hcitl_host_write() calls when several tasks send HCI packets.

The stream never loses a byte, because a missing byte would desynchronize the H4 framing for good. A full ring therefore never drops or blocks: ipro_ble_ctlr_hcitl_host_write() accepts only what fits and the caller keeps the rest, and the controller holds back its own output until the host has read enough to make room.

Host-side sequence:

1. ipro_ble_ctlr_hcitl_host_set_rx_notify() with a callback that wakes the host RX thread.
2. Send commands and data with ipro_ble_ctlr_hcitl_host_write(); after each notification, read events and data with ipro_ble_ctlr_hcitl_host_read() until it returns 0.
3. When the host has finished its HCI initialization, call ipro_ble_ctlr_hcitl_host_ready() so that the controller may let the BLE core sleep.

The bundled host driver (hci_driver_ipro_ble_ctlr_init()) performs steps 1 and 2; an application that uses it only has to call ipro_ble_ctlr_hcitl_host_ready().

ipro_ble_ctlr_hcitl_host_ready¶

void ipro_ble_ctlr_hcitl_host_ready(void);

Tell the controller that the host has finished its HCI initialization.

Until this is called the controller keeps the BLE core out of deep sleep and never enters platform PDS, so that every exchange of the host's start-up command sequence finds it awake. Call it once the host stack is up, for example from the bt_enable() ready callback. Further calls have no additional effect. It also wakes the controller task.

ipro_ble_ctlr_hcitl_host_write¶

uint32_t ipro_ble_ctlr_hcitl_host_write(const uint8_t *data, uint32_t len);

Send H4 bytes to the controller.

Copies as many bytes as fit into the host-to-controller ring, restarts the HCI awake guard (ipro_ble_ctlr_hcitl_awake_guard_ms) and wakes the controller task. The data is an H4 stream: every packet starts with its packet-type byte (for example 0x01 for a command, 0x02 for ACL data). A packet may be split across several calls.

Returns: Number of bytes accepted, from 0 to len. Less than len means the ring is full: keep the remaining bytes and send them later; never drop them, or the stream loses its framing. Check ipro_ble_ctlr_hcitl_host_write_space() first to avoid a partial write.

ipro_ble_ctlr_hcitl_host_write_space¶

uint32_t ipro_ble_ctlr_hcitl_host_write_space(void);

Get the free space in the host-to-controller ring.

Returns: Number of bytes ipro_ble_ctlr_hcitl_host_write() can accept right now.

ipro_ble_ctlr_hcitl_host_read¶

uint32_t ipro_ble_ctlr_hcitl_host_read(uint8_t *out, uint32_t max);

Read H4 bytes sent by the controller.

Copies up to max bytes out of the controller-to-host ring. Packet boundaries are not preserved: the host parses the H4 stream (type byte, header, payload) itself. If the controller was waiting for room in the ring, it is woken.

Returns: Number of bytes read; 0 when nothing is available.

ipro_ble_ctlr_hcitl_host_avail¶

uint32_t ipro_ble_ctlr_hcitl_host_avail(void);

Get the number of bytes waiting in the controller-to-host ring.

Returns: Number of bytes ipro_ble_ctlr_hcitl_host_read() can return right now.

ipro_ble_ctlr_hcitl_host_set_rx_notify¶

void ipro_ble_ctlr_hcitl_host_set_rx_notify(void(*cb)(void));

Register the callback that tells the host the controller has data for it.

The callback is invoked every time the controller adds bytes to the controller-to-host ring, which can happen several times per packet. Pass NULL to remove it.

Typedefs¶

Macros¶

ipro_ble_ctlr_lowpower.h¶

#include "ipro_ble_ctlr_lowpower.h" (Source)

IPRO7 BLE controller sleep clock: 32 kHz source qualification and drift bound.

Two clocks time a BLE link. While the CPU only waits in core-retentive WFI between radio events, BLE timing stays on the 32 MHz crystal and uses its accuracy. When the BLE core sleeps on its own or the chip enters platform PDS, elapsed time is measured on the 32 kHz clock instead. That clock is therefore selected and qualified once at controller start-up, and its accuracy is reported to the controller.

ipro_ble_ctlr_lowpower_init¶

int ipro_ble_ctlr_lowpower_init(void);

Select and qualify the 32 kHz sleep clock for the BLE controller.

The board configuration names the candidate source (board_get_32k_source(), from BOARD_CLK_32K_SOURCE_MACRO):

• a board that declares RC32K calibrates RC32K straight away;
• a board that declares the 32 kHz crystal, or declares nothing, first measures the crystal against the 32 MHz crystal. If it is off by more than 500 ppm or does not oscillate, RC32K is calibrated and used instead.

The measured error is compensated, and an accuracy bound that also covers temperature and supply (by default at least 50 ppm for the crystal and 500 ppm for RC32K) becomes the value returned by ipro_ble_ctlr_lowpower_sleep_drift_ppm_get(). Only the controller's own sleep and platform PDS use the result.

Called by ipro_ble_ctlr_controller_init() before the controller core is initialized; applications do not need to call it.

Returns: 0 when the 32 kHz crystal was qualified and selected; when RC32K is selected, the calibrated RC32K capacitor code (0 or greater); a negative value when the RC32K calibration or its accuracy measurement failed.

ipro_ble_ctlr_lowpower_sleep_drift_ppm_get¶

uint16_t ipro_ble_ctlr_lowpower_sleep_drift_ppm_get(void);

Get the sleep-clock accuracy bound the controller uses.

This is the positive accuracy bound of the 32 kHz clock in ppm. Whenever the 32 kHz clock times the link, the controller uses it to widen receive windows and to report its sleep clock accuracy to peers. It is not the signed error that the controller compensates.

Returns: Accuracy bound in ppm, between 20 and 2000; 500 before ipro_ble_ctlr_lowpower_init() has qualified the clock.

ipro_ble_ctlr_pds_snapshot.h¶

#include "ipro_ble_ctlr_pds_snapshot.h" (Source)

IPRO7 BLE controller connected platform PDS: enable, policy modes and window grants.

Connected platform PDS powers the IPRO7 down between connection events while a BLE link stays up. The controller owns the whole PDS cycle: it saves the BLE core state, enters PDS, restores the core and re-synchronizes the link. The application, or the ipro_pm power manager, only decides which idle windows may be used.

Set-up, after ipro_ble_ctlr_controller_init():

1. ipro_ble_ctlr_pds_enable(true) once.
2. When a connection is established, ipro_ble_ctlr_pds_auto_connected(true). When its parameters leave room for a PDS between connection events, ipro_ble_ctlr_tickless_connection_active_set(true) and ipro_ble_ctlr_pds_auto_config(true, 0) (grant-only mode).
3. In the RTOS idle hook, for each new window (ipro_ble_ctlr_pds_full_generation), check it with ipro_ble_ctlr_pds_candidate_revalidate(), size the sleep to the shorter of the RTOS and radio windows minus ipro_ble_ctlr_pds_reserve_us(), and grant it once with ipro_ble_ctlr_pds_tickless_grant().
4. When the link leaves the profile or disconnects, undo step 2.

ipro_pm_ble_controller_init() (ipro_pm_ble.h) does all of this; use these functions directly only to implement a different policy.

The controller reports what happened to each grant through optional hooks that the application may define (the controller references them as weak symbols):

• bool ipro_ble_ctlr_app_pds_prepare(uint32_t sleep_us): controller task, interrupts masked, last point before the cycle commits; return false to keep this window on WFI.
• void ipro_ble_ctlr_app_pds_resumed(void): right after the chip returns from PDS, interrupts masked.
• void ipro_ble_ctlr_app_pds_cycle_consumed(void): controller task; the grant was used for a PDS cycle.
• void ipro_ble_ctlr_app_pds_grant_released(void): the grant was given back without a PDS; only the window is lost and the next one may be granted. It can also run in the task that calls ipro_ble_ctlr_pds_enable(false) or ipro_ble_ctlr_pds_auto_connected(false).
• void ipro_ble_ctlr_app_pds_recovered(void): BLE interrupt context; the first connection event after the PDS re-synchronized the link.
• void ipro_ble_ctlr_app_pds_recovery_failed(uint32_t reason): controller task; the link did not recover, reason is an ipro_ble_ctlr_pds_recovery_fail_reason value.
• void ipro_ble_ctlr_app_pds_link_stuck(uint32_t links): controller task; a recovery disconnection did not complete and the host was sent HCI Hardware Error. The application owns any reset.

When ipro_pm handles BLE (CONFIG_IPRO_PM_BLE), it defines these hooks itself and the application must not define them.

Time values with the suffix _hus are in half-microseconds (units of 0.5 us).

ipro_ble_ctlr_pds_reserve_us¶

uint32_t ipro_ble_ctlr_pds_reserve_us(void);

Get the time the controller reserves around each connected PDS cycle.

The reserve covers waking the chip, restoring the BLE core and reaching the next radio event with a guard; it is 22000 us with the default configuration. A PDS policy subtracts it from the idle window before it calls ipro_ble_ctlr_pds_tickless_grant().

Returns: Reserve in microseconds.

ipro_ble_ctlr_pds_enable¶

int ipro_ble_ctlr_pds_enable(bool enable);

Enable or disable connected platform PDS.

Enabling keeps the MISC power domain on across PDS, so that the RAM holding host task stacks and kernel objects keeps its contents, and initializes the low-power HAL (hal_lp_init()). Disabling gives back any pending grant and ends any post-PDS recovery hold. Call it after ipro_ble_ctlr_controller_init(), which resets the PDS state.

ipro_ble_ctlr_pds_auto_config¶

int ipro_ble_ctlr_pds_auto_config(bool enable, uint32_t sleep_us);

Select the automatic connected-PDS mode.

• enable false: no automatic PDS; a pending automatic request is dropped.
• enable true, sleep_us 0: grant-only mode. A PDS cycle runs only when the RTOS idle policy grants a window with ipro_ble_ctlr_pds_tickless_grant(). ipro_pm uses this mode.
• enable true, sleep_us not 0: the controller requests a PDS of sleep_us on its own whenever the connected link allows one (no pending link-procedure instant, clean reception since the previous PDS).

Automatic PDS also needs ipro_ble_ctlr_pds_enable(true) and ipro_ble_ctlr_pds_auto_connected(true).

ipro_ble_ctlr_pds_tickless_grant¶

int ipro_ble_ctlr_pds_tickless_grant(uint32_t sleep_us);

Grant the controller one connected PDS cycle in the current idle window.

Called by the RTOS idle policy after ipro_ble_ctlr_pds_candidate_revalidate() succeeded. The controller uses the grant at its next safe point in the same window, shortening the sleep if less of the window is left, and reports the outcome through the hooks listed in the file description. Only one grant can be outstanding at a time.

ipro_ble_ctlr_pds_auto_connected¶

void ipro_ble_ctlr_pds_auto_connected(bool connected);

Tell the controller whether a connection is up for connected PDS.

Call it with true when a connection is established and with false when it ends. True restarts the link-settle and reception checks for the new link; false gives back any pending grant and ends any post-PDS recovery hold left from the link.

ipro_ble_ctlr_pds_auto_enabled¶

bool ipro_ble_ctlr_pds_auto_enabled(void);

Report whether automatic connected PDS is enabled.

Returns: true after ipro_ble_ctlr_pds_auto_config() enabled it, false otherwise.

ipro_ble_ctlr_pds_snapshot_enabled¶

bool ipro_ble_ctlr_pds_snapshot_enabled(void);

Report whether connected platform PDS is enabled.

Returns: true after ipro_ble_ctlr_pds_enable(true) until ipro_ble_ctlr_pds_enable(false); false when PDS is not available in this controller profile.

ipro_ble_ctlr_pds_clock_drift¶

bool ipro_ble_ctlr_pds_clock_drift(int32_t *error_hus, int32_t *ppm, uint32_t *elapsed_ms);

Measure the controller clock against the 32 kHz RTC since the last PDS restore.

Compares the BLE clock rebuilt after the last platform PDS with the always-on 32 kHz RTC. Diagnostic; any output pointer may be NULL.

Returns: true on success; false until a platform-PDS restore has set a reference point, while the BLE core is in its own deep sleep, or if the clock sample timed out.

ipro_ble_ctlr_pds_recovery_fail_reason¶

Why a link did not recover after a platform PDS; passed as reason to the optional ipro_ble_ctlr_app_pds_recovery_failed() hook.

After a restore the controller keeps the BLE core awake until the first clean connection event. If no connection event arrives within six connection intervals (each interval x (latency + 1), by default) after the next scheduled event, capped at the supervision timeout, or if the BLE core reports an error, or if a restore step times out, recovery is abandoned and every link is ended with reason 0x08 (the host receives HCI Disconnection Complete). Events that keep running without re-synchronizing are left to the link layer's own supervision timeout.

Typedefs¶

Macros¶

ipro_ble_ctlr_nvds.h¶

#include "ipro_ble_ctlr_nvds.h" (Source)

IPRO7 BLE controller parameters: Bluetooth device address and clock accuracy.

At start-up the controller reads its Bluetooth device address, the accuracy of its sleep and active clocks and its wake-up timing from a small parameter store in RAM, which ipro_ble_ctlr_nvds_init() fills. Nothing is kept in flash: the store is rebuilt on every boot.

ipro_ble_ctlr_nvds_init¶

bool ipro_ble_ctlr_nvds_init(void);

Fill the controller parameter store.

Stores the device address, the 32 kHz sleep-clock accuracy measured by ipro_ble_ctlr_lowpower_init(), the active-clock accuracy, the wake-up times and the setting of the controller's own BLE-core deep sleep. The device address is taken from the first of these sources that is usable:

1. the factory MAC address in eFuse, if it is programmed and is a valid unicast, globally administered address with a non-zero device part;
2. an address derived from the chip ID: locally administered, shown as 1E:0B:37:xx:xx:xx, unique per chip but not a registered public address;
3. a fixed development address, if the chip ID cannot be read either.

The address in use is logged at start-up.

Called by ipro_ble_ctlr_controller_init() before the controller core starts, because the core reads the address while it initializes; applications do not need to call it.

Returns: true if the address comes from eFuse; false if a fallback address is used or the parameter store could not be initialized.

ipro_ble_ctlr_nvds_bd_addr_get¶

void ipro_ble_ctlr_nvds_bd_addr_get(uint8_t addr[6]);

Get the Bluetooth device address the controller uses.