From 79a90bd566f45d530e12bf662789a74e681211d1 Mon Sep 17 00:00:00 2001 From: "Martine S. Lenders" Date: Fri, 15 Nov 2024 01:08:40 +0100 Subject: [PATCH 1/8] skald_bthome: initial import --- makefiles/pseudomodules.inc.mk | 1 + sys/include/net/skald/bthome.h | 324 ++++++++++++++++++++++++++++ sys/include/net/skald/bthome/defs.h | 322 +++++++++++++++++++++++++++ sys/net/ble/skald/Makefile | 4 + sys/net/ble/skald/skald_bthome.c | 181 ++++++++++++++++ 5 files changed, 832 insertions(+) create mode 100644 sys/include/net/skald/bthome.h create mode 100644 sys/include/net/skald/bthome/defs.h create mode 100644 sys/net/ble/skald/skald_bthome.c diff --git a/makefiles/pseudomodules.inc.mk b/makefiles/pseudomodules.inc.mk index c6cb490c27d0..3eb66341f09b 100644 --- a/makefiles/pseudomodules.inc.mk +++ b/makefiles/pseudomodules.inc.mk @@ -592,6 +592,7 @@ PSEUDOMODULES += pio_autostart_% # Submodules provided by Skald PSEUDOMODULES += skald_ibeacon PSEUDOMODULES += skald_eddystone +PSEUDOMODULES += skald_bthome PSEUDOMODULES += crypto_aes_128 PSEUDOMODULES += crypto_aes_192 diff --git a/sys/include/net/skald/bthome.h b/sys/include/net/skald/bthome.h new file mode 100644 index 000000000000..620553505615 --- /dev/null +++ b/sys/include/net/skald/bthome.h @@ -0,0 +1,324 @@ +/* + * Copyright (C) 2024 Martine S. Lenders + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +#ifndef NET_SKALD_BTHOME_H +#define NET_SKALD_BTHOME_H +/** + * @defgroup ble_skald_bthome Skald about BTHome + * @ingroup ble_skald + * @brief Skald's BTHome abstraction + * + * # About + * This Skald module supports the creation and advertisement of BTHome messages + * (see https://bthome.io) + * + * # Implementation state + * - BTHome v2 is mostly supported + * - [Encryption](https://bthome.io/encryption/) is not supported + * - [Trigger based devices](https://bthome.io/format/#bthome-data-format) are not supported + * + * + * @{ + * + * @file + * @brief BTHome interface + * + * @author Martine S. Lenders + */ + +#include "byteorder.h" + +#include "net/skald.h" + +#include "net/skald/bthome/defs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief BTHome advertising context holding the advertising data and state + */ +typedef struct { + skald_ctx_t skald; /**< Skald context */ + /** + * @brief Pointer to service data length field + * + * Will point to the service data length field within skald_bthome_ctx_t::skald after calling + * @ref skald_bthome_init(). + */ + uint8_t *svc_data_len; +} skald_bthome_ctx_t; + +/** + * @brief Initialize the next BTHome advertisement + * + * @pre `ctx != NULL` + * + * @param[out] ctx The BTHome context + * @param[in] shortened_name The shortened name for the BTHome advertisement. May be NULL, if no + * shortened name should be advertised. Must end with '\0' and may not + * make the length of the PDU exceed @ref NETDEV_BLE_PDU_MAXLEN + * @param[in] complete_name The complete name for the BTHome advertisement. May be NULL, if no + * complete name should be advertised. Must end with '\0' and may not + * make the length of the PDU exceed @ref NETDEV_BLE_PDU_MAXLEN + * @param[in] dev_info Flags for the device information. Currently, no flags are supported. + * + * @return The current size of the advertisement on success + * @return -EMSGSIZE, when @p shortened_name or @p complete_name cause the message to exceed + * @ref NETDEV_BLE_PDU_MAXLEN. With NDEBUG=0 an assertion is raised in this case. + */ +int skald_bthome_init( + skald_bthome_ctx_t *ctx, + const char *shortened_name, const char *complete_name, + uint8_t dev_info +); + +/** + * @brief Adds a measurement to the next BTHome advertisement + * @warning This does not check if the @p obj_id was inserted in the right order (they have to be + * added in numerical order from low to high) or if @p data_len is the correct data length + * for @p obj_id. It just checks if @p data_len fits within @p NETDEV_BLE_PDU_MAXLEN of the + * PDU. + * + * @pre `ctx != NULL` and `ctx` was initialized with @ref skald_bthome_init(). + * @pre @p data fits within the advertisement in @p ctx. + * + * @param[in,out] ctx The BTHome context. Must not be NULL and must be initialized with + * @ref skald_bthome_init(). + * @param[in] obj_id An object ID (see @ref skald_bthome_id_t). + * @param[in] data The measurement data. Must not be NULL. + * @param[in] data_len The length of @p data. + * + * @return The current size of the advertisement on success + * @return -EMSGSIZE, when @p data_len cause the message to exceed @ref NETDEV_BLE_PDU_MAXLEN. + * With NDEBUG=0 an assertion is raised in this case. + */ +int skald_bthome_add_measurement( + skald_bthome_ctx_t *ctx, + skald_bthome_id_t obj_id, + const void *data, + uint8_t data_len +); + +/** + * @brief Adds a one byte unsigned measurement to the next BTHome advertisement + * @warning This does not check if the @p obj_id was inserted in the right order (they have to be + * added in numerical order from low to high) or if @p data_len is the correct data length + * for @p obj_id. It just checks if @p data_len fits within @p NETDEV_BLE_PDU_MAXLEN of the + * PDU. + * + * @pre `ctx != NULL` and `ctx` was initialized with @ref skald_bthome_init(). + * @pre @p data fits within the advertisement in @p ctx. + * + * @param[in,out] ctx The BTHome context. Must not be NULL and must be initialized with + * @ref skald_bthome_init(). + * @param[in] obj_id An object ID (see @ref skald_bthome_id_t). + * @param[in] data The measurement data. + * + * @return The current size of the advertisement on success + * @return -EMSGSIZE, when @p data cause the message to exceed @ref NETDEV_BLE_PDU_MAXLEN. + * With NDEBUG=0 an assertion is raised in this case. + */ +static inline int skald_bthome_add_uint8_measurement( + skald_bthome_ctx_t *ctx, + skald_bthome_id_t obj_id, + uint8_t data +) +{ + return skald_bthome_add_measurement(ctx, obj_id, &data, sizeof(data)); +} + +/** + * @brief Adds a one byte signed measurement to the next BTHome advertisement + * @warning This does not check if the @p obj_id was inserted in the right order (they have to be + * added in numerical order from low to high) or if @p data_len is the correct data length + * for @p obj_id. It just checks if @p data_len fits within @p NETDEV_BLE_PDU_MAXLEN of the + * PDU. + * + * @pre `ctx != NULL` and `ctx` was initialized with @ref skald_bthome_init(). + * @pre @p data fits within the advertisement in @p ctx. + * + * @param[in,out] ctx The BTHome context. Must not be NULL and must be initialized with + * @ref skald_bthome_init(). + * @param[in] obj_id An object ID (see @ref skald_bthome_id_t). + * @param[in] data The measurement data. + * + * @return The current size of the advertisement on success + * @return -EMSGSIZE, when @p data cause the message to exceed @ref NETDEV_BLE_PDU_MAXLEN. + * With NDEBUG=0 an assertion is raised in this case. + */ +static inline int skald_bthome_add_int8_measurement( + skald_bthome_ctx_t *ctx, + skald_bthome_id_t obj_id, + int8_t data +) +{ + return skald_bthome_add_measurement(ctx, obj_id, &data, sizeof(data)); +} + +/** + * @brief Adds a two byte unsigned measurement to the next BTHome advertisement + * @warning This does not check if the @p obj_id was inserted in the right order (they have to be + * added in numerical order from low to high) or if @p data_len is the correct data length + * for @p obj_id. It just checks if @p data_len fits within @p NETDEV_BLE_PDU_MAXLEN of the + * PDU. + * + * @pre `ctx != NULL` and `ctx` was initialized with @ref skald_bthome_init(). + * @pre @p data fits within the advertisement in @p ctx. + * + * @param[in,out] ctx The BTHome context. Must not be NULL and must be initialized with + * @ref skald_bthome_init(). + * @param[in] obj_id An object ID (see @ref skald_bthome_id_t). + * @param[in] data The measurement data. + * + * @return The current size of the advertisement on success + * @return -EMSGSIZE, when @p data cause the message to exceed @ref NETDEV_BLE_PDU_MAXLEN. + * With NDEBUG=0 an assertion is raised in this case. + */ +static inline int skald_bthome_add_uint16_measurement( + skald_bthome_ctx_t *ctx, + skald_bthome_id_t obj_id, + uint16_t data +) +{ + uint16_t le_data = htole16(data); + return skald_bthome_add_measurement(ctx, obj_id, &le_data, sizeof(data)); +} + +/** + * @brief Adds a two byte signed measurement to the next BTHome advertisement + * @warning This does not check if the @p obj_id was inserted in the right order (they have to be + * added in numerical order from low to high) or if @p data_len is the correct data length + * for @p obj_id. It just checks if @p data_len fits within @p NETDEV_BLE_PDU_MAXLEN of the + * PDU. + * + * @pre `ctx != NULL` and `ctx` was initialized with @ref skald_bthome_init(). + * @pre @p data fits within the advertisement in @p ctx. + * + * @param[in,out] ctx The BTHome context. Must not be NULL and must be initialized with + * @ref skald_bthome_init(). + * @param[in] obj_id An object ID (see @ref skald_bthome_id_t). + * @param[in] data The measurement data. + * + * @return The current size of the advertisement on success + * @return -EMSGSIZE, when @p data cause the message to exceed @ref NETDEV_BLE_PDU_MAXLEN. + * With NDEBUG=0 an assertion is raised in this case. + */ +static inline int skald_bthome_add_int16_measurement( + skald_bthome_ctx_t *ctx, + skald_bthome_id_t obj_id, + int16_t data +) +{ + uint16_t le_data = htole16((uint16_t)data); + return skald_bthome_add_measurement(ctx, obj_id, &le_data, sizeof(data)); +} + +/** + * @brief Adds a three byte unsigned measurement to the next BTHome advertisement + * @warning This does not check if the @p obj_id was inserted in the right order (they have to be + * added in numerical order from low to high) or if @p data_len is the correct data length + * for @p obj_id. It just checks if @p data_len fits within @p NETDEV_BLE_PDU_MAXLEN of the + * PDU. + * + * @pre `ctx != NULL` and `ctx` was initialized with @ref skald_bthome_init(). + * @pre @p data fits within the advertisement in @p ctx. + * + * @param[in,out] ctx The BTHome context. Must not be NULL and must be initialized with + * @ref skald_bthome_init(). + * @param[in] obj_id An object ID (see @ref skald_bthome_id_t). + * @param[in] data The measurement data. + * + * @return The current size of the advertisement on success + * @return -EMSGSIZE, when @p data cause the message to exceed @ref NETDEV_BLE_PDU_MAXLEN. + * With NDEBUG=0 an assertion is raised in this case. + */ +static inline int skald_bthome_add_uint24_measurement( + skald_bthome_ctx_t *ctx, + skald_bthome_id_t obj_id, + uint32_t data +) +{ + uint32_t le_data = htole32(data); + return skald_bthome_add_measurement(ctx, obj_id, &le_data, 3U); +} + +/** + * @brief Adds a four byte unsigned measurement to the next BTHome advertisement + * @warning This does not check if the @p obj_id was inserted in the right order (they have to be + * added in numerical order from low to high) or if @p data_len is the correct data length + * for @p obj_id. It just checks if @p data_len fits within @p NETDEV_BLE_PDU_MAXLEN of the + * PDU. + * + * @pre `ctx != NULL` and `ctx` was initialized with @ref skald_bthome_init(). + * @pre @p data fits within the advertisement in @p ctx. + * + * @param[in,out] ctx The BTHome context. Must not be NULL and must be initialized with + * @ref skald_bthome_init(). + * @param[in] obj_id An object ID (see @ref skald_bthome_id_t). + * @param[in] data The measurement data. + * + * @return The current size of the advertisement on success + * @return -EMSGSIZE, when @p data cause the message to exceed @ref NETDEV_BLE_PDU_MAXLEN. + * With NDEBUG=0 an assertion is raised in this case. + */ +static inline int skald_bthome_add_uint32_measurement( + skald_bthome_ctx_t *ctx, + skald_bthome_id_t obj_id, + uint32_t data +) +{ + uint32_t le_data = htole32(data); + return skald_bthome_add_measurement(ctx, obj_id, &le_data, sizeof(data)); +} + +/** + * @brief Adds a four byte signed measurement to the next BTHome advertisement + * @warning This does not check if the @p obj_id was inserted in the right order (they have to be + * added in numerical order from low to high) or if @p data_len is the correct data length + * for @p obj_id. It just checks if @p data_len fits within @p NETDEV_BLE_PDU_MAXLEN of the + * PDU. + * + * @pre `ctx != NULL` and `ctx` was initialized with @ref skald_bthome_init(). + * @pre @p data fits within the advertisement in @p ctx. + * + * @param[in,out] ctx The BTHome context. Must not be NULL and must be initialized with + * @ref skald_bthome_init(). + * @param[in] obj_id An object ID (see @ref skald_bthome_id_t). + * @param[in] data The measurement data. + * + * @return The current size of the advertisement on success + * @return -EMSGSIZE, when @p data cause the message to exceed @ref NETDEV_BLE_PDU_MAXLEN. + * With NDEBUG=0 an assertion is raised in this case. + */ +static inline int skald_bthome_add_int32_measurement( + skald_bthome_ctx_t *ctx, + skald_bthome_id_t obj_id, + int32_t data +) +{ + uint32_t le_data = htole32((uint32_t)data); + return skald_bthome_add_measurement(ctx, obj_id, &le_data, sizeof(data)); +} + +/** + * @brief Starts periodically advertising the BTHome advertisement + * + * @param[in] ctx The BTHome context. Must not be NULL and must be initialized with + * @ref skald_bthome_init(). + * @param[in] adv_itvl_ms advertising interval in milliseconds + */ +void skald_bthome_advertise(skald_bthome_ctx_t *ctx, uint32_t adv_itvl_ms); + +#ifdef __cplusplus +} +#endif + +/** @} */ +#endif /* NET_SKALD_BTHOME_H */ diff --git a/sys/include/net/skald/bthome/defs.h b/sys/include/net/skald/bthome/defs.h new file mode 100644 index 000000000000..7d1346c99c1d --- /dev/null +++ b/sys/include/net/skald/bthome/defs.h @@ -0,0 +1,322 @@ +/* + * Copyright (C) 2024 Martine S. Lenders + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +#ifndef NET_SKALD_BTHOME_DEFS_H +#define NET_SKALD_BTHOME_DEFS_H +/** + * @defgroup ble_skald_bthome_defs BTHome definitions + * @ingroup ble_skald_bthome + * @brief Numbers for BTHome + * + * @{ + * + * @file + * @brief BTHome definitions interface + * + * @author Martine S. Lenders + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief BTHome object IDs + * + * _v_ is the value send, with the type in parenthesis. + */ +typedef enum { + /* ==================== 0x00 ==================== */ + BTHOME_ID_PACKET_ID = 0x00, /**< Packet ID as _v_ (uint8_t) */ + BTHOME_ID_BATTERY = 0x01, /**< Battery in _v_ % (uint8_t) */ + BTHOME_ID_TEMPERATURE_FACTOR_0_01 = 0x02, /**< Temperature in _v_ * 0.01 °C (int16_t) */ + BTHOME_ID_HUMIDITY_FACTOR_0_01 = 0x03, /**< Humidity in _v_ * 0.01 % (uint16_t) */ + BTHOME_ID_PRESSURE_FACTOR_0_01 = 0x04, /**< Pressure in _v_ * 0.01 hPa (uint24_t) */ + BTHOME_ID_ILLUMINANCE_FACTOR_0_01 = 0x05, /**< Illuminance in _v_ * 0.01 lux (uint24_t) */ + BTHOME_ID_MASS_KG_FACTOR_0_01 = 0x06, /**< Mass in _v_ * 0.01 kg (uint16_t) */ + BTHOME_ID_MASS_LB_FACTOR_0_01 = 0x07, /**< Mass in _v_ * 0.01 lb (uint16_t) */ + BTHOME_ID_DEWPOINT_0_01 = 0x08, /**< Dewpoint in _v_ * 0.01 °C (int16_t) */ + BTHOME_ID_COUNT_UINT8 = 0x09, /**< Count as _v_ (uint8_t) */ + BTHOME_ID_ENERGY_3B_FACTOR_0_001 = 0x0a, /**< Energy in _v_ * 0.001 kWh (uint24_t) */ + BTHOME_ID_POWER_UINT_FACTOR_0_01 = 0x0b, /**< Power in _v_ * 0.01 W (uint24_t) */ + BTHOME_ID_VOLTAGE_FACTOR_0_001 = 0x0c, /**< Voltage in _v_ * 0.001 V (uint16_t) */ + /** + * @brief PM2.5 (very fine particular matter) in _v_ ug/m3 (uint16_t) + */ + BTHOME_ID_PM_2_5 = 0x0d, + /** + * @brief PM10 (fine particular matter) in _v_ ug/m3 (uint16_t) + */ + BTHOME_ID_PM_10 = 0x0e, + /** + * @brief Generic boolean (uint8_t) + * + * 0 = False, 1 = True + */ + BTHOME_ID_BOOLEAN = 0x0f, + /* ==================== 0x10 ==================== */ + /** + * @brief Power as binary state (uint8_t) + * + * 0 = Off, 1 = On + */ + BTHOME_ID_POWER_BINARY = 0x10, + /** + * @brief Opening as binary state (uint8_t) + * + * 0 = Closed, 1 = Open + */ + BTHOME_ID_OPENING_BINARY = 0x11, + BTHOME_ID_C02 = 0x12, /**< CO2 in _v_ ppm (uint16_t) */ + BTHOME_ID_TVOC = 0x13, /**< TVOC in _v_ ug/m3 (uint16_t) */ + BTHOME_ID_MOISTURE_FACTOR_0_01 = 0x14, /**< Moisture in _v_ * 0.01 % (uint16_t) */ + /** + * @brief Battery as binary state (uint8_t) + * + * 0 = Normal, 1 = Low + */ + BTHOME_ID_BATTERY_BINARY = 0x15, + /** + * @brief Battery charging as binary state (uint8_t) + * + * 0 = Not charging, 1 = Charging + */ + BTHOME_ID_BATTERY_CHARGING_BINARY = 0x16, + /** + * @brief Carbon monoxid as binary state (uint8_t) + * + * 0 = Not detected, 1 = Detected + */ + BTHOME_ID_CARBON_MONOXIDE_BINARY = 0x17, + /** + * @brief Cold as binary state (uint8_t) + * + * 0 = Normal, 1 = Cold + */ + BTHOME_ID_COLD_BINARY = 0x18, + /** + * @brief Connectivity as binary state (uint8_t) + * + * 0 = Disconnected, 1 = Connected + */ + BTHOME_ID_CONNECTIVITY_BINARY = 0x19, + /** + * @brief Door as binary state (uint8_t) + * + * 0 = Closed, 1 = Open + */ + BTHOME_ID_DOOR_BINARY = 0x1a, + /** + * @brief Garage door as binary state (uint8_t) + * + * 0 = Closed, 1 = Open + */ + BTHOME_ID_GARAGE_DOOR_BINARY = 0x1b, + /** + * @brief Gas as binary state (uint8_t) + * + * 0 = Clear, 1 = Detected + */ + BTHOME_ID_GAS_BINARY = 0x1c, + /** + * @brief Heat as binary state (uint8_t) + * + * 0 = Normal, 1 = Hot + */ + BTHOME_ID_HEAT_BINARY = 0x1d, + /** + * @brief Light as binary state (uint8_t) + * + * 0 = No light, 1 = Light detected + */ + BTHOME_ID_LIGHT_BINARY = 0x1e, + /** + * @brief Lock as binary state (uint8_t) + * + * 0 = Locked, 1 = Unlocked + */ + BTHOME_ID_LOCKED_BINARY = 0x1f, + /* ==================== 0x20 ==================== */ + /** + * @brief Moisture as binary state (uint8_t) + * + * 0 = Dry, 1 = Wet + */ + BTHOME_ID_MOISTURE_BINARY = 0x20, + /** + * @brief Motion as binary state (uint8_t) + * + * 0 = Clear, 1 = Detected + */ + BTHOME_ID_MOTION_BINARY = 0x21, + /** + * @brief Moving as binary state (uint8_t) + * + * 0 = Not moving, 1 = Moving + */ + BTHOME_ID_MOVING_BINARY = 0x22, + /** + * @brief Occupancy as binary state (uint8_t) + * + * 0 = Clear, 1 = Detected + */ + BTHOME_ID_OCCUPANCY_BINARY = 0x23, + /** + * @brief Plug as binary state (uint8_t) + * + * 0 = Unplugged, 1 = Plugged in + */ + BTHOME_ID_PLUG_BINARY = 0x24, + /** + * @brief Presence as binary state (uint8_t) + * + * 0 = Away, 1 = Home + */ + BTHOME_ID_PRESENCE_BINARY = 0x25, + /** + * @brief Problem as binary state (uint8_t) + * + * 0 = OK, 1 = Problem + */ + BTHOME_ID_PROBLEM_BINARY = 0x26, + /** + * @brief Running as binary state (uint8_t) + * + * 0 = Not running, 1 = Running + */ + BTHOME_ID_RUNNING_BINARY = 0x27, + /** + * @brief Safety as binary state (uint8_t) + * + * 0 = Unsafe, 1 = Safe + */ + BTHOME_ID_SAFETY_BINARY = 0x28, + /** + * @brief Smoke as binary state (uint8_t) + * + * 0 = Clear, 1 = Detected + */ + BTHOME_ID_SMOKE_BINARY = 0x29, + /** + * @brief Sound as binary state (uint8_t) + * + * 0 = Clear, 1 = Detected + */ + BTHOME_ID_SOUND_BINARY = 0x2a, + /** + * @brief Tamper as binary state (uint8_t) + * + * 0 = Off, 1 = On + */ + BTHOME_ID_TAMPER_BINARY = 0x2b, + /** + * @brief Vibration as binary state (uint8_t) + * + * 0 = Clear, 1 = Detected + */ + BTHOME_ID_VIBRATION_BINARY = 0x2c, + /** + * @brief Window as binary state (uint8_t) + * + * 0 = Closed, 1 = Open + */ + BTHOME_ID_WINDOW_BINARY = 0x2d, + BTHOME_ID_HUMIDITY_FACTOR_1 = 0x2e, /**< Humidity in _v_ % (uint8_t) */ + BTHOME_ID_MOISTURE_FACTOR_1 = 0x2f, /**< Moisture in _v_ % (uint8_t) */ + /* ==================== 0x30 ==================== */ + /** + * @brief Button as _v_ (uint8_t) + * + * @see @ref skald_bthome_btn_t for value of _v_ + */ + BTHOME_ID_BUTTON = 0x3a, + /** + * @brief Dimmer as _v_ (uint16_t) + * + * 0x00XX for none, 0x01XX for XX steps left, 0x02XX for XX steps right + */ + BTHOME_ID_DIMMER = 0x3c, + BTHOME_ID_COUNT_UINT16 = 0x3d, /**< Count as _v_ (uint16_t) */ + BTHOME_ID_COUNT_UINT32 = 0x3e, /**< Count as _v_ (uint32_t) */ + BTHOME_ID_ROTATION_FACTOR_0_1 = 0x3f, /**< Rotation in _v_ (int16_t) */ + /* ==================== 0x40 ==================== */ + BTHOME_ID_DISTANCE_MM = 0x40, /**< Distance in _v_ mm (uint16_t) */ + BTHOME_ID_DISTANCE_M = 0x41, /**< Distance in _v_ m (uint16_t) */ + BTHOME_ID_DURATION_FACTOR_0_001 = 0x42, /**< Distance in _v_ m (uint16_t) */ + BTHOME_ID_CURRENT_UINT_FACTOR_0_001 = 0x43, /**< Current in _v_ * 0.001 A (uint16_t) */ + BTHOME_ID_SPEED_FACTOR_0_01 = 0x44, /**< Speed in _v_ * 0.01 m/s (uint16_t) */ + BTHOME_ID_TEMPERATURE_FACTOR_0_1 = 0x45, /**< Temperature in _v_ * 0.1 °C (int16_t) */ + BTHOME_ID_UV_INDEX_FACTOR_0_1 = 0x44, /**< Volume in _v_ * 0.1 (uint8_t) */ + BTHOME_ID_VOLUME_L_FACTOR_0_1 = 0x47, /**< Volume in _v_ * 0.1 l (uint16_t) */ + BTHOME_ID_VOLUME_ML_FACTOR_0_1 = 0x48, /**< Volume in _v_ * 0.1 ml (uint16_t) */ + /** + * @brief Volume flow rate in _v_ * 0.001 m3/h (uint16_t) + */ + BTHOME_ID_VOLUME_FLOW_RATE_FACTOR_0_001 = 0x49, + BTHOME_ID_VOLTAGE_FACTOR_0_1 = 0x4a, /**< Voltage in _v_ * 0.1 V (uint16_t) */ + BTHOME_ID_GAS_3B_FACTOR_0_001 = 0x4b, /**< Gas in _v_ * 0.001 m3 (uint24_t) */ + BTHOME_ID_GAS_4B_FACTOR_0_001 = 0x4c, /**< Gas in _v_ * 0.001 m3 (uint32_t) */ + BTHOME_ID_ENERGY_4B_FACTOR_0_001 = 0x4d, /**< Energy in _v_ * 0.001 kWh (uint32_t) */ + BTHOME_ID_VOLUME_L_FACTOR_0_001 = 0x4e, /**< Volume in _v_ * 0.001 l (uint32_t) */ + BTHOME_ID_WATER_FACTOR_0_001 = 0x4f, /**< Water in _v_ * 0.001 l (uint32_t) */ + /* ==================== 0x50 ==================== */ + BTHOME_ID_TIMESTAMP = 0x50, /**< Timestamp in _v_ s since UNIX epoch (uint48) */ + BTHOME_ID_ACCELERATION_FACTOR_0_001 = 0x51, /**< Acceleration in _v_ m/s² */ + BTHOME_ID_GYROSCOPE_FACTOR_0_001 = 0x52, /**< Gyroscope in _v_ °/s */ + /** + * @brief Volume storage in _v_ * 0.001 l (uint32_t) + */ + BTHOME_ID_VOLUME_STORAGE_FACTOR_0_001 = 0x55, + BTHOME_ID_TEMPERATURE_FACTOR_1 = 0x57, /**< Temperature in _v_ °C (int8_t) */ + BTHOME_ID_TEMPERATURE_FACTOR_0_35 = 0x58, /**< Temperature in _v_ * 0.35 °C (int8_t) */ + BTHOME_ID_COUNT_SINT8 = 0x59, /**< Count as _v_ (int8_t) */ + BTHOME_ID_COUNT_SINT16 = 0x5a, /**< Count as _v_ (int16_t) */ + BTHOME_ID_COUNT_SINT32 = 0x5b, /**< Count as _v_ (int32_t) */ + BTHOME_ID_POWER_SINT_FACTOR_0_01 = 0x5c, /**< Power in _v_ * 0.01 W (int32_t) */ + BTHOME_ID_CURRENT_SINT_FACTOR_0_001 = 0x5d, /**< Current in _v_ * 0.001 A (int16_t) */ + BTHOME_ID_TEXT = 0x53, /**< Text as _v_ (bytes) */ + BTHOME_ID_RAW = 0x54, /**< Raw as _v_ (bytes) */ + BTHOME_ID_CONDUCTIVITY = 0x56, /**< Conductivity in _v_ uS/cm (uint16_t) */ + /* ==================== 0xf0 ==================== */ + BTHOME_ID_DEVICE_TYPE_ID = 0xf0, /**< Device type id as _v_ (uint16_t) */ + /** + * @brief Firmware version as _v_ (4 bytes, uint32_t) + * + * _v_ is interpreted as v[3].v[2].[1].[0] + */ + BTHOME_ID_FIRMWARE_VERSION_4B_ID = 0xf1, + /** + * @brief Firmware version as _v_ (3 bytes, uint32_t) + * + * _v_ is interpreted as v[2].[1].[0] + */ + BTHOME_ID_FIRMWARE_VERSION_3B_ID = 0xf2, +} skald_bthome_id_t; + +/** + * @brief Value for button. + * + * @see @ref BTHOME_ID_BUTTON. + */ +typedef enum { + BTHOME_BTN_NONE = 0x00, /**< No button press */ + BTHOME_BTN_PRESS = 0x01, /**< Press */ + BTHOME_BTN_DOUBLE_PRESS = 0x02, /**< Double press */ + BTHOME_BTN_TRIPLE_PRESS = 0x03, /**< Triple press */ + BTHOME_BTN_LONG_PRESS = 0x04, /**< Long press */ + BTHOME_BTN_LONG_DOUBLE_PRESS = 0x05, /**< Long double press */ + BTHOME_BTN_LONG_TRIPLE_PRESS = 0x05, /**< Long triple press */ + BTHOME_BTN_HOLD_PRESS = 0x80, /**< Hold press */ +} skald_bthome_btn_t; + +#ifdef __cplusplus +} +#endif + +/** @} */ +#endif /* NET_SKALD_BTHOME_DEFS_H */ diff --git a/sys/net/ble/skald/Makefile b/sys/net/ble/skald/Makefile index c835b4d8ddc5..3ca013456562 100644 --- a/sys/net/ble/skald/Makefile +++ b/sys/net/ble/skald/Makefile @@ -8,4 +8,8 @@ ifneq (,$(filter skald_eddystone,$(USEMODULE))) SRC += skald_eddystone.c endif +ifneq (,$(filter skald_bthome,$(USEMODULE))) + SRC += skald_bthome.c +endif + include $(RIOTBASE)/Makefile.base diff --git a/sys/net/ble/skald/skald_bthome.c b/sys/net/ble/skald/skald_bthome.c new file mode 100644 index 000000000000..a6c35b367332 --- /dev/null +++ b/sys/net/ble/skald/skald_bthome.c @@ -0,0 +1,181 @@ +/* + * Copyright (C) 2024 Martine S. Lenders + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +/** + * @{ + * + * @file + * @author Martine S. Lenders + */ + +#include "random.h" + +#include "net/skald/bthome.h" + +#define AD_TYPE_FLAGS 0x01 +#define AD_TYPE_SVC_DATA 0x16 +#define AD_TYPE_LOCAL_NAME_SHORT 0x08 +#define AD_TYPE_LOCAL_NAME_COMPLETE 0x09 + +#define BT_HOME_DEV_INFO_MASK 0x01 +#define BT_HOME_DEV_INFO_BTHOME_V2 (2 << 5) + +typedef struct __attribute__((packed)) { + uint8_t length; + uint8_t ad_type; +} _ad_element_hdr_t; + +typedef struct __attribute__((packed)) { + _ad_element_hdr_t hdr; + uint8_t flags; +} _flags_t; + +typedef struct __attribute__((packed)) { + uint8_t txadd[BLE_ADDR_LEN]; + _flags_t flags; +} _bthome_msg_hdr_t; + +typedef struct __attribute__((packed)) { + /* MUST be { 0xd2, 0xfc }, see https://bthome.io/images/License_Statement_-_BTHOME.pdf */ + uint8_t uuid[2]; + uint8_t dev_info; +} _bthome_data_hdr_t; + +/* flags: LE General Discoverable Mode | BR/EDR Not Supported */ +#define BTHOME_FLAGS { .hdr = { .length = 0x02, .ad_type = 0x01 }, 0x06 } + +static int _set_name(skald_ctx_t *ctx, const char *name, uint8_t offset, uint8_t type) +{ + if (name) { + _ad_element_hdr_t *name_hdr; + uint8_t name_len = strlen(name); + uint8_t exp_size = (offset + name_len + sizeof(_ad_element_hdr_t)); + + assert(strlen(name) <= NETDEV_BLE_PDU_MAXLEN); + if (exp_size >= NETDEV_BLE_PDU_MAXLEN) { + assert(exp_size < NETDEV_BLE_PDU_MAXLEN); + return -EMSGSIZE; + } + name_hdr = (_ad_element_hdr_t *)(&ctx->pkt.pdu[offset]); + name_hdr->length = name_len + 1; + name_hdr->ad_type = type; + strncpy((char *)(&ctx->pkt.pdu[offset + sizeof(*name_hdr)]), name, name_len); + return sizeof(*name_hdr) + name_len; + } + return 0; +} + +static inline int _set_shortened_name(skald_ctx_t *ctx, const char *name, uint8_t offset) +{ + return _set_name(ctx, name, offset, AD_TYPE_LOCAL_NAME_SHORT); +} + +static inline int _set_complete_name(skald_ctx_t *ctx, const char *name, uint8_t offset) +{ + return _set_name(ctx, name, offset, AD_TYPE_LOCAL_NAME_COMPLETE); +} + +static int _init_svc_data(skald_bthome_ctx_t *ctx, uint8_t dev_info, uint8_t offset) +{ + _ad_element_hdr_t *svc_data_hdr; + _bthome_data_hdr_t *data_hdr; + uint8_t exp_size = (offset + sizeof(*svc_data_hdr) + sizeof(*data_hdr)); + + if (exp_size >= NETDEV_BLE_PDU_MAXLEN) { + assert(exp_size < NETDEV_BLE_PDU_MAXLEN); + return -EMSGSIZE; + } + svc_data_hdr = (_ad_element_hdr_t *)(&ctx->skald.pkt.pdu[offset]); + data_hdr = (_bthome_data_hdr_t *)(&ctx->skald.pkt.pdu[offset + sizeof(*svc_data_hdr)]); + svc_data_hdr->length = sizeof(*data_hdr) + 1; + svc_data_hdr->ad_type = AD_TYPE_SVC_DATA; + ctx->svc_data_len = &svc_data_hdr->length; + /* https://bthome.io/images/License_Statement_-_BTHOME.pdf */ + data_hdr->uuid[0] = 0xd2; + data_hdr->uuid[1] = 0xfc; + data_hdr->dev_info = ((dev_info & BT_HOME_DEV_INFO_MASK) | BT_HOME_DEV_INFO_BTHOME_V2); + return sizeof(*svc_data_hdr) + sizeof(*data_hdr); +} + +int skald_bthome_init( + skald_bthome_ctx_t *ctx, + const char *shortened_name, const char *complete_name, + uint8_t dev_info +) +{ + assert(ctx); + + uint8_t offset = sizeof(_bthome_msg_hdr_t); + int res; + static const _flags_t flags = BTHOME_FLAGS; + _bthome_msg_hdr_t *hdr = (_bthome_msg_hdr_t *)ctx->skald.pkt.pdu; + + skald_generate_random_addr(hdr->txadd); + hdr->flags = flags; + res = _set_shortened_name(&ctx->skald, shortened_name, offset); + if (res < 0) { + return res; + } + offset += res; + res = _set_complete_name(&ctx->skald, complete_name, offset); + if (res < 0) { + return res; + } + offset += res; + res = _init_svc_data(ctx, dev_info, offset); + if (res < 0) { + return res; + } + offset += res; + ctx->skald.pkt.len = offset; + return offset; +} + +int skald_bthome_add_measurement( + skald_bthome_ctx_t *ctx, + skald_bthome_id_t obj_id, + const void *data, + uint8_t data_len +) +{ + /* check if skald_bthome_init() was called */ + assert( + ctx + && (ctx->svc_data_len > (&ctx->skald.pkt.pdu[0])) + && (ctx->svc_data_len < (&ctx->skald.pkt.pdu[NETDEV_BLE_PDU_MAXLEN])) + && (ctx->skald.pkt.len > 0) + && (ctx->skald.pkt.len < NETDEV_BLE_PDU_MAXLEN) + ); + assert(data); + bool data_contains_length = ((obj_id == BTHOME_ID_RAW) || (obj_id == BTHOME_ID_TEXT)); + uint16_t exp_size = ctx->skald.pkt.len + sizeof(obj_id) + data_len + data_contains_length; + uint8_t offset = ctx->skald.pkt.len; + + if (exp_size >= NETDEV_BLE_PDU_MAXLEN) { + assert(exp_size < NETDEV_BLE_PDU_MAXLEN); + return -EMSGSIZE; + } + ctx->skald.pkt.pdu[offset++] = (uint8_t)obj_id; + if (data_contains_length) { + ctx->skald.pkt.pdu[offset++] = data_len; + } + memcpy(&ctx->skald.pkt.pdu[offset], data, data_len); + offset += data_len; + /* store diff in offset to return it later */ + *ctx->svc_data_len += offset - ctx->skald.pkt.len; + ctx->skald.pkt.len = offset; + return ctx->skald.pkt.len; +} + +void skald_bthome_advertise(skald_bthome_ctx_t *ctx, uint32_t adv_itvl_ms) +{ + ctx->skald.adv_itvl_ms = adv_itvl_ms; + skald_adv_start(&ctx->skald); +} + +/** @} */ From 8beb409743431d05915a30cc42d55f31fc02c47e Mon Sep 17 00:00:00 2001 From: "Martine S. Lenders" Date: Fri, 15 Nov 2024 01:13:22 +0100 Subject: [PATCH 2/8] examples: add simple skald_bthome example --- examples/README.md | 1 + examples/skald_bthome/Makefile | 24 +++++++++++++ examples/skald_bthome/README.md | 7 ++++ examples/skald_bthome/main.c | 54 +++++++++++++++++++++++++++++ sys/include/net/skald/bthome/defs.h | 2 +- 5 files changed, 87 insertions(+), 1 deletion(-) create mode 100644 examples/skald_bthome/Makefile create mode 100644 examples/skald_bthome/README.md create mode 100644 examples/skald_bthome/main.c diff --git a/examples/README.md b/examples/README.md index 030edface304..c387ed436eec 100644 --- a/examples/README.md +++ b/examples/README.md @@ -77,6 +77,7 @@ Here is a quick overview of the examples available in the RIOT: |---------|-------------| | [skald_eddystone](./skald_eddystone/README.md) | This example demonstrates the usage of `Skald` for creating an Google `Eddystone` beacon. | | [skald_ibeacon](./skald_ibeacon/README.md) | This example demonstrates the usage of `Skald` for creating an Apple `iBeacon`. | +| [skald_bthome](./skald_bthome/README.md) | This example demonstrates the usage of `Skald` for sending SAUL measurements via [`BTHome`](https://bthome.io). | ### MQTT diff --git a/examples/skald_bthome/Makefile b/examples/skald_bthome/Makefile new file mode 100644 index 000000000000..402ce8b580ee --- /dev/null +++ b/examples/skald_bthome/Makefile @@ -0,0 +1,24 @@ +# name of your application +APPLICATION = skald_bthome + +# If no BOARD is found in the environment, use this default: +BOARD ?= nrf52dk + +# This has to be the absolute path to the RIOT base directory: +RIOTBASE ?= $(CURDIR)/../.. + +# include Skald +USEMODULE += skald_bthome + +DEVELHELP ?= 1 + +BTHOME_NAME = "RIOT" +BTHOME_ADV_INTERVAL ?= 60000 + +CFLAGS += -DBTHOME_NAME="\"$(BTHOME_NAME)\"" +CFLAGS += -DBTHOME_ADV_INTERVAL=$(BTHOME_ADV_INTERVAL) + +# Change this to 0 show compiler invocation lines by default: +QUIET ?= 1 + +include $(RIOTBASE)/Makefile.include diff --git a/examples/skald_bthome/README.md b/examples/skald_bthome/README.md new file mode 100644 index 000000000000..9604e04d152e --- /dev/null +++ b/examples/skald_bthome/README.md @@ -0,0 +1,7 @@ +# Skald BTHome Example + +This example demonstrates the usage of `Skald` for creating a BTHome +setup, advertising sensors in the SAUL registry. + +Simply compile and flash, and verify your newly created beacon with any type of +BLE scanner / BTHome receiver (e.g. Home Assistant). diff --git a/examples/skald_bthome/main.c b/examples/skald_bthome/main.c new file mode 100644 index 000000000000..de7873fc25ef --- /dev/null +++ b/examples/skald_bthome/main.c @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2024 Martine S. Lenders + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +/** + * @ingroup examples + * @{ + * + * @file + * @brief BLE BTHome example using Skald + * + * @author Martine S. Lenders + * + * @} + */ + +#include + +#include "ztimer.h" + +#include "net/skald/bthome.h" + +#ifndef CONFIG_BTHOME_SAUL_REG_DEVS +#define CONFIG_BTHOME_SAUL_REG_DEVS (16U) +#endif + +#ifndef BTHOME_ADV_INTERVAL +#define BTHOME_ADV_INTERVAL (60000U) +#endif + +static skald_bthome_ctx_t _ctx; + +int main(void) +{ + ztimer_sleep(ZTIMER_MSEC, 2000); + printf("Skald and the tale of Harald's home\n"); + + if (skald_bthome_init(&_ctx, NULL, BTHOME_NAME, 0) < 0) { + return 1; + } + if (skald_bthome_add_uint24_measurement(&_ctx, BTHOME_ID_TEMPERATURE_FACTOR_0_01, 2500) < 0) { + return 1; + } + if (skald_bthome_add_int16_measurement(&_ctx, BTHOME_ID_HUMIDITY_FACTOR_0_01, 5055) < 0) { + printf("H %u\n", _ctx.skald.pkt.len); + return 1; + } + skald_bthome_advertise(&_ctx, BTHOME_ADV_INTERVAL); + return 0; +} diff --git a/sys/include/net/skald/bthome/defs.h b/sys/include/net/skald/bthome/defs.h index 7d1346c99c1d..b59c85afd89f 100644 --- a/sys/include/net/skald/bthome/defs.h +++ b/sys/include/net/skald/bthome/defs.h @@ -72,7 +72,7 @@ typedef enum { * 0 = Closed, 1 = Open */ BTHOME_ID_OPENING_BINARY = 0x11, - BTHOME_ID_C02 = 0x12, /**< CO2 in _v_ ppm (uint16_t) */ + BTHOME_ID_CO2 = 0x12, /**< CO2 in _v_ ppm (uint16_t) */ BTHOME_ID_TVOC = 0x13, /**< TVOC in _v_ ug/m3 (uint16_t) */ BTHOME_ID_MOISTURE_FACTOR_0_01 = 0x14, /**< Moisture in _v_ * 0.01 % (uint16_t) */ /** From d2edf12890c4054a39c72dafc0c1855ec119c32b Mon Sep 17 00:00:00 2001 From: "Martine S. Lenders" Date: Sat, 16 Nov 2024 01:14:29 +0100 Subject: [PATCH 3/8] isl29020: use lux instead of cd --- drivers/isl29020/isl29020_saul.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/isl29020/isl29020_saul.c b/drivers/isl29020/isl29020_saul.c index cd514d3869c9..365838e5b027 100644 --- a/drivers/isl29020/isl29020_saul.c +++ b/drivers/isl29020/isl29020_saul.c @@ -28,7 +28,7 @@ static int read(const void *dev, phydat_t *res) res->val[0] = (int16_t)isl29020_read((const isl29020_t *)dev); res->val[1] = 0; res->val[2] = 0; - res->unit = UNIT_CD; + res->unit = UNIT_LUX; /* https://www.renesas.com/en/document/dst/isl29020-datasheet */ res->scale = 0; return 1; } From b579a40666340daf7c7bc85fccae855747a27e67 Mon Sep 17 00:00:00 2001 From: "Martine S. Lenders" Date: Sat, 16 Nov 2024 01:16:45 +0100 Subject: [PATCH 4/8] skald_bthome_saul: initial import for SAUL support --- makefiles/pseudomodules.inc.mk | 2 + sys/Makefile.dep | 6 + sys/include/net/skald.h | 44 +- sys/include/net/skald/bthome.h | 92 +++- sys/net/ble/skald/Makefile | 4 + sys/net/ble/skald/skald.c | 43 +- sys/net/ble/skald/skald_bthome_saul.c | 656 ++++++++++++++++++++++++++ 7 files changed, 834 insertions(+), 13 deletions(-) create mode 100644 sys/net/ble/skald/skald_bthome_saul.c diff --git a/makefiles/pseudomodules.inc.mk b/makefiles/pseudomodules.inc.mk index 3eb66341f09b..e4d1cff6d334 100644 --- a/makefiles/pseudomodules.inc.mk +++ b/makefiles/pseudomodules.inc.mk @@ -590,9 +590,11 @@ NO_PSEUDOMODULES += periph_common PSEUDOMODULES += pio_autostart_% # Submodules provided by Skald +PSEUDOMODULES += skald_update_pkt_cb PSEUDOMODULES += skald_ibeacon PSEUDOMODULES += skald_eddystone PSEUDOMODULES += skald_bthome +PSEUDOMODULES += skald_bthome_saul PSEUDOMODULES += crypto_aes_128 PSEUDOMODULES += crypto_aes_192 diff --git a/sys/Makefile.dep b/sys/Makefile.dep index 00afb08a25ee..8a405f9605a1 100644 --- a/sys/Makefile.dep +++ b/sys/Makefile.dep @@ -581,6 +581,12 @@ ifneq (,$(filter skald,$(USEMODULE))) USEMODULE += ztimer_msec endif +ifneq (,$(filter skald_bthome_saul,$(USEMODULE))) + USEMODULE += skald_bthome + USEMODULE += skald_update_pkt_cb + USEMODULE += saul_reg +endif + ifneq (,$(filter bluetil_addr,$(USEMODULE))) USEMODULE += fmt endif diff --git a/sys/include/net/skald.h b/sys/include/net/skald.h index 91c3cbfa0f58..46c39a793cff 100644 --- a/sys/include/net/skald.h +++ b/sys/include/net/skald.h @@ -46,10 +46,15 @@ #include +#include "kernel_defines.h" #include "ztimer.h" #include "net/ble.h" #include "net/netdev/ble.h" +#if IS_USED(MODULE_SKALD_UPDATE_PKT_CB) +#include "event.h" +#endif + #ifdef __cplusplus extern "C" { #endif @@ -68,16 +73,41 @@ typedef struct { uint8_t u8[16]; /**< UUID with byte-wise access */ } skald_uuid_t; +/** + * @brief Forward declaration + */ +typedef struct skald_ctx skald_ctx_t; + /** * @brief Advertising context holding the advertising data and state */ -typedef struct { - netdev_ble_pkt_t pkt; /**< packet holding the advertisement (GAP) data */ - ztimer_t timer; /**< timer for scheduling advertising events */ - ztimer_now_t last; /**< last timer trigger (for offset compensation) */ - uint8_t cur_chan; /**< keep track of advertising channels */ - uint32_t adv_itvl_ms; /**< advertising interval [ms] */ -} skald_ctx_t; +struct skald_ctx { + netdev_ble_pkt_t pkt; /**< packet holding the advertisement (GAP) data */ +#if IS_USED(MODULE_SKALD_UPDATE_PKT_CB) || defined(DOXYGEN) + /** + * @brief callback to update packet on periodic advertisements + * + * Requires module `skald_pkt_update_cb`. + */ + void (*update_pkt)(skald_ctx_t *); + /** + * @brief Event queue to send periodic advertisements from + * + * Only available and needed with module `skald_pkt_update_cb`. + */ + event_queue_t queue; + /** + * @brief The event to trigger to send periodic advertisements + * + * Only available and needed with module `skald_pkt_update_cb`. + */ + event_t event; +#endif + ztimer_t timer; /**< timer for scheduling advertising events */ + ztimer_now_t last; /**< last timer trigger (for offset compensation) */ + uint8_t cur_chan; /**< keep track of advertising channels */ + uint32_t adv_itvl_ms; /**< advertising interval [ms] */ +}; /** * @brief Initialize Skald and the underlying radio diff --git a/sys/include/net/skald/bthome.h b/sys/include/net/skald/bthome.h index 620553505615..53264d37e57a 100644 --- a/sys/include/net/skald/bthome.h +++ b/sys/include/net/skald/bthome.h @@ -32,9 +32,13 @@ */ #include "byteorder.h" - +#include "kernel_defines.h" #include "net/skald.h" +#if IS_USED(MODULE_SKALD_BTHOME_SAUL) +#include "saul_reg.h" +#endif + #include "net/skald/bthome/defs.h" #ifdef __cplusplus @@ -42,9 +46,62 @@ extern "C" { #endif /** - * @brief BTHome advertising context holding the advertising data and state + * @brief Forward declaration of @ref skald_bthome_ctx_t. + */ +typedef struct skald_bthome_ctx skald_bthome_ctx_t; + +#if IS_USED(MODULE_SKALD_BTHOME_SAUL) || defined(DOXYGEN) +/** + * @brief BTHome-SAUL-adapter */ typedef struct { + /** + * @brief Copy of the SAUL registry entry. + * + * Must be initialized when calling @ref skald_bthome_saul_add() + * with saul_reg_t::next set to NULL. + */ + saul_reg_t saul; + /** + * @brief Object ID for the SAUL registry entry + * + * @see skald_bthome_id_t + * + * Will be filled by @ref skald_bthome_saul_add(). + */ + skald_bthome_id_t obj_id; + + /** + * @brief Callback to add measurement from SAUL registry entry + * + * Called directly after the measurement was taken via + * @ref saul_reg_read() and should ultimately call + * @ref skald_bthome_add_measurement() * (or one of its wrappers). + * + * Will be filled by @ref skald_bthome_saul_add(). + * + * @param[in,out] ctx BTHome advertising context. MUST not be NULL. + * @param[in] obj_id The object ID for the measurement. + * @param[in] data The @ref phydat_t to an element from. MUST not be NULL. + * @param[in] idx The index of phydat_t::val to take the measurement from. + * MUST be lesser than PHYDAT_DIM. + * + * @return The result of @ref skald_bthome_add_measurement() or one of its + * wrappers. + */ + int (*add_measurement)( + skald_bthome_ctx_t *ctx, + uint8_t obj_id, + phydat_t *data, + uint8_t idx + ); +} skald_bthome_saul_t; +#endif + +/** + * @brief BTHome advertising context holding the advertising data and state + */ +struct skald_bthome_ctx { skald_ctx_t skald; /**< Skald context */ /** * @brief Pointer to service data length field @@ -53,7 +110,15 @@ typedef struct { * @ref skald_bthome_init(). */ uint8_t *svc_data_len; -} skald_bthome_ctx_t; +#if IS_USED(MODULE_SKALD_BTHOME_SAUL) || defined(DOXYGEN) + /** + * @brief SAUL devices to take measurements from. + * + * Fill this using @ref skald_bthome_saul_add(). + */ + skald_bthome_saul_t *devs; +#endif +}; /** * @brief Initialize the next BTHome advertisement @@ -307,6 +372,27 @@ static inline int skald_bthome_add_int32_measurement( return skald_bthome_add_measurement(ctx, obj_id, &le_data, sizeof(data)); } +#if IS_USED(MODULE_SKALD_BTHOME_SAUL) || defined(DOXYGEN) +/** + * @brief Add SAUL registry entry to BTHome + * + * skald_bthome_saul_t::saul of @p saul must be a copy of what is found in @ref sys_saul_reg. + * + * @see @ref sys_saul_reg + * + * @param[in,out] ctx The BTHome context. Must not be NULL and must be initialized with + * @ref skald_bthome_init(). + * @param[in] saul A BTHome-SAUL-adapter. + * + * @retval 0 on success. + * @retval -ENOTSUP if the SAUL registry entry of @p saul has no driver. + * @retval -ENODEV if reading the SAUL device results in an error. + * @retval -ENOENT if the SAUL device and its result are not convertible to a sensible + * object ID. + */ +int skald_bthome_saul_add(skald_bthome_ctx_t *ctx, skald_bthome_saul_t *saul); +#endif + /** * @brief Starts periodically advertising the BTHome advertisement * diff --git a/sys/net/ble/skald/Makefile b/sys/net/ble/skald/Makefile index 3ca013456562..6fc4fc753b6e 100644 --- a/sys/net/ble/skald/Makefile +++ b/sys/net/ble/skald/Makefile @@ -12,4 +12,8 @@ ifneq (,$(filter skald_bthome,$(USEMODULE))) SRC += skald_bthome.c endif +ifneq (,$(filter skald_bthome_saul,$(USEMODULE))) + SRC += skald_bthome_saul.c +endif + include $(RIOTBASE)/Makefile.base diff --git a/sys/net/ble/skald/skald.c b/sys/net/ble/skald/skald.c index 021967355746..c737c6e8780a 100644 --- a/sys/net/ble/skald/skald.c +++ b/sys/net/ble/skald/skald.c @@ -46,6 +46,12 @@ #define ADV_AA (0x8e89bed6) /* access address */ #define ADV_CRC (0x00555555) /* CRC initializer */ +#if IS_USED(MODULE_SKALD_UPDATE_PKT_CB) +#define _on_adv_evt_isr _on_adv_evt_event +#else +#define _on_adv_evt_isr _on_adv_evt +#endif + static const uint8_t _adv_chan[] = SKALD_ADV_CHAN; static netdev_ble_ctx_t _ble_ctx = { @@ -69,7 +75,10 @@ static void _sched_next(skald_ctx_t *ctx) ctx->last += random_uint32_range(JITTER_MIN, JITTER_MAX); /* compensate the time passed since the timer triggered last by using the * current value of the timer */ - ztimer_set(ZTIMER_MSEC, &ctx->timer, (ctx->last - ztimer_now(ZTIMER_MSEC))); + ztimer_now_t next = (ctx->last > ztimer_now(ZTIMER_MSEC)) + ? (ctx->last - ztimer_now(ZTIMER_MSEC)) + : 0; + ztimer_set(ZTIMER_MSEC, &ctx->timer, next); } static void _on_adv_evt(void *arg) @@ -81,6 +90,11 @@ static void _on_adv_evt(void *arg) if ((ctx->cur_chan < ADV_CHAN_NUMOF) && (_radio->context == NULL)) { _radio->context = ctx; _ble_ctx.chan = _adv_chan[ctx->cur_chan]; +#if IS_USED(MODULE_SKALD_UPDATE_PKT_CB) + if (ctx->update_pkt) { + ctx->update_pkt(ctx); + } +#endif netdev_ble_set_ctx(_radio, &_ble_ctx); netdev_ble_send(_radio, &ctx->pkt); ++ctx->cur_chan; @@ -91,6 +105,23 @@ static void _on_adv_evt(void *arg) } } +#if IS_USED(MODULE_SKALD_UPDATE_PKT_CB) +static void _event_handler(event_t *event) +{ + skald_ctx_t *ctx = container_of(event, skald_ctx_t, event); + + _on_adv_evt(ctx); +} + +static void _on_adv_evt_event(void *arg) +{ + skald_ctx_t *ctx = arg; + + ctx->event.handler = _event_handler; + event_post(&ctx->queue, &ctx->event); +} +#endif + static void _on_radio_evt(netdev_t *netdev, netdev_event_t event) { (void)netdev; @@ -98,7 +129,7 @@ static void _on_radio_evt(netdev_t *netdev, netdev_event_t event) if (event == NETDEV_EVENT_TX_COMPLETE) { skald_ctx_t *ctx = _radio->context; _stop_radio(); - _on_adv_evt(ctx); + _on_adv_evt_isr(ctx); } } @@ -122,14 +153,20 @@ void skald_adv_start(skald_ctx_t *ctx) skald_adv_stop(ctx); /* initialize advertising context */ - ctx->timer.callback = _on_adv_evt; + ctx->timer.callback = _on_adv_evt_isr; ctx->timer.arg = ctx; ctx->last = ztimer_now(ZTIMER_MSEC); ctx->cur_chan = 0; ctx->pkt.flags = (BLE_ADV_NONCON_IND | BLE_LL_FLAG_TXADD); +#if IS_USED(MODULE_SKALD_UPDATE_PKT_CB) + event_queue_init(&ctx->queue); +#endif /* start advertising */ _sched_next(ctx); +#if IS_USED(MODULE_SKALD_UPDATE_PKT_CB) + event_loop(&ctx->queue); +#endif } void skald_adv_stop(skald_ctx_t *ctx) diff --git a/sys/net/ble/skald/skald_bthome_saul.c b/sys/net/ble/skald/skald_bthome_saul.c new file mode 100644 index 000000000000..35436ecec577 --- /dev/null +++ b/sys/net/ble/skald/skald_bthome_saul.c @@ -0,0 +1,656 @@ +/* + * Copyright (C) 2024 Martine S. Lenders + * + * This file is subject to the terms and conditions of the GNU Lesser + * General Public License v2.1. See the file LICENSE in the top level + * directory for more details. + */ + +/** + * @{ + * + * @file + * @author Martine S. Lenders + */ + +#include "net/skald/bthome.h" + +static int _add_50perc_to_binary_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_button_press( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_int8_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_int16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_uint8_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_uint24_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_div_10_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_div_10_uint24_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_div_100_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_div_100_uint24_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_div_1000_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_div_10000_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_g_force_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_ppb_to_ugm3_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_times_10_uint8_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_times_10_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_times_10_uint24_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_times_100_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_times_100_uint24_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_times_1000_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); +static int _add_times_10000_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx); + +static int _saul_sense_to_bthome_id(skald_bthome_saul_t *saul, const phydat_t *data) +{ + switch (saul->saul.driver->type & SAUL_ID_MASK) { + case SAUL_SENSE_ID_ANY: + return -1; + case SAUL_SENSE_ID_BTN: + saul->obj_id = BTHOME_ID_BUTTON; + saul->add_measurement = &_add_button_press; + return 0; + case SAUL_SENSE_ID_TEMP: + case SAUL_SENSE_ID_OBJTEMP: + switch (data->unit) { + case UNIT_TEMP_C: + switch (data->scale) { + case -2: + saul->obj_id = BTHOME_ID_TEMPERATURE_FACTOR_0_01; + saul->add_measurement = &_add_int16_measurement; + return 0; + case -1: + saul->obj_id = BTHOME_ID_TEMPERATURE_FACTOR_0_1; + saul->add_measurement = &_add_int16_measurement; + return 0; + case 0: + saul->obj_id = BTHOME_ID_TEMPERATURE_FACTOR_1; + saul->add_measurement = &_add_int8_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + case SAUL_SENSE_ID_HUM: + switch (data->unit) { + case UNIT_PERCENT: + switch (data->scale) { + case -2: + saul->obj_id = BTHOME_ID_HUMIDITY_FACTOR_0_01; + saul->add_measurement = &_add_uint16_measurement; + return 0; + case -1: + saul->obj_id = BTHOME_ID_HUMIDITY_FACTOR_0_01; + saul->add_measurement = &_add_times_10_uint16_measurement; + return 0; + case 0: + saul->obj_id = BTHOME_ID_HUMIDITY_FACTOR_1; + saul->add_measurement = &_add_uint8_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + case SAUL_SENSE_ID_LIGHT: + switch (data->unit) { + case UNIT_LUX: + switch (data->scale) { + case 0: + saul->obj_id = BTHOME_ID_ILLUMINANCE_FACTOR_0_01; + saul->add_measurement = &_add_times_100_uint24_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + case SAUL_SENSE_ID_ACCEL: + switch (data->unit) { + case UNIT_G_FORCE: + switch (data->scale) { + case -3: + saul->obj_id = BTHOME_ID_ACCELERATION_FACTOR_0_001; + saul->add_measurement = &_add_g_force_uint16_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + case SAUL_SENSE_ID_MAG: + return -1; + case SAUL_SENSE_ID_GYRO: + switch (data->unit) { + case UNIT_DPS: + saul->obj_id = BTHOME_ID_GYROSCOPE_FACTOR_0_001; + switch (data->scale) { + case -1: + saul->add_measurement = &_add_times_100_uint16_measurement; + return 0; + case 0: + saul->add_measurement = &_add_times_1000_uint16_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + case SAUL_SENSE_ID_COLOR: + return -1; + case SAUL_SENSE_ID_PRESS: + switch (data->unit) { + case UNIT_BAR: + switch (data->scale) { + case -6: + saul->obj_id = BTHOME_ID_PRESSURE_FACTOR_0_01; + /* 10^-6 bar = 0.000001 bar = 0.1 Pa = 0.001 hPa + * => data / 10 = 10^-6 bar in 0.01 hPA */ + saul->add_measurement = &_add_div_10_uint24_measurement; + return 0; + default: + return -1; + } + case UNIT_PA: + saul->obj_id = BTHOME_ID_PRESSURE_FACTOR_0_01; + switch (data->scale) { + case -2: + /* 10^-2 Pa = 0.0001 hPa + * => data / 100 = 10^-2 Pa in 0.01 hPa */ + saul->add_measurement = &_add_div_100_uint24_measurement; + return 0; + case 0: + saul->add_measurement = &_add_uint24_measurement; + return 0; + case 1: + /* 10^1 Pa = 0.1 hPa */ + saul->add_measurement = &_add_times_10_uint24_measurement; + return 0; + case 2: + /* 10^2 Pa = 1 hPa */ + saul->add_measurement = &_add_times_100_uint24_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + case SAUL_SENSE_ID_ANALOG: + return -1; + case SAUL_SENSE_ID_UV: + switch (data->scale) { + case -1: + saul->obj_id = BTHOME_ID_UV_INDEX_FACTOR_0_1; + saul->add_measurement = &_add_uint8_measurement; + return 0; + case 0: + saul->obj_id = BTHOME_ID_UV_INDEX_FACTOR_0_1; + saul->add_measurement = &_add_times_10_uint8_measurement; + return 0; + default: + return -1; + } + case SAUL_SENSE_ID_COUNT: + switch (data->unit) { + case UNIT_CPM3: + switch (data->scale) { + case 3: + saul->obj_id = BTHOME_ID_COUNT_UINT32; + saul->add_measurement = &_add_times_1000_uint16_measurement; + return 0; + case 4: + saul->obj_id = BTHOME_ID_COUNT_UINT32; + saul->add_measurement = &_add_times_10000_uint16_measurement; + return 0; + default: + return -1; + } + case UNIT_NONE: + switch (data->scale) { + case 0: + saul->obj_id = BTHOME_ID_COUNT_UINT16; + saul->add_measurement = &_add_uint16_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + return -1; + return -1; + case SAUL_SENSE_ID_DISTANCE: + switch (data->unit) { + case UNIT_M: + switch (data->scale) { + case -3: + saul->obj_id = BTHOME_ID_DISTANCE_MM; + saul->add_measurement = &_add_uint16_measurement; + return 0; + case 0: + saul->obj_id = BTHOME_ID_DISTANCE_M; + saul->add_measurement = &_add_uint16_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + return -1; + case SAUL_SENSE_ID_CO2: + switch (data->unit) { + case UNIT_PPM: + saul->obj_id = BTHOME_ID_CO2; + switch (data->scale) { + case -2: + saul->add_measurement = &_add_div_100_uint16_measurement; + return 0; + case 0: + saul->add_measurement = &_add_uint16_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + return -1; + case SAUL_SENSE_ID_TVOC: + switch (data->unit) { + case UNIT_PPB: + switch (data->scale) { + case 0: + saul->obj_id = BTHOME_ID_TVOC; + saul->add_measurement = &_add_ppb_to_ugm3_uint16_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + return -1; + return -1; + case SAUL_SENSE_ID_GAS: + /* only gas sensor so far seems to be a poti that outputs in Ohm */ + return -1; + case SAUL_SENSE_ID_OCCUP: + switch (data->unit) { + case UNIT_PERCENT: + switch (data->scale) { + case 0: + saul->obj_id = BTHOME_ID_OCCUPANCY_BINARY; + saul->add_measurement = &_add_50perc_to_binary_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + return -1; + case SAUL_SENSE_ID_PROXIMITY: + /* proximity sensors return in counts. Don't know how to convert */ + return -1; + case SAUL_SENSE_ID_RSSI: + return -1; + case SAUL_SENSE_ID_CHARGE: + /* none of the sensors express the charge in % as, e.g., BTHOME_ID_BATTERY */ + return -1; + case SAUL_SENSE_ID_CURRENT: + switch (data->unit) { + case UNIT_A: + switch (data->scale) { + case -6: + saul->obj_id = BTHOME_ID_CURRENT_UINT_FACTOR_0_001; + saul->add_measurement = &_add_div_1000_uint16_measurement; + return 0; + case -5: + saul->obj_id = BTHOME_ID_CURRENT_UINT_FACTOR_0_001; + saul->add_measurement = &_add_div_100_uint16_measurement; + return 0; + case -4: + saul->obj_id = BTHOME_ID_CURRENT_UINT_FACTOR_0_001; + saul->add_measurement = &_add_div_10_uint16_measurement; + return 0; + case -3: + saul->obj_id = BTHOME_ID_CURRENT_UINT_FACTOR_0_001; + saul->add_measurement = &_add_uint16_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + return -1; + case SAUL_SENSE_ID_PM: + /* Left as exercise to the reader to convert it to either + * BTHOME_ID_PM_2_5 or BTHOME_ID_PM_10 for UNIT_GPM3 */ + return -1; + case SAUL_SENSE_ID_CAPACITANCE: + return -1; + case SAUL_SENSE_ID_VOLTAGE: + switch (data->unit) { + case UNIT_V: + switch (data->scale) { + case -6: + saul->obj_id = BTHOME_ID_VOLTAGE_FACTOR_0_001; + saul->add_measurement = &_add_div_1000_uint16_measurement; + return 0; + case -3: + saul->obj_id = BTHOME_ID_VOLTAGE_FACTOR_0_001; + saul->add_measurement = &_add_uint16_measurement; + return 0; + case -1: + saul->obj_id = BTHOME_ID_VOLTAGE_FACTOR_0_1; + saul->add_measurement = &_add_uint16_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + return -1; + case SAUL_SENSE_ID_PH: + return -1; + case SAUL_SENSE_ID_POWER: + switch (data->unit) { + case UNIT_W: + switch (data->scale) { + case -6: + saul->obj_id = BTHOME_ID_POWER_UINT_FACTOR_0_01; + saul->add_measurement = &_add_div_10000_uint16_measurement; + return 0; + case -4: + saul->obj_id = BTHOME_ID_POWER_UINT_FACTOR_0_01; + saul->add_measurement = &_add_div_100_uint16_measurement; + return 0; + case -2: + saul->obj_id = BTHOME_ID_POWER_UINT_FACTOR_0_01; + saul->add_measurement = &_add_uint16_measurement; + return 0; + default: + return -1; + } + default: + return -1; + } + return -1; + case SAUL_SENSE_ID_SIZE: + return -1; + default: + return -1; + } +} + +static void _reset_hdr(skald_bthome_ctx_t *ctx) +{ + /* Skip AD type, BTHome UUID, and BTHome Device Information */ + uint8_t *data_start = ctx->svc_data_len + 5U; + ctx->skald.pkt.len = data_start - &ctx->skald.pkt.pdu[0]; + *ctx->svc_data_len = 4U; /* AD type + BTHome UUID + BTHome Device Information */ +} + +static void _update_saul_measurements(skald_ctx_t *skald_ctx) +{ + skald_bthome_ctx_t *ctx = container_of(skald_ctx, skald_bthome_ctx_t, skald); + + _reset_hdr(ctx); + skald_bthome_saul_t *ptr = ctx->devs; + while (ptr) { + int dim; + phydat_t data; + + dim = saul_reg_read(&ptr->saul, &data); + if (dim <= 0) { + continue; + } + for (uint8_t i = 0; i < dim; i++) { + if (ptr->add_measurement(ctx, ptr->obj_id, &data, i) < 0) { + break; + } + } + + ptr = container_of( + ptr->saul.next, skald_bthome_saul_t, saul + ); + } +#if IS_USED(MODULE_SKALD_BTHOME_ENCRYPT) + skald_bthome_encrypt(ctx); +#endif +} + +int skald_bthome_saul_add(skald_bthome_ctx_t *ctx, skald_bthome_saul_t *saul) +{ + int dim; + phydat_t sample; + + if ((saul->saul.driver->type & SAUL_CAT_MASK) != SAUL_CAT_SENSE) { + return -ENOTSUP; + } + + if (!ctx->skald.update_pkt) { + ctx->skald.update_pkt = &_update_saul_measurements; + } + dim = saul_reg_read(&saul->saul, &sample); + if (dim <= 0) { + return -ENODEV; + } + if (_saul_sense_to_bthome_id(saul, &sample) < 0) { + return -ENOENT; + } + if (ctx->devs) { + skald_bthome_saul_t *ptr = ctx->devs; + + if (ptr->obj_id > saul->obj_id) { + saul->saul.next = &ptr->saul; + ctx->devs = saul; + return 0; + } + while (ptr) { + skald_bthome_saul_t *next = container_of( + ptr->saul.next, skald_bthome_saul_t, saul + ); + /* insert in obj_id order */ + if (next) { + if (next->obj_id > saul->obj_id) { + saul->saul.next = &next->saul; + ptr->saul.next = &saul->saul; + break; + } + } + else { + ptr->saul.next = &saul->saul; + break; + } + ptr = next; + } + } + else { + ctx->devs = saul; + } + return 0; +} + +static int _add_50perc_to_binary_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint8_measurement(ctx, obj_id, (data->val[idx] < 50) ? 0x00 : 0x01); +} + +static int _add_button_press( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint8_measurement(ctx, obj_id, (data->val[idx]) ? 0x01 : 0x00); +} + +static int _add_int8_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_int8_measurement(ctx, obj_id, (int8_t)data->val[idx]); +} + +static int _add_uint8_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint8_measurement(ctx, obj_id, (uint8_t)data->val[idx]); +} + +static int _add_int16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_int16_measurement(ctx, obj_id, data->val[idx]); +} + +static int _add_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint16_measurement(ctx, obj_id, (uint16_t)data->val[idx]); +} + +static int _add_uint24_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint24_measurement(ctx, obj_id, (uint32_t)data->val[idx]); +} + +static int _add_g_force_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + int32_t d = data->val[idx]; + /* 1g ~= 9.807 m/s² */ + d *= 98; + d /= 10; + if (d > INT16_MAX) { + d = INT16_MAX; + } + if (d < INT16_MIN) { + d = INT16_MIN; + } + return skald_bthome_add_uint16_measurement(ctx, obj_id, (uint16_t)d); +} + +static int _add_ppb_to_ugm3_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + int32_t d = data->val[idx]; + /* see https://www.arcskoru.com/sites/default/files/Arc%20Guide%20to%20Re-Entry.pdf page 26 */ + d *= 3767; + d /= 1000; + if (d > INT16_MAX) { + d = INT16_MAX; + } + if (d < INT16_MIN) { + d = INT16_MIN; + } + return skald_bthome_add_uint16_measurement(ctx, obj_id, (uint16_t)d); +} + +static int _add_div_10_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint16_measurement(ctx, obj_id, (uint16_t)(data->val[idx] / 10)); +} + +static int _add_div_10_uint24_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint24_measurement(ctx, obj_id, (uint32_t)(data->val[idx] / 10)); +} + +static int _add_div_100_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint16_measurement(ctx, obj_id, (uint16_t)(data->val[idx] / 100)); +} + +static int _add_div_100_uint24_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint24_measurement(ctx, obj_id, (uint32_t)(data->val[idx] / 100)); +} + +static int _add_div_1000_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint16_measurement(ctx, obj_id, (uint16_t)(data->val[idx] / 1000)); +} + +static int _add_div_10000_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint16_measurement(ctx, obj_id, (uint16_t)(data->val[idx] / 10000)); +} + +static int _add_times_10_uint8_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint8_measurement(ctx, obj_id, (uint8_t)(data->val[idx] * 10)); +} + +static int _add_times_10_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint16_measurement(ctx, obj_id, (uint16_t)(data->val[idx] * 10)); +} + +static int _add_times_100_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint16_measurement(ctx, obj_id, (uint16_t)(data->val[idx] * 100)); +} + +static int _add_times_10_uint24_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint24_measurement(ctx, obj_id, (uint32_t)(data->val[idx] * 10)); +} + +static int _add_times_100_uint24_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint24_measurement(ctx, obj_id, (uint32_t)(data->val[idx] * 100)); +} + +static int _add_times_1000_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint16_measurement(ctx, obj_id, (uint16_t)(data->val[idx] * 1000)); +} + +static int _add_times_10000_uint16_measurement( + skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + return skald_bthome_add_uint16_measurement(ctx, obj_id, (uint16_t)(data->val[idx] * 1000)); +} + +/** @} */ From e616edddb603c5be11c44267683181beb884e4d2 Mon Sep 17 00:00:00 2001 From: "Martine S. Lenders" Date: Sat, 16 Nov 2024 01:18:26 +0100 Subject: [PATCH 5/8] examples/skald_bthome: update for skald_bthome_saul --- examples/skald_bthome/Makefile | 5 +++-- examples/skald_bthome/main.c | 29 +++++++++++++++++++++++++---- 2 files changed, 28 insertions(+), 6 deletions(-) diff --git a/examples/skald_bthome/Makefile b/examples/skald_bthome/Makefile index 402ce8b580ee..cf526af798fb 100644 --- a/examples/skald_bthome/Makefile +++ b/examples/skald_bthome/Makefile @@ -7,8 +7,9 @@ BOARD ?= nrf52dk # This has to be the absolute path to the RIOT base directory: RIOTBASE ?= $(CURDIR)/../.. -# include Skald -USEMODULE += skald_bthome +# include Skald using SAUL +USEMODULE += saul_default +USEMODULE += skald_bthome_saul DEVELHELP ?= 1 diff --git a/examples/skald_bthome/main.c b/examples/skald_bthome/main.c index de7873fc25ef..87e32b1c52eb 100644 --- a/examples/skald_bthome/main.c +++ b/examples/skald_bthome/main.c @@ -18,8 +18,10 @@ * @} */ +#include #include +#include "saul_reg.h" #include "ztimer.h" #include "net/skald/bthome.h" @@ -33,22 +35,41 @@ #endif static skald_bthome_ctx_t _ctx; +static skald_bthome_saul_t _saul_devs[CONFIG_BTHOME_SAUL_REG_DEVS]; int main(void) { + saul_reg_t *dev = saul_reg; + unsigned i = 0; + ztimer_sleep(ZTIMER_MSEC, 2000); printf("Skald and the tale of Harald's home\n"); + _ctx.skald.update_pkt = NULL; + _ctx.devs = NULL; + _ctx.skald.pkt.len = 0; if (skald_bthome_init(&_ctx, NULL, BTHOME_NAME, 0) < 0) { return 1; } - if (skald_bthome_add_uint24_measurement(&_ctx, BTHOME_ID_TEMPERATURE_FACTOR_0_01, 2500) < 0) { + if (!saul_reg) { + puts("Hark! The board does not know SAUL. :-("); return 1; } - if (skald_bthome_add_int16_measurement(&_ctx, BTHOME_ID_HUMIDITY_FACTOR_0_01, 5055) < 0) { - printf("H %u\n", _ctx.skald.pkt.len); - return 1; + while (dev && (i < CONFIG_BTHOME_SAUL_REG_DEVS)) { + int res; + _saul_devs[i].saul = *dev; /* copy registry entry */ + _saul_devs[i].saul.next = NULL; + printf("Adding %s (%s) to BTHome.\n", dev->name, saul_class_to_str(dev->driver->type)); + if ((res = skald_bthome_saul_add(&_ctx, &_saul_devs[i])) < 0) { + errno = -res; + perror("Unable to add sensor to BTHome"); + dev = dev->next; + continue; + }; + i++; + dev = dev->next; } + assert(!saul_reg || _ctx.devs); skald_bthome_advertise(&_ctx, BTHOME_ADV_INTERVAL); return 0; } From ce6a7e0b96bf4ffbed3b5ca22352b7fe6a02215e Mon Sep 17 00:00:00 2001 From: "Martine S. Lenders" Date: Sat, 16 Nov 2024 11:46:27 +0100 Subject: [PATCH 6/8] skald_bthome_encrypt: initial import --- examples/skald_bthome/Makefile | 6 +++ examples/skald_bthome/main.c | 56 +++++++++++++++++++++ makefiles/pseudomodules.inc.mk | 1 + sys/Makefile.dep | 5 ++ sys/include/net/skald/bthome.h | 40 ++++++++++++++- sys/net/ble/skald/Makefile | 4 ++ sys/net/ble/skald/skald_bthome.c | 86 +++++++++++++++++++++++++++++++- 7 files changed, 195 insertions(+), 3 deletions(-) diff --git a/examples/skald_bthome/Makefile b/examples/skald_bthome/Makefile index cf526af798fb..a2724fef785e 100644 --- a/examples/skald_bthome/Makefile +++ b/examples/skald_bthome/Makefile @@ -15,6 +15,12 @@ DEVELHELP ?= 1 BTHOME_NAME = "RIOT" BTHOME_ADV_INTERVAL ?= 60000 +ENCRYPTION_KEY ?= + +ifneq ($(ENCRYPTION_KEY),) + USEMODULE += skald_bthome_encrypt + CFLAGS += -DENCRYPTION_KEY="\"$(ENCRYPTION_KEY)\"" +endif CFLAGS += -DBTHOME_NAME="\"$(BTHOME_NAME)\"" CFLAGS += -DBTHOME_ADV_INTERVAL=$(BTHOME_ADV_INTERVAL) diff --git a/examples/skald_bthome/main.c b/examples/skald_bthome/main.c index 87e32b1c52eb..5b9f28ee37be 100644 --- a/examples/skald_bthome/main.c +++ b/examples/skald_bthome/main.c @@ -37,6 +37,47 @@ static skald_bthome_ctx_t _ctx; static skald_bthome_saul_t _saul_devs[CONFIG_BTHOME_SAUL_REG_DEVS]; +#ifdef ENCRYPTION_KEY +int _get_encryption_key(void) +{ + static const char enc_str[] = ENCRYPTION_KEY; + static uint8_t encryption_key[SKALD_BTHOME_KEY_LEN] = { 0 }; + size_t enc_str_len = strlen(enc_str); + uint8_t key_len = 0; + + uint8_t shift = 4; + for (unsigned i = 0; i < enc_str_len; i++) { + char c = enc_str[i]; + unsigned char offset; + + if (c >= '0' && c <= '9') { + offset = '0'; + } + else if (c >= 'a' && c <= 'f') { + offset = 'a' - 10; + } + else { + continue; + } + encryption_key[i / 2] |= (c - offset) << shift; + shift = (shift) ? 0 : 4; + key_len = (i / 2) + 1; + if (key_len > SKALD_BTHOME_KEY_LEN) { + printf("Key was too long: %u bytes\n", key_len); + return -ENOBUFS; + } + } + + if (key_len < SKALD_BTHOME_KEY_LEN) { + printf("Key was too short: %u bytes\n", key_len); + return -EINVAL; + } + memcpy(_ctx.key, encryption_key, key_len); + _ctx.encrypt = 1; + return key_len; +} +#endif + int main(void) { saul_reg_t *dev = saul_reg; @@ -45,6 +86,21 @@ int main(void) ztimer_sleep(ZTIMER_MSEC, 2000); printf("Skald and the tale of Harald's home\n"); +#ifdef ENCRYPTION_KEY + int key_len; + + key_len = _get_encryption_key(); + + if (key_len != SKALD_BTHOME_KEY_LEN) { + printf( + "Key should be of length 16 (32 chars), " + "was \"%s\" (%u chars)\n", + ENCRYPTION_KEY, + strlen(ENCRYPTION_KEY) + ); + return 1; + } +#endif _ctx.skald.update_pkt = NULL; _ctx.devs = NULL; _ctx.skald.pkt.len = 0; diff --git a/makefiles/pseudomodules.inc.mk b/makefiles/pseudomodules.inc.mk index e4d1cff6d334..73f7c068d6c5 100644 --- a/makefiles/pseudomodules.inc.mk +++ b/makefiles/pseudomodules.inc.mk @@ -594,6 +594,7 @@ PSEUDOMODULES += skald_update_pkt_cb PSEUDOMODULES += skald_ibeacon PSEUDOMODULES += skald_eddystone PSEUDOMODULES += skald_bthome +PSEUDOMODULES += skald_bthome_encrypt PSEUDOMODULES += skald_bthome_saul PSEUDOMODULES += crypto_aes_128 diff --git a/sys/Makefile.dep b/sys/Makefile.dep index 8a405f9605a1..a3ef833a3e43 100644 --- a/sys/Makefile.dep +++ b/sys/Makefile.dep @@ -581,6 +581,11 @@ ifneq (,$(filter skald,$(USEMODULE))) USEMODULE += ztimer_msec endif +ifneq (,$(filter skald_bthome_encrypt,$(USEMODULE))) + USEMODULE += cipher_modes + USEMODULE += skald_bthome +endif + ifneq (,$(filter skald_bthome_saul,$(USEMODULE))) USEMODULE += skald_bthome USEMODULE += skald_update_pkt_cb diff --git a/sys/include/net/skald/bthome.h b/sys/include/net/skald/bthome.h index 53264d37e57a..5a9ad33977e5 100644 --- a/sys/include/net/skald/bthome.h +++ b/sys/include/net/skald/bthome.h @@ -19,7 +19,9 @@ * * # Implementation state * - BTHome v2 is mostly supported - * - [Encryption](https://bthome.io/encryption/) is not supported + * - [Encryption](https://bthome.io/encryption/) is supported and the format is + * confirmed to provide the expected output, but Home Assistant does not + * accept the encryption key to decrypt the message. * - [Trigger based devices](https://bthome.io/format/#bthome-data-format) are not supported * * @@ -45,6 +47,13 @@ extern "C" { #endif +/** + * @brief Length of the BTHome encryption key + * + * @see [BTHome Encryption Reference](https://bthome.io/encryption/) + */ +#define SKALD_BTHOME_KEY_LEN 16U + /** * @brief Forward declaration of @ref skald_bthome_ctx_t. */ @@ -118,6 +127,22 @@ struct skald_bthome_ctx { */ skald_bthome_saul_t *devs; #endif +#if IS_USED(MODULE_SKALD_BTHOME_ENCRYPT) || defined(DOXYGEN) + /** + * @brief The encryption key for BTHome + * + * @see [BTHome Encryption Reference](https://bthome.io/encryption/) + */ + uint8_t key[SKALD_BTHOME_KEY_LEN]; + /** + * @brief Enable encryption with BTHome + * + * @see [BTHome Encryption Reference](https://bthome.io/encryption/) + * + * A non-zero key should be set in skald_bthome_ctx_t::key in this case. + */ + uint8_t encrypt; +#endif }; /** @@ -393,6 +418,19 @@ static inline int skald_bthome_add_int32_measurement( int skald_bthome_saul_add(skald_bthome_ctx_t *ctx, skald_bthome_saul_t *saul); #endif +#if IS_USED(MODULE_SKALD_BTHOME_ENCRYPT) || defined(DOXYGEN) +/** + * @brief Encrypt the packet in the Skald context + * + * @param[in] ctx A BTHome Skald context. Must not be NULL. + * + * @return The total size of the encrypted packet on success. + * @return -ENOBUFS, if the encrypted packet would not fit into a + * BLE advertisement. + */ +int skald_bthome_encrypt(skald_bthome_ctx_t *ctx); +#endif + /** * @brief Starts periodically advertising the BTHome advertisement * diff --git a/sys/net/ble/skald/Makefile b/sys/net/ble/skald/Makefile index 6fc4fc753b6e..14ba09c3b9c1 100644 --- a/sys/net/ble/skald/Makefile +++ b/sys/net/ble/skald/Makefile @@ -16,4 +16,8 @@ ifneq (,$(filter skald_bthome_saul,$(USEMODULE))) SRC += skald_bthome_saul.c endif +ifneq (,$(filter skald_bthome_encrypt,$(USEMODULE))) + $(shell $(COLOR_ECHO) "\n\n$(COLOR_RED)This currently does not work with Home Assistant!$(COLOR_RESET)\n\n" 1>&2) +endif + include $(RIOTBASE)/Makefile.base diff --git a/sys/net/ble/skald/skald_bthome.c b/sys/net/ble/skald/skald_bthome.c index a6c35b367332..f81269ac9b42 100644 --- a/sys/net/ble/skald/skald_bthome.c +++ b/sys/net/ble/skald/skald_bthome.c @@ -13,16 +13,20 @@ * @author Martine S. Lenders */ -#include "random.h" - #include "net/skald/bthome.h" +#if IS_USED(MODULE_SKALD_BTHOME_ENCRYPT) +#include "random.h" +#include "crypto/modes/ccm.h" +#endif + #define AD_TYPE_FLAGS 0x01 #define AD_TYPE_SVC_DATA 0x16 #define AD_TYPE_LOCAL_NAME_SHORT 0x08 #define AD_TYPE_LOCAL_NAME_COMPLETE 0x09 #define BT_HOME_DEV_INFO_MASK 0x01 +#define BT_HOME_DEV_INFO_ENCRYPT 0x01 #define BT_HOME_DEV_INFO_BTHOME_V2 (2 << 5) typedef struct __attribute__((packed)) { @@ -172,6 +176,84 @@ int skald_bthome_add_measurement( return ctx->skald.pkt.len; } +#if IS_USED(MODULE_SKALD_BTHOME_ENCRYPT) +static uint32_t _counter = 0; + +int skald_bthome_encrypt(skald_bthome_ctx_t *ctx) +{ + if (!ctx->encrypt) { + return ctx->skald.pkt.len; + } + uint8_t ciphertext[NETDEV_BLE_PDU_MAXLEN]; + cipher_t cipher = { 0 }; + uint8_t *txadd = &ctx->skald.pkt.pdu[0]; + uint8_t *dev_info = ctx->svc_data_len + 4; + uint8_t *uuid = ctx->svc_data_len + 2; + uint8_t *data = dev_info + 1; + int ciphertext_len; + uint8_t nonce[13]; + uint8_t nonce_len = 0; + /* maximum data length - counter */ + uint8_t max_len = &ctx->skald.pkt.pdu[NETDEV_BLE_PDU_MAXLEN] - data - 4; + uint8_t data_len = &ctx->skald.pkt.pdu[ctx->skald.pkt.len] - data; + + if (_counter == 0) { + _counter = random_uint32(); + } + + *dev_info |= BT_HOME_DEV_INFO_ENCRYPT; + + /* set nonce according to spec: MAC Address + UUID + BTHome dev info + counter */ + memcpy(&nonce[nonce_len], txadd, BLE_ADDR_LEN); + nonce_len += BLE_ADDR_LEN; + memcpy(&nonce[nonce_len], uuid, 2); + nonce_len += 2; + nonce[nonce_len++] = *dev_info; + nonce[nonce_len++] = (_counter >> 24) & 0xff; + nonce[nonce_len++] = (_counter >> 16) & 0xff; + nonce[nonce_len++] = (_counter >> 8) & 0xff; + nonce[nonce_len++] = _counter & 0xff; + + if (cipher_init(&cipher, CIPHER_AES, + ctx->key, SKALD_BTHOME_KEY_LEN) != CIPHER_INIT_SUCCESS) { + return -1; + } + + ciphertext_len = cipher_encrypt_ccm(&cipher, NULL, 0, 4, 2, + nonce, nonce_len, + data, data_len, + ciphertext); + + if (ciphertext_len < 0) { + return -1; + } + + if (ciphertext_len > max_len) { + return -ENOBUFS; + } + /* replace original payload with ciphertext */ + data_len = 0; + /* add ciphertext */ + memcpy(&data[data_len], ciphertext, ciphertext_len -4); + data_len += (ciphertext_len - 4); + /* add counter */ + data[data_len++] = (_counter >> 24) & 0xff; + data[data_len++] = (_counter >> 16) & 0xff; + data[data_len++] = (_counter >> 8) & 0xff; + data[data_len++] = _counter & 0xff; + /* add mic */ + memcpy(&data[data_len], &ciphertext[ciphertext_len - 4], 4); + data_len += 4; + + ctx->skald.pkt.len = (dev_info - txadd) + data_len + 1; + *ctx->svc_data_len = data_len + 4; + /* Progress counter a random step but not too big step */ + _counter += random_uint32() & 0x1f; + + return ctx->skald.pkt.len; +} +#endif + void skald_bthome_advertise(skald_bthome_ctx_t *ctx, uint32_t adv_itvl_ms) { ctx->skald.adv_itvl_ms = adv_itvl_ms; From 7d0d41a10a39559ced5d2035eedda8d7ba2726f4 Mon Sep 17 00:00:00 2001 From: "Martine S. Lenders" Date: Sat, 16 Nov 2024 18:38:22 +0100 Subject: [PATCH 7/8] skald_bthome_saul: add capability for custom SAUL entries --- examples/skald_bthome/main.c | 22 ++++++++++++++++- sys/Makefile.dep | 5 ++++ sys/include/net/skald/bthome.h | 28 ++++++++++++++++++++-- sys/net/ble/skald/skald_bthome_saul.c | 34 +++++++++++++++------------ 4 files changed, 71 insertions(+), 18 deletions(-) diff --git a/examples/skald_bthome/main.c b/examples/skald_bthome/main.c index 5b9f28ee37be..e2c48ecf28e7 100644 --- a/examples/skald_bthome/main.c +++ b/examples/skald_bthome/main.c @@ -78,10 +78,20 @@ int _get_encryption_key(void) } #endif +static int _add_text(skald_bthome_ctx_t *ctx, uint8_t obj_id, phydat_t *data, uint8_t idx) +{ + static const char info[] = "RIOT"; + + (void)data; + (void)idx; + return skald_bthome_add_measurement(ctx, obj_id, info, strlen(info)); +} + int main(void) { saul_reg_t *dev = saul_reg; unsigned i = 0; + int res; ztimer_sleep(ZTIMER_MSEC, 2000); printf("Skald and the tale of Harald's home\n"); @@ -112,7 +122,6 @@ int main(void) return 1; } while (dev && (i < CONFIG_BTHOME_SAUL_REG_DEVS)) { - int res; _saul_devs[i].saul = *dev; /* copy registry entry */ _saul_devs[i].saul.next = NULL; printf("Adding %s (%s) to BTHome.\n", dev->name, saul_class_to_str(dev->driver->type)); @@ -126,6 +135,17 @@ int main(void) dev = dev->next; } assert(!saul_reg || _ctx.devs); + if (i < CONFIG_BTHOME_SAUL_REG_DEVS) { + memset(&_saul_devs[i].saul, 0, sizeof(_saul_devs[i].saul)); + _saul_devs[i].obj_id = BTHOME_ID_TEXT; + _saul_devs[i].flags = SKALD_BTHOME_SAUL_FLAGS_CUSTOM; + _saul_devs[i].add_measurement = _add_text; + if ((res = skald_bthome_saul_add(&_ctx, &_saul_devs[i])) < 0) { + errno = -res; + perror("Unable to add text info to BTHome"); + }; + i++; + } skald_bthome_advertise(&_ctx, BTHOME_ADV_INTERVAL); return 0; } diff --git a/sys/Makefile.dep b/sys/Makefile.dep index a3ef833a3e43..138790ba53ad 100644 --- a/sys/Makefile.dep +++ b/sys/Makefile.dep @@ -592,6 +592,11 @@ ifneq (,$(filter skald_bthome_saul,$(USEMODULE))) USEMODULE += saul_reg endif +ifneq (,$(filter skald_update_pkt_cb,$(USEMODULE))) + USEMODULE += event + USEMODULE += skald +endif + ifneq (,$(filter bluetil_addr,$(USEMODULE))) USEMODULE += fmt endif diff --git a/sys/include/net/skald/bthome.h b/sys/include/net/skald/bthome.h index 5a9ad33977e5..4a4edf50d8e9 100644 --- a/sys/include/net/skald/bthome.h +++ b/sys/include/net/skald/bthome.h @@ -60,6 +60,16 @@ extern "C" { typedef struct skald_bthome_ctx skald_bthome_ctx_t; #if IS_USED(MODULE_SKALD_BTHOME_SAUL) || defined(DOXYGEN) +/** + * @brief Flags for the BTHome-SAUL-adapter + */ +typedef enum { + /** + * @brief Use custom object ID and add-measurement callback + */ + SKALD_BTHOME_SAUL_FLAGS_CUSTOM = 0x01, +} skald_bthome_saul_flags_t; + /** * @brief BTHome-SAUL-adapter */ @@ -76,9 +86,20 @@ typedef struct { * * @see skald_bthome_id_t * - * Will be filled by @ref skald_bthome_saul_add(). + * Will be filled by @ref skald_bthome_saul_add() if + * @ref SKALD_BTHOME_SAUL_FLAGS_CUSTOM is unset in + * skald_bthome_saul_t::flags. Otherwise, set to the desired + * object ID for the measurement. */ skald_bthome_id_t obj_id; + /** + * @brief Flags for the BTHome-SAUL-adapter + * + * @see skald_bthome_saul_flags_t + * + * May be set before calling @ref skald_bthome_saul_add() + */ + skald_bthome_saul_flags_t flags; /** * @brief Callback to add measurement from SAUL registry entry @@ -87,7 +108,10 @@ typedef struct { * @ref saul_reg_read() and should ultimately call * @ref skald_bthome_add_measurement() * (or one of its wrappers). * - * Will be filled by @ref skald_bthome_saul_add(). + * Will be filled by @ref skald_bthome_saul_add() if + * @ref SKALD_BTHOME_SAUL_FLAGS_CUSTOM is unset in + * skald_bthome_saul_t::flags. Otherwise, set to the desired + * object ID for the measurement. * * @param[in,out] ctx BTHome advertising context. MUST not be NULL. * @param[in] obj_id The object ID for the measurement. diff --git a/sys/net/ble/skald/skald_bthome_saul.c b/sys/net/ble/skald/skald_bthome_saul.c index 35436ecec577..7c36c855dba5 100644 --- a/sys/net/ble/skald/skald_bthome_saul.c +++ b/sys/net/ble/skald/skald_bthome_saul.c @@ -427,12 +427,14 @@ static void _update_saul_measurements(skald_ctx_t *skald_ctx) _reset_hdr(ctx); skald_bthome_saul_t *ptr = ctx->devs; while (ptr) { - int dim; - phydat_t data; + int dim = 1; + phydat_t data = { 0 }; - dim = saul_reg_read(&ptr->saul, &data); - if (dim <= 0) { - continue; + if (ptr->saul.driver) { + dim = saul_reg_read(&ptr->saul, &data); + if (dim <= 0) { + continue; + } } for (uint8_t i = 0; i < dim; i++) { if (ptr->add_measurement(ctx, ptr->obj_id, &data, i) < 0) { @@ -451,22 +453,24 @@ static void _update_saul_measurements(skald_ctx_t *skald_ctx) int skald_bthome_saul_add(skald_bthome_ctx_t *ctx, skald_bthome_saul_t *saul) { - int dim; - phydat_t sample; - - if ((saul->saul.driver->type & SAUL_CAT_MASK) != SAUL_CAT_SENSE) { + if ((saul->saul.driver != NULL) && + (saul->saul.driver->type & SAUL_CAT_MASK) != SAUL_CAT_SENSE) { return -ENOTSUP; } if (!ctx->skald.update_pkt) { ctx->skald.update_pkt = &_update_saul_measurements; } - dim = saul_reg_read(&saul->saul, &sample); - if (dim <= 0) { - return -ENODEV; - } - if (_saul_sense_to_bthome_id(saul, &sample) < 0) { - return -ENOENT; + if (!(saul->flags & SKALD_BTHOME_SAUL_FLAGS_CUSTOM)) { + phydat_t sample; + int dim = saul_reg_read(&saul->saul, &sample); + + if (dim <= 0) { + return -ENODEV; + } + if (_saul_sense_to_bthome_id(saul, &sample) < 0) { + return -ENOENT; + } } if (ctx->devs) { skald_bthome_saul_t *ptr = ctx->devs; From 5d6f27b54cbafd144eca69dd532df0c492060895 Mon Sep 17 00:00:00 2001 From: "Martine S. Lenders" Date: Wed, 20 Nov 2024 11:17:27 +0100 Subject: [PATCH 8/8] skald_bthome_saul: add message fragmentation --- sys/include/net/skald/bthome.h | 18 ++++++++++++ sys/net/ble/skald/skald_bthome.c | 5 +++- sys/net/ble/skald/skald_bthome_saul.c | 40 +++++++++++++++++++-------- 3 files changed, 51 insertions(+), 12 deletions(-) diff --git a/sys/include/net/skald/bthome.h b/sys/include/net/skald/bthome.h index 4a4edf50d8e9..249faaa02c0d 100644 --- a/sys/include/net/skald/bthome.h +++ b/sys/include/net/skald/bthome.h @@ -167,6 +167,24 @@ struct skald_bthome_ctx { */ uint8_t encrypt; #endif +#if IS_USED(MODULE_SKALD_BTHOME_SAUL) || defined(DOXYGEN) + /** + * @brief The index of the last device sent in skald_bthome_ctx_t::devs. + * + * Will be updated on each periodic advertisement to allow for fragmenting + * different measurement readings across multiple advertisements (in case all + * measurements from skald_bthome_ctx_t::devs are too large for one + * advertisement). Is initialized to 0. + * + * If a single reading is too big to fit into an advertisement, + * the skald_ctx_t::update_pkt() callback will just return (i.e. BTHome + * payload may be left empty) and skald_bthome_ctx_t::last_dev_sent will + * be reset to 0. + * This can e.g. happen with a @ref BTHOME_ID_TEXT or @ref BTHOME_ID_RAW record + * if the appended bytes are larger than a BLE advertisement. + */ + uint8_t last_dev_sent; +#endif }; /** diff --git a/sys/net/ble/skald/skald_bthome.c b/sys/net/ble/skald/skald_bthome.c index f81269ac9b42..dce28b3cdb5b 100644 --- a/sys/net/ble/skald/skald_bthome.c +++ b/sys/net/ble/skald/skald_bthome.c @@ -160,8 +160,11 @@ int skald_bthome_add_measurement( uint16_t exp_size = ctx->skald.pkt.len + sizeof(obj_id) + data_len + data_contains_length; uint8_t offset = ctx->skald.pkt.len; +#ifdef MODULE_SKALD_BTHOME_ENCRYPT + exp_size += 8; +#endif + if (exp_size >= NETDEV_BLE_PDU_MAXLEN) { - assert(exp_size < NETDEV_BLE_PDU_MAXLEN); return -EMSGSIZE; } ctx->skald.pkt.pdu[offset++] = (uint8_t)obj_id; diff --git a/sys/net/ble/skald/skald_bthome_saul.c b/sys/net/ble/skald/skald_bthome_saul.c index 7c36c855dba5..238598fb5a1b 100644 --- a/sys/net/ble/skald/skald_bthome_saul.c +++ b/sys/net/ble/skald/skald_bthome_saul.c @@ -423,32 +423,50 @@ static void _reset_hdr(skald_bthome_ctx_t *ctx) static void _update_saul_measurements(skald_ctx_t *skald_ctx) { skald_bthome_ctx_t *ctx = container_of(skald_ctx, skald_bthome_ctx_t, skald); + uint8_t dev_idx = 0; + uint8_t orig_last_dev_sent = ctx->last_dev_sent; _reset_hdr(ctx); skald_bthome_saul_t *ptr = ctx->devs; while (ptr) { - int dim = 1; - phydat_t data = { 0 }; - - if (ptr->saul.driver) { - dim = saul_reg_read(&ptr->saul, &data); - if (dim <= 0) { - continue; + if ((ctx->last_dev_sent == 0) || + (dev_idx > ctx->last_dev_sent)) { + int dim = 1; + int res = 0; + phydat_t data = { 0 }; + + if (ptr->saul.driver) { + dim = saul_reg_read(&ptr->saul, &data); + if (dim <= 0) { + continue; + } } - } - for (uint8_t i = 0; i < dim; i++) { - if (ptr->add_measurement(ctx, ptr->obj_id, &data, i) < 0) { + for (uint8_t i = 0; i < dim; i++) { + if ((res = ptr->add_measurement(ctx, ptr->obj_id, &data, i)) < 0) { + break; + } + } + if ((res == -EMSGSIZE) && (dev_idx > 0)) { + ctx->last_dev_sent = dev_idx - 1; + } + if (res < 0) { break; } } - ptr = container_of( ptr->saul.next, skald_bthome_saul_t, saul ); + dev_idx++; } #if IS_USED(MODULE_SKALD_BTHOME_ENCRYPT) skald_bthome_encrypt(ctx); #endif + if ((ptr == NULL) || + /* or value just too big */ + (orig_last_dev_sent == ctx->last_dev_sent)) { + /* reset device train */ + ctx->last_dev_sent = 0; + } } int skald_bthome_saul_add(skald_bthome_ctx_t *ctx, skald_bthome_saul_t *saul)