Compare commits

..
Author SHA1 Message Date
c6f330458a [tcp] Add TCP packet interface link (#21119)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>
2026-11-16 04:36:50 +00:00
Clyde StubbsandJ. Nick Koston dbb4ba769a [sx126x][sx127x] Packet interface links for SX126x and SX127x (#21110)
Co-authored-by: J. Nick Koston <nick@koston.org>
2026-11-16 14:19:19 +11:00
J. Nick Kostonandclydebarrow 0eb4a09935 [sx127x] Write multi-byte settings in one SPI burst (#22776)
Co-authored-by: clydebarrow <2366188+clydebarrow@users.noreply.github.com>
2026-11-16 14:16:55 +11:00
Clyde Stubbs ed9e5cff58 [sx127x] Set rx_floor in the unit test radio (#22779) 2026-11-15 20:31:44 -06:00
61 changed files with 3060 additions and 322 deletions

No files matched your search

+4
View File
@@ -651,7 +651,9 @@ esphome/components/sun_gtil2/* @Mat931
esphome/components/switch/* @esphome/core
esphome/components/switch/binary_sensor/* @ssieb
esphome/components/sx126x/* @swoboda1337
esphome/components/sx126x/packet_interface/* @clydebarrow
esphome/components/sx127x/* @swoboda1337
esphome/components/sx127x/packet_interface/* @clydebarrow
esphome/components/sy6970/* @linkedupbits
esphome/components/syslog/* @clydebarrow
esphome/components/systa_bus/* @Mat931
@@ -663,6 +665,8 @@ esphome/components/tca8418/* @zebble
esphome/components/tca9548a/* @andreashergert1984
esphome/components/tca9555/* @mobrembski
esphome/components/tcl112/* @glmnet
esphome/components/tcp/* @clydebarrow
esphome/components/tcp/packet_interface/* @clydebarrow
esphome/components/tcp_uart/* @Bascht74
esphome/components/tee501/* @Stock-M
esphome/components/teleinfo/* @0hax @FredM67
+136 -67
View File
@@ -21,38 +21,48 @@ static constexpr size_t MAX_I2C_BUFFER_SIZE = 32;
static constexpr size_t MAX_I2C_BUFFER_SIZE = 256;
#endif
// Configuration blob upload
// The BMI270 requires a firmware config blob to be written to its internal
// memory after every power-on before sensors can be used.
bool BMI270Component::load_config_file_() {
// The config port is only reachable with advanced power save off
// 1. Disable advanced power-save so the config port is accessible
if (!this->write_byte(BMI270_REG_PWR_CONF, BMI270_PWR_CONF_ADV_POWER_SAVE_OFF))
return false;
delay(1);
// 2. Prepare config load: write 0x00 to INIT_CTRL to start
if (!this->write_byte(BMI270_REG_INIT_CTRL, BMI270_INIT_CTRL_LOAD_START))
return false;
// 3. Burst-write the config in pages
const uint8_t *cfg = BMI270_CONFIG_FILE;
constexpr size_t cfg_len = sizeof(BMI270_CONFIG_FILE);
// The register byte goes first, so each burst is copied once and sent with write()
uint8_t buf[1 + MAX_I2C_BUFFER_SIZE];
buf[0] = BMI270_REG_INIT_DATA;
size_t index = 0;
while (index != cfg_len) {
// INIT_ADDR_0 takes the word address bits 0-3 and INIT_ADDR_1 bits 4-11
const uint8_t addr[2] = {static_cast<uint8_t>((index / 2) & 0x0F), static_cast<uint8_t>((index / 2) >> 4)};
if (this->write_register(BMI270_REG_INIT_ADDR_0, addr, sizeof(addr)) != i2c::ERROR_OK)
// Set the page address in INIT_ADDR registers
uint8_t addr_lsb = (uint8_t) ((index / 2) & 0x0F);
uint8_t addr_msb = (uint8_t) ((index / 2) >> 4);
if (!this->write_byte(BMI270_REG_INIT_ADDR_0, addr_lsb))
return false;
if (!this->write_byte(BMI270_REG_INIT_ADDR_0 + 1, addr_msb))
return false;
// Write a burst of up to the maximum allowed size
size_t burst = clamp_at_most(cfg_len - index, MAX_I2C_BUFFER_SIZE);
progmem_memcpy(buf + 1, BMI270_CONFIG_FILE + index, burst);
if (this->write(buf, burst + 1) != i2c::ERROR_OK)
if (this->write_register(BMI270_REG_INIT_DATA, cfg + index, burst) != i2c::ERROR_OK)
return false;
index += burst;
}
// 4. Signal end of config load
if (!this->write_byte(BMI270_REG_INIT_CTRL, BMI270_INIT_CTRL_LOAD_DONE))
return false;
delay(20); // The datasheet asks for at least 20 ms before INTERNAL_STATUS is valid
delay(20); // spec: wait ≥20 ms for init to complete
// 5. Check INTERNAL_STATUS: bit[0:3] should be 0x01 ("initialisation OK")
uint8_t status = 0;
if (!this->read_byte(BMI270_REG_INTERNAL_STATUS, &status))
return false;
@@ -63,52 +73,74 @@ bool BMI270Component::load_config_file_() {
return true;
}
// setup() ─
void BMI270Component::setup() {
MotionComponent::setup();
// 1. Verify chip ID
if (!this->check_chip_id(this, BMI270_REG_CHIP_ID, BMI270_CHIP_ID_VALUE))
return;
// 2. Soft-reset via CMD register (0x7E = 0xB6)
if (!this->setup_check(this->write_byte(BMI270_REG_CMD, BMI270_CMD_SOFT_RESET)))
return;
delay(20);
if (!this->setup_check(this->load_config_file_(), LOG_STR("Config file upload failed")))
// 4. Upload the configuration blob
if (!this->setup_check(load_config_file_(), LOG_STR("Config file upload failed")))
return;
ESP_LOGD(TAG, "Config blob uploaded ✓");
// 5. Configure accelerometer
// ACC_CONF: ODR | BWP(0x2 = normal avg4) | perf_mode(1)
uint8_t acc_conf =
(uint8_t) (accel_odr_) | (BMI270_CONF_BWP_NORMAL << BMI270_CONF_BWP_SHIFT) | BMI270_ACC_CONF_PERF_MODE;
if (!this->setup_check(this->write_byte(BMI270_REG_ACC_CONF, acc_conf)))
return;
if (!this->setup_check(this->write_byte(BMI270_REG_ACC_RANGE, (uint8_t) accel_range_)))
return;
// Normal filter bandwidth; performance mode for the accelerometer, noise and filter performance for the gyroscope
const uint8_t acc_conf =
this->accel_odr_ | (BMI270_CONF_BWP_NORMAL << BMI270_CONF_BWP_SHIFT) | BMI270_ACC_CONF_PERF_MODE;
const uint8_t gyr_conf = this->gyro_odr_ | (BMI270_CONF_BWP_NORMAL << BMI270_CONF_BWP_SHIFT) |
BMI270_GYR_CONF_NOISE_PERF | BMI270_GYR_CONF_FILTER_PERF;
if (!this->setup_check(this->write_byte(BMI270_REG_ACC_CONF, acc_conf) &&
this->write_byte(BMI270_REG_ACC_RANGE, this->accel_range_) &&
this->write_byte(BMI270_REG_GYR_CONF, gyr_conf) &&
this->write_byte(BMI270_REG_GYR_RANGE, this->gyro_range_) &&
this->write_byte(BMI270_REG_PWR_CTRL, BMI270_PWR_CTRL_IMU)))
// 6. Configure gyroscope
// GYR_CONF: ODR | BWP(0x2 = normal) | noise_perf(1) | filter_perf(1)
uint8_t gyr_conf = (uint8_t) (gyro_odr_) | (BMI270_CONF_BWP_NORMAL << BMI270_CONF_BWP_SHIFT) |
BMI270_GYR_CONF_NOISE_PERF | BMI270_GYR_CONF_FILTER_PERF;
if (!this->setup_check(this->write_byte(BMI270_REG_GYR_CONF, gyr_conf)))
return;
if (!this->setup_check(this->write_byte(BMI270_REG_GYR_RANGE, (uint8_t) gyro_range_)))
return;
// 7. Enable accelerometer, gyroscope, and temperature sensor
// PWR_CTRL bits: temp_en[3] | gyr_en[2] | acc_en[1]
if (!this->setup_check(this->write_byte(BMI270_REG_PWR_CTRL, BMI270_PWR_CTRL_IMU)))
return;
delay(5);
// Advanced power save stays off; FIFO self-wakeup on
// 8. Re-enable advanced power save (optional; keeps current low between reads)
// Disabled here for simplicity – leave in performance mode
// bit1 = fifo_self_wakeup
if (!this->setup_check(this->write_byte(BMI270_REG_PWR_CONF, BMI270_PWR_CONF_FIFO_SELF_WAKEUP)))
return;
// 9. Optionally bring up whatever is wired to the aux interface.
// This is entirely additive: it is off by default, and failure only disables
// magnetometer reporting rather than the whole component.
#ifdef USE_BMI270_BMM150
// A missing magnetometer only disables magnetometer reporting
if (this->aux_device_ == BMI270_AUX_DEVICE_BMM150) {
const LogString *failed_step = this->setup_magnetometer_();
this->magnetometer_ready_ = failed_step == nullptr;
this->magnetometer_ready_ = this->setup_magnetometer_();
if (!this->magnetometer_ready_) {
ESP_LOGW(TAG, "BMM150 magnetometer setup failed at %s; continuing without it", LOG_STR_ARG(failed_step));
ESP_LOGW(TAG, "BMM150 magnetometer setup failed; continuing without it");
}
}
#endif
ESP_LOGCONFIG(TAG, "BMI270 initialised successfully");
}
#ifdef USE_BMI270_BMM150
static_assert(BMM150_TRIM_BLOCK_LEN == BMI270_AUX_DATA_LEN, "each trim block is one aux read");
bool BMI270Component::wait_for_aux_idle_() {
static constexpr uint32_t AUX_IDLE_TIMEOUT_MS = 20;
bool BMI270Component::wait_for_aux_idle_(uint32_t timeout_ms) {
// The STATUS aux-busy bit is set while an aux transaction is in flight. Aux transaction
// duration depends on the attached device's own timing, so poll with a bounded
// timeout instead of guessing a fixed delay.
uint32_t start = millis();
while (true) {
uint8_t status = 0;
@@ -116,63 +148,98 @@ bool BMI270Component::wait_for_aux_idle_() {
return false;
if ((status & BMI270_STATUS_AUX_BUSY) == 0)
return true;
if (millis() - start >= AUX_IDLE_TIMEOUT_MS)
if (millis() - start >= timeout_ms)
return false;
delay(1);
}
}
bool BMI270Component::write_aux_register_(uint8_t reg, uint8_t value) {
return this->write_byte(BMI270_REG_AUX_WR_DATA, value) && this->write_byte(BMI270_REG_AUX_WR_ADDR, reg) &&
this->wait_for_aux_idle_();
if (!this->write_byte(BMI270_REG_AUX_WR_DATA, value))
return false;
if (!this->write_byte(BMI270_REG_AUX_WR_ADDR, reg))
return false;
return this->wait_for_aux_idle_(20);
}
bool BMI270Component::read_aux_block_(uint8_t reg, uint8_t *buf) {
return this->write_byte(BMI270_REG_AUX_RD_ADDR, reg) && this->wait_for_aux_idle_() &&
this->read_bytes(BMI270_REG_AUX_X_LSB, buf, BMI270_AUX_DATA_LEN);
if (!this->write_byte(BMI270_REG_AUX_RD_ADDR, reg))
return false;
if (!this->wait_for_aux_idle_(20))
return false;
return this->read_bytes(BMI270_REG_AUX_X_LSB, buf, BMI270_AUX_DATA_LEN);
}
// Follows the Bosch BMI270 aux-interface sequence; ends in auto-burst mode, where the BMI270 keeps
// AUX_X/Y/Z/R filled from the BMM150's data registers
const LogString *BMI270Component::setup_magnetometer_() {
if (!(this->write_byte(BMI270_REG_IF_CONF, BMI270_IF_CONF_AUX_IF_EN) &&
this->write_byte(BMI270_REG_AUX_IF_CONF, BMI270_AUX_IF_CONF_MANUAL_EN | BMI270_AUX_IF_CONF_MAN_RD_BURST_8) &&
this->write_byte(BMI270_REG_AUX_DEV_ID, this->aux_device_address_ << 1)))
return LOG_STR("aux interface");
bool BMI270Component::read_magnetometer_trim_() {
uint8_t regs[BMM150_TRIM_BLOCKS * BMM150_TRIM_BLOCK_LEN];
for (uint8_t i = 0; i < BMM150_TRIM_BLOCKS; i++) {
if (!this->read_aux_block_(BMM150_REG_TRIM_START + i * BMM150_TRIM_BLOCK_LEN, regs + i * BMM150_TRIM_BLOCK_LEN))
return false;
}
this->mag_trim_ = bmm150_parse_trim(regs);
return true;
}
bool BMI270Component::setup_magnetometer_() {
// Sequence adapted from the Bosch BMI270 aux-interface protocol: enable the secondary
// I2C master in manual mode, point it at the BMM150's address, power the BMM150 up
// and soft-reset it, verify its chip ID, read its factory trim values, put it in
// normal/30Hz mode, then switch the aux interface to auto-burst mode so BMI270 keeps
// AUX_X/Y/Z/R refreshed from the BMM150's data registers.
ESP_LOGD(TAG, "Setting up BMM150 magnetometer via BMI270 aux interface...");
if (!this->write_byte(BMI270_REG_IF_CONF, BMI270_IF_CONF_AUX_IF_EN))
return false;
if (!this->write_byte(BMI270_REG_AUX_IF_CONF, BMI270_AUX_IF_CONF_MANUAL_EN | BMI270_AUX_IF_CONF_MAN_RD_BURST_8))
return false;
if (!this->write_byte(BMI270_REG_AUX_DEV_ID, (uint8_t) (this->aux_device_address_ << 1)))
return false;
// Suspend -> sleep, then a soft reset so the BMM150 starts from a known state even if it
// stayed powered across a restart. The chip ID is only readable once the power bit is set.
if (!this->write_aux_register_(BMM150_REG_POWER_CONTROL, BMM150_CMD_POWER_ON))
return LOG_STR("power-on");
if (!this->write_aux_register_(BMM150_REG_POWER_CONTROL, BMM150_CMD_POWER_ON)) {
ESP_LOGW(TAG, "BMM150 power-on write timed out");
return false;
}
delay(BMM150_START_UP_TIME_MS);
if (!this->write_aux_register_(BMM150_REG_POWER_CONTROL, BMM150_CMD_SOFT_RESET))
return LOG_STR("soft reset");
if (!this->write_aux_register_(BMM150_REG_POWER_CONTROL, BMM150_CMD_SOFT_RESET)) {
ESP_LOGW(TAG, "BMM150 soft-reset write timed out");
return false;
}
delay(BMM150_SOFT_RESET_TIME_MS);
uint8_t chip_id[BMI270_AUX_DATA_LEN];
if (!this->read_aux_block_(BMM150_REG_CHIP_ID, chip_id))
return LOG_STR("chip ID read");
if (!this->read_aux_block_(BMM150_REG_CHIP_ID, chip_id)) {
ESP_LOGW(TAG, "BMM150 chip-ID read failed");
return false;
}
if (chip_id[0] != BMM150_CHIP_ID_VALUE) {
ESP_LOGW(TAG, "BMM150 chip ID 0x%02X, expected 0x%02X", chip_id[0], BMM150_CHIP_ID_VALUE);
return LOG_STR("chip ID check");
ESP_LOGW(TAG, "BMM150 not detected (chip ID 0x%02X, expected 0x%02X)", chip_id[0], BMM150_CHIP_ID_VALUE);
return false;
}
uint8_t trim[BMM150_TRIM_BLOCKS * BMM150_TRIM_BLOCK_LEN];
for (uint8_t i = 0; i < BMM150_TRIM_BLOCKS; i++) {
if (!this->read_aux_block_(BMM150_REG_TRIM_START + i * BMM150_TRIM_BLOCK_LEN, trim + i * BMM150_TRIM_BLOCK_LEN))
return LOG_STR("trim read");
if (!this->read_magnetometer_trim_()) {
ESP_LOGW(TAG, "BMM150 trim data read failed");
return false;
}
this->mag_trim_ = bmm150_parse_trim(trim);
if (!this->write_aux_register_(BMM150_REG_OP_MODE, BMM150_CMD_NORMAL_MODE_ODR_30HZ))
return LOG_STR("normal mode");
if (!this->write_aux_register_(BMM150_REG_OP_MODE, BMM150_CMD_NORMAL_MODE_ODR_30HZ)) {
ESP_LOGW(TAG, "BMM150 mode write timed out");
return false;
}
if (!(this->write_byte(BMI270_REG_AUX_IF_CONF, BMI270_AUX_IF_CONF_FCU_WRITE_EN | BMI270_AUX_IF_CONF_MAN_RD_BURST_8 |
BMI270_AUX_IF_CONF_RD_BURST_8) &&
this->write_byte(BMI270_REG_AUX_RD_ADDR, BMM150_REG_DATA_X_LSB) &&
this->write_byte(BMI270_REG_PWR_CTRL, BMI270_PWR_CTRL_IMU | BMI270_PWR_CTRL_AUX_EN)))
return LOG_STR("auto-burst mode");
return nullptr;
// Switch to auto-burst mode: BMI270 will keep polling 8 bytes from the BMM150's
// data registers (0x42) into its own AUX_X/Y/Z/R registers automatically.
if (!this->write_byte(BMI270_REG_AUX_IF_CONF, BMI270_AUX_IF_CONF_FCU_WRITE_EN | BMI270_AUX_IF_CONF_MAN_RD_BURST_8 |
BMI270_AUX_IF_CONF_RD_BURST_8))
return false;
if (!this->write_byte(BMI270_REG_AUX_RD_ADDR, BMM150_REG_DATA_X_LSB))
return false;
if (!this->write_byte(BMI270_REG_PWR_CTRL, BMI270_PWR_CTRL_IMU | BMI270_PWR_CTRL_AUX_EN))
return false;
ESP_LOGD(TAG, "BMM150 magnetometer ready");
return true;
}
#endif // USE_BMI270_BMM150
@@ -182,10 +249,9 @@ void BMI270Component::dump_config() {
if (this->is_failed())
return;
ESP_LOGCONFIG(TAG,
" Accel range : %s\n"
" Gyro range : %s",
LOG_STR_ARG(AccelRangeStrings::get_log_str(this->accel_range_, AccelRangeStrings::LAST_INDEX)),
ESP_LOGCONFIG(TAG, " Accel range : %s",
LOG_STR_ARG(AccelRangeStrings::get_log_str(this->accel_range_, AccelRangeStrings::LAST_INDEX)));
ESP_LOGCONFIG(TAG, " Gyro range : %s",
LOG_STR_ARG(GyroRangeStrings::get_log_str(this->gyro_range_, GyroRangeStrings::LAST_INDEX)));
#ifdef USE_BMI270_BMM150
if (this->aux_device_ == BMI270_AUX_DEVICE_BMM150) {
@@ -196,6 +262,9 @@ void BMI270Component::dump_config() {
MotionComponent::dump_config();
}
// update() ─
// Reads all 6 axes + temperature in one block
bool BMI270Component::update_data(motion::MotionData &data) {
if (this->is_failed())
return false;
+24 -8
View File
@@ -12,15 +12,18 @@
namespace esphome::bmi270 {
// Register map
static constexpr uint8_t BMI270_REG_CHIP_ID = 0x00;
static constexpr uint8_t BMI270_REG_ERR_REG = 0x02;
static constexpr uint8_t BMI270_REG_STATUS = 0x03;
static constexpr uint8_t BMI270_REG_DATA_8 = 0x0C; // ACC_X LSB
static constexpr uint8_t BMI270_REG_DATA_14 = 0x12; // GYR_X LSB
static constexpr uint8_t BMI270_REG_TEMP_0 = 0x22;
static constexpr uint8_t BMI270_REG_TEMP_MSB = 0x23;
static constexpr uint8_t BMI270_REG_TEMP_MSB = 0x23; // temperature (2 bytes big-endian ish)
// Accel, gyro, 10 unused bytes, then temperature: 0x0C to 0x23
static constexpr uint8_t REG_READ_LEN = BMI270_REG_TEMP_MSB - BMI270_REG_DATA_8 + 1;
static constexpr uint8_t REG_READ_LEN =
BMI270_REG_TEMP_MSB - BMI270_REG_DATA_8 +
1; // 0x23 - 0x0C + 1 = 0x18 bytes total for accel(6) + gyro(6) + temp(2) + padding(4)
static constexpr uint8_t BMI270_REG_PWR_CONF = 0x7C;
static constexpr uint8_t BMI270_REG_PWR_CTRL = 0x7D;
@@ -77,6 +80,7 @@ static constexpr uint8_t BMI270_AUX_IF_CONF_RD_BURST_8 = 0x03; // bits 1:0
static constexpr uint8_t BMI270_AUX_DATA_LEN = 8;
static_assert(BMI270_REG_AUX_X_LSB + BMI270_AUX_DATA_LEN == BMI270_REG_DATA_8, "aux data must precede accel data");
// Accelerometer range options
enum BMI270AccelRange : uint8_t {
BMI270_ACCEL_RANGE_2G = 0x00,
BMI270_ACCEL_RANGE_4G = 0x01,
@@ -84,6 +88,7 @@ enum BMI270AccelRange : uint8_t {
BMI270_ACCEL_RANGE_16G = 0x03,
};
// Accelerometer ODR options
enum BMI270AccelODR : uint8_t {
BMI270_ACCEL_ODR_12_5 = 0x05,
BMI270_ACCEL_ODR_25 = 0x06,
@@ -95,6 +100,7 @@ enum BMI270AccelODR : uint8_t {
BMI270_ACCEL_ODR_1600 = 0x0C,
};
// Gyroscope range options
enum BMI270GyroRange : uint8_t {
BMI270_GYRO_RANGE_2000 = 0x00,
BMI270_GYRO_RANGE_1000 = 0x01,
@@ -103,6 +109,7 @@ enum BMI270GyroRange : uint8_t {
BMI270_GYRO_RANGE_125 = 0x04,
};
// Gyroscope ODR options
enum BMI270GyroODR : uint8_t {
BMI270_GYRO_ODR_25 = 0x06,
BMI270_GYRO_ODR_50 = 0x07,
@@ -123,11 +130,14 @@ enum BMI270AuxDevice : uint8_t {
};
#endif
// Main component class
class BMI270Component final : public motion::MotionComponent, public i2c::I2CDevice {
public:
// Lifecycle
void setup() override;
void dump_config() override;
// Configuration setters
void set_accel_range(BMI270AccelRange r) { this->accel_range_ = r; }
void set_accel_odr(BMI270AccelODR o) { this->accel_odr_ = o; }
void set_gyro_range(BMI270GyroRange r) { this->gyro_range_ = r; }
@@ -143,15 +153,21 @@ class BMI270Component final : public motion::MotionComponent, public i2c::I2CDev
bool update_data(motion::MotionData &data) override;
bool load_config_file_();
#ifdef USE_BMI270_BMM150
// Returns the step that failed, or nullptr once the BMM150 is running
const LogString *setup_magnetometer_();
// Polls the aux busy bit, as the aux transaction time depends on the attached device
bool wait_for_aux_idle_();
// Manual-mode aux read of 8 bytes starting at `reg` on the aux device
// Brings up the BMM150 over the BMI270's aux interface. Optional: on failure this only
// disables magnetometer reporting, it does not fail the whole component (accel/gyro still work).
bool setup_magnetometer_();
// Blocking poll of the aux-transaction-busy bit; aux transaction time depends on the
// attached device, so this is bounded by retries/timeout rather than a fixed delay.
bool wait_for_aux_idle_(uint32_t timeout_ms);
// Manual-mode aux read of 8 bytes starting at `reg` on the aux device.
bool read_aux_block_(uint8_t reg, uint8_t *buf);
// Manual-mode aux write of one byte to `reg` on the aux device.
bool write_aux_register_(uint8_t reg, uint8_t value);
// Reads the BMM150 factory trim values used to compensate its samples.
bool read_magnetometer_trim_();
#endif
// Config
BMI270AccelRange accel_range_{BMI270_ACCEL_RANGE_4G};
BMI270AccelODR accel_odr_{BMI270_ACCEL_ODR_100};
BMI270GyroRange gyro_range_{BMI270_GYRO_RANGE_2000};
+1 -2
View File
@@ -1,6 +1,5 @@
#pragma once
#include <cstdint>
#include "esphome/core/hal.h"
namespace esphome::bmi270 {
@@ -45,7 +44,7 @@ POSSIBILITY OF SUCH DAMAGE.
after every power cycle, before any sensor data can be read.
--------------------------------------------------------------------------- */
static constexpr uint8_t BMI270_CONFIG_FILE[] PROGMEM = {
static constexpr uint8_t BMI270_CONFIG_FILE[] = {
0xc8, 0x2e, 0x00, 0x2e, 0x80, 0x2e, 0x3d, 0xb1, 0xc8, 0x2e, 0x00, 0x2e, 0x80, 0x2e, 0x91, 0x03, 0x80, 0x2e, 0xbc,
0xb0, 0x80, 0x2e, 0xa3, 0x03, 0xc8, 0x2e, 0x00, 0x2e, 0x80, 0x2e, 0x00, 0xb0, 0x50, 0x30, 0x21, 0x2e, 0x59, 0xf5,
0x10, 0x30, 0x21, 0x2e, 0x6a, 0xf5, 0x80, 0x2e, 0x3b, 0x03, 0x00, 0x00, 0x00, 0x00, 0x08, 0x19, 0x01, 0x00, 0x22,
+16 -16
View File
@@ -3,8 +3,11 @@
#include <cstdint>
#include "esphome/core/helpers.h"
// BMM150 magnetometer behind the BMI270's aux interface; it is not on the main I2C bus, so it is not
// its own component
// BMM150 magnetometer definitions - the chip that can optionally be wired to the BMI270's
// auxiliary (secondary I2C master) interface. Lives in its own header/namespace because this
// is BMM150-specific driver knowledge, not BMI270 knowledge - it just can't be a standalone
// ESPHome component, since the BMM150 has no address of its own on the main I2C bus and is only
// reachable by having the BMI270 proxy register reads/writes through its aux interface.
namespace esphome::bmi270::bmm150 {
static constexpr uint8_t BMM150_DEFAULT_I2C_ADDRESS = 0x10;
@@ -61,23 +64,20 @@ inline uint16_t bmm150_trim_word(const uint8_t *regs, uint8_t reg) {
return encode_value_le<uint16_t>(&regs[offset]);
}
// A trim byte, addressed by its register
inline uint8_t bmm150_trim_byte(const uint8_t *regs, uint8_t reg) { return regs[reg - BMM150_REG_TRIM_START]; }
// Decodes the trim registers; `regs` holds the bytes of registers 0x5D onwards (at least 21).
inline BMM150Trim bmm150_parse_trim(const uint8_t *regs) {
BMM150Trim trim;
trim.x1 = static_cast<int8_t>(bmm150_trim_byte(regs, BMM150_TRIM_X1));
trim.y1 = static_cast<int8_t>(bmm150_trim_byte(regs, BMM150_TRIM_Y1));
trim.x1 = static_cast<int8_t>(regs[BMM150_TRIM_X1 - BMM150_REG_TRIM_START]);
trim.y1 = static_cast<int8_t>(regs[BMM150_TRIM_Y1 - BMM150_REG_TRIM_START]);
trim.z4 = static_cast<int16_t>(bmm150_trim_word(regs, BMM150_TRIM_Z4));
trim.x2 = static_cast<int8_t>(bmm150_trim_byte(regs, BMM150_TRIM_X2));
trim.y2 = static_cast<int8_t>(bmm150_trim_byte(regs, BMM150_TRIM_Y2));
trim.x2 = static_cast<int8_t>(regs[BMM150_TRIM_X2 - BMM150_REG_TRIM_START]);
trim.y2 = static_cast<int8_t>(regs[BMM150_TRIM_Y2 - BMM150_REG_TRIM_START]);
trim.z2 = static_cast<int16_t>(bmm150_trim_word(regs, BMM150_TRIM_Z2));
trim.z1 = bmm150_trim_word(regs, BMM150_TRIM_Z1);
trim.xyz1 = bmm150_trim_word(regs, BMM150_TRIM_XYZ1) & BMM150_TRIM_XYZ1_MASK;
trim.z3 = static_cast<int16_t>(bmm150_trim_word(regs, BMM150_TRIM_Z3));
trim.xy2 = static_cast<int8_t>(bmm150_trim_byte(regs, BMM150_TRIM_XY2));
trim.xy1 = bmm150_trim_byte(regs, BMM150_TRIM_XY1);
trim.xy2 = static_cast<int8_t>(regs[BMM150_TRIM_XY2 - BMM150_REG_TRIM_START]);
trim.xy1 = regs[BMM150_TRIM_XY1 - BMM150_REG_TRIM_START];
return trim;
}
@@ -108,11 +108,11 @@ inline float bmm150_compensate_z(const BMM150Trim &trim, int16_t raw, uint16_t r
// Converts 8 raw bytes from the BMM150 data registers (X, Y, Z, RHALL; 0x42-0x49) to compensated µT.
inline BMM150Data bmm150_convert(const BMM150Trim &trim, const uint8_t *raw) {
// Left-aligned in their 16-bit words: X/Y are 13-bit, Z is 15-bit, RHALL is 14-bit
const int16_t x = encode_value_le<int16_t>(&raw[0]) >> 3;
const int16_t y = encode_value_le<int16_t>(&raw[2]) >> 3;
const int16_t z = encode_value_le<int16_t>(&raw[4]) >> 1;
const uint16_t rhall = encode_value_le<uint16_t>(&raw[6]) >> 2;
// X/Y are 13-bit (LSB byte bits 7:3), Z is 15-bit (bits 7:1), RHALL is 14-bit (bits 7:2).
int16_t x = (int16_t) (((int16_t) (int8_t) raw[1] * 32) | (raw[0] >> 3));
int16_t y = (int16_t) (((int16_t) (int8_t) raw[3] * 32) | (raw[2] >> 3));
int16_t z = (int16_t) (((int16_t) (int8_t) raw[5] * 128) | (raw[4] >> 1));
uint16_t rhall = (uint16_t) (((uint16_t) raw[7] << 6) | (raw[6] >> 2));
return BMM150Data{
.x = bmm150_compensate_xy(trim, trim.x1, trim.x2, x, rhall),
.y = bmm150_compensate_xy(trim, trim.y1, trim.y2, y, rhall),
+21 -28
View File
@@ -17,14 +17,6 @@ DEPENDENCIES = ["i2c"]
CONF_AUX_ADDRESS = "aux_address"
CONF_AUX_DEVICE = "aux_device"
# to_code skips the setters at these values, so each must match its member default in bmi270.h
DEFAULT_ACCELEROMETER_RANGE = "4G"
DEFAULT_ACCELEROMETER_ODR = "100HZ"
DEFAULT_GYROSCOPE_RANGE = "2000DPS"
DEFAULT_GYROSCOPE_ODR = "200HZ"
# The BMM150's fixed address
DEFAULT_AUX_ADDRESS = 0x10
# Enum proxies (must match the C++ enum values exactly)
BMI270AuxDevice = bmi270_ns.enum("BMI270AuxDevice")
BMI270AccelRange = bmi270_ns.enum("BMI270AccelRange")
@@ -65,49 +57,50 @@ GYRO_ODR_OPTIONS = {
"3200HZ": BMI270GyroODR.BMI270_GYRO_ODR_3200,
}
# Top-level CONFIG_SCHEMA
CONFIG_SCHEMA = (
motion_schema(BMI270Component, has_accel=True, has_gyro=True)
.extend(
{
cv.Optional(
CONF_ACCELEROMETER_RANGE, default=DEFAULT_ACCELEROMETER_RANGE
): cv.enum(ACCEL_RANGE_OPTIONS, upper=True),
cv.Optional(
CONF_ACCELEROMETER_ODR, default=DEFAULT_ACCELEROMETER_ODR
): cv.enum(ACCEL_ODR_OPTIONS, upper=True),
cv.Optional(CONF_GYROSCOPE_RANGE, default=DEFAULT_GYROSCOPE_RANGE): cv.enum(
cv.Optional(CONF_ACCELEROMETER_RANGE, default="4G"): cv.enum(
ACCEL_RANGE_OPTIONS, upper=True
),
cv.Optional(CONF_ACCELEROMETER_ODR, default="100HZ"): cv.enum(
ACCEL_ODR_OPTIONS, upper=True
),
cv.Optional(CONF_GYROSCOPE_RANGE, default="2000DPS"): cv.enum(
GYRO_RANGE_OPTIONS, upper=True
),
cv.Optional(CONF_GYROSCOPE_ODR, default=DEFAULT_GYROSCOPE_ODR): cv.enum(
cv.Optional(CONF_GYROSCOPE_ODR, default="200HZ"): cv.enum(
GYRO_ODR_OPTIONS, upper=True
),
# Optional device wired to the BMI270's aux interface (not the main I2C bus).
# Defaults to NONE so existing configs/boards are unaffected.
cv.Optional(CONF_AUX_DEVICE, default="NONE"): cv.one_of(
"NONE", "BMM150", upper=True
),
cv.Optional(CONF_AUX_ADDRESS, default=DEFAULT_AUX_ADDRESS): cv.i2c_address,
# Default matches the BMM150's fixed I2C address; irrelevant when aux_device is NONE.
cv.Optional(CONF_AUX_ADDRESS, default=0x10): cv.i2c_address,
}
)
.extend(i2c.i2c_device_schema(0x68))
)
# Code generation
async def to_code(config: ConfigType) -> None:
var = await new_motion_component(config)
await i2c.register_i2c_device(var, config)
# The C++ members already hold the schema defaults
for key, default, setter in (
(CONF_ACCELEROMETER_RANGE, DEFAULT_ACCELEROMETER_RANGE, var.set_accel_range),
(CONF_ACCELEROMETER_ODR, DEFAULT_ACCELEROMETER_ODR, var.set_accel_odr),
(CONF_GYROSCOPE_RANGE, DEFAULT_GYROSCOPE_RANGE, var.set_gyro_range),
(CONF_GYROSCOPE_ODR, DEFAULT_GYROSCOPE_ODR, var.set_gyro_odr),
):
if config[key] != default:
cg.add(setter(config[key]))
# Accelerometer sensors
# Hardware configuration
cg.add(var.set_accel_range(config[CONF_ACCELEROMETER_RANGE]))
cg.add(var.set_accel_odr(config[CONF_ACCELEROMETER_ODR]))
cg.add(var.set_gyro_range(config[CONF_GYROSCOPE_RANGE]))
cg.add(var.set_gyro_odr(config[CONF_GYROSCOPE_ODR]))
# The aux interface code only compiles when some instance has a BMM150; the
# instance still records its own device, as another one may have none
if config[CONF_AUX_DEVICE] == "BMM150":
cg.add_define("USE_BMI270_BMM150")
cg.add(var.set_aux_device(BMI270AuxDevice.BMI270_AUX_DEVICE_BMM150))
if (address := config[CONF_AUX_ADDRESS]) != DEFAULT_AUX_ADDRESS:
cg.add(var.set_aux_device_address(address))
cg.add(var.set_aux_device_address(config[CONF_AUX_ADDRESS]))
@@ -10,7 +10,7 @@ from esphome.components.const import CONF_PROVIDER, CONF_REMOTE_ID
from esphome.components.packet_interface import (
CONF_PACKET_INTERFACE,
final_validate_interface,
interface_layers,
interface_has_layer,
interface_packet_size,
)
from esphome.components.packet_interface.layers import CONF_SESSION
@@ -103,11 +103,13 @@ CONFIG_SCHEMA = cv.Schema(
def _final_validate(config: ConfigType) -> ConfigType:
"""With a session layer, which clears the states when the peer is lost, nothing would refresh an unchanged state."""
layers = interface_layers(config[CONF_PACKET_INTERFACE])
if CONF_TIMEOUT in config and CONF_SESSION in layers:
if CONF_TIMEOUT in config and interface_has_layer(
config[CONF_PACKET_INTERFACE], CONF_SESSION
):
raise cv.Invalid(
f"Not allowed with a '{CONF_SESSION}' layer, which already clears the states when the other device "
"cannot be reached; unchanged states may never be sent again, so they would time out on a working link",
f"Not allowed with a '{CONF_SESSION}' layer, or a link that does its job, which already clears the "
"states when the other device cannot be reached; unchanged states may never be sent again, so they "
"would time out on a working link",
path=[CONF_TIMEOUT],
)
return config
+79 -15
View File
@@ -1,4 +1,4 @@
from collections.abc import Callable
from collections.abc import Callable, Iterator
import importlib
import pkgutil
from typing import Any
@@ -6,7 +6,7 @@ from typing import Any
import esphome.codegen as cg
from esphome.components.const import CONF_MAX_PACKET_SIZE
import esphome.config_validation as cv
from esphome.const import CONF_ID
from esphome.const import CONF_ID, CONF_TIMEOUT
from esphome.core import CORE, ID
from esphome.cpp_generator import MockObj, MockObjClass
import esphome.final_validate as fv
@@ -19,16 +19,20 @@ from .layers import (
CONF_ADDRESSING,
CONF_DESTINATION,
CONF_PEERS,
CONF_RELIABILITY,
CONF_SESSION,
STACK_ORDER,
PacketInterface,
build_stack,
check_packet_sizes,
check_session,
check_single_peer,
layer_needing_session,
packet_interface_ns,
stack_auto_load,
stack_schema,
)
from .layers.hdlc_reliability import DEFAULT_TIMEOUT, check_ack_delay
CODEOWNERS = ["@clydebarrow"]
DOMAIN = "packet_interface"
@@ -40,6 +44,9 @@ CONF_PACKET_INTERFACE = "packet_interface"
for module_info in pkgutil.iter_modules(layers.__path__):
importlib.import_module(f".layers.{module_info.name}", package=__package__)
# The layer keys that each link class does itself, by class name
_PROVIDED_LAYERS: dict[str, tuple[str, ...]] = {}
LINK_LAYER_SCHEMAS = {
cv.Optional(CONF_ADDRESSING): ADDRESSING.schema(),
**stack_schema(),
@@ -48,6 +55,7 @@ LINK_LAYER_SCHEMAS = {
__all__ = [
"CONF_MAX_PACKET_SIZE",
"CONF_PACKET_INTERFACE",
"interface_has_layer",
"interface_layers",
"interface_packet_size",
"PacketInterface",
@@ -142,6 +150,14 @@ def interface_packet_size(interface_id: ID) -> int:
return check_packet_sizes(layers_config, size)
def interface_has_layer(interface_id: ID, key: str) -> bool:
"""During final validation, whether the packet interface with this id has the layer, configured or done by its link."""
link, layers_config = _find_interface(interface_id, fv.full_config.get())
return key in layers_config or key in _PROVIDED_LAYERS.get(
str(link[CONF_ID].type), ()
)
def final_validate_interface(key: str) -> Callable[[ConfigType], ConfigType]:
"""Final validation for an application: a link with peers must be used through one of the peers."""
@@ -158,25 +174,73 @@ def final_validate_interface(key: str) -> Callable[[ConfigType], ConfigType]:
return validator
def _check_provided_session(config: ConfigType) -> ConfigType:
"""A link's own session does not send packets through the layers, so none can need them from the peer."""
if key := layer_needing_session(config):
raise cv.Invalid(
f"This '{key}' needs packets from the peer, which this link does not send through its layers, "
"so it cannot be used on this link",
path=[key],
)
return config
def reliability_layers(config: ConfigType) -> Iterator[tuple[list, ConfigType]]:
"""The reliability layers on a link and in its peers, each with its path in the link's configuration."""
if (layer := config.get(CONF_RELIABILITY)) is not None:
yield [CONF_RELIABILITY], layer
for index, peer in enumerate(config.get(CONF_ADDRESSING, {}).get(CONF_PEERS, [])):
if (layer := peer.get(CONF_RELIABILITY)) is not None:
yield [CONF_ADDRESSING, CONF_PEERS, index, CONF_RELIABILITY], layer
def _check_default_ack_delays(config: ConfigType) -> ConfigType:
"""A reliability layer without a timeout uses the default one on this link."""
for path, layer in reliability_layers(config):
if CONF_TIMEOUT not in layer:
try:
check_ack_delay(layer, DEFAULT_TIMEOUT)
except cv.Invalid as err:
err.prepend(path)
raise
return config
def packet_interface_schema(
class_: MockObjClass,
default_max_packet_size: int,
max_packet_size_limit: int = 4096,
provides: tuple[str, ...] = (),
chooses_reliability_timeout: bool = False,
) -> cv.Schema:
"""Schema for a link platform, with the layers that can be stacked on it."""
return (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(class_),
cv.Optional(
CONF_MAX_PACKET_SIZE, default=default_max_packet_size
): cv.int_range(16, max_packet_size_limit),
**LINK_LAYER_SCHEMAS,
}
"""Schema for a link platform; provides names the layer keys, such as reliability, that the link does itself.
chooses_reliability_timeout is for a link that works out a reliability timeout of its own, when none is set.
"""
if provides:
_PROVIDED_LAYERS[str(class_)] = provides
link_layers = {
key: (
cv.invalid(f"This link provides '{key}' itself, so it cannot be configured")
if key in provides
else schema
)
.extend(cv.COMPONENT_SCHEMA)
.add_extra(_validate_layers)
)
for key, schema in LINK_LAYER_SCHEMAS.items()
}
schema = cv.Schema(
{
cv.GenerateID(): cv.declare_id(class_),
cv.Optional(
CONF_MAX_PACKET_SIZE, default=default_max_packet_size
): cv.int_range(16, max_packet_size_limit),
**link_layers,
}
).extend(cv.COMPONENT_SCHEMA)
if CONF_SESSION in provides:
schema = schema.add_extra(_check_provided_session)
if not chooses_reliability_timeout:
schema = schema.add_extra(_check_default_ack_delays)
return schema.add_extra(_validate_layers)
async def new_packet_interface(config: ConfigType, *args: Any) -> MockObj:
@@ -88,8 +88,12 @@ bool BasicFragmentation::send_(const PacketBuffer &data, const PacketMetaData &m
header[1] = index | (index + 1 == fragments ? LAST_FRAGMENT : 0);
PacketBuffer body(this->tx_buffer_, length);
if (!this->lower_->send_to_interface(PacketBuffer(header, HEADER_SIZE, &body, nullptr, 0), meta_data)) {
// The peer drops the part already sent when the next packet starts
ESP_LOGV(TAG, "%s: Fragment %zu of %zu not accepted", this->name_, index, fragments);
if (index == 0) {
ESP_LOGV(TAG, "%s: Fragment 0 of %zu not accepted", this->name_, fragments);
} else {
// The peer drops the part already sent when the next packet starts
ESP_LOGW(TAG, "%s: Packet cut short, fragment %zu of %zu not accepted", this->name_, index, fragments);
}
return false;
}
}
@@ -161,7 +161,7 @@ bool HdlcReliability::send_supervisory_(uint8_t type) {
// components run between frames: on a radio, sending blocks, and the peer's frames are received in between. If the
// lower layer refuses the frame, it is sent again shortly.
bool HdlcReliability::send_pending_() {
if (this->vn_ == this->vs_)
if (this->vn_ == this->vs_ || (this->resend_held_ && this->vn_ != this->va_))
return true;
uint8_t control = (this->vn_ << 1) | (this->vr_ << 5);
if (!this->send_frame_(control, this->slot_(this->vn_), this->tx_lengths_[this->slot_index_(this->vn_)])) {
@@ -178,6 +178,15 @@ bool HdlcReliability::send_pending_() {
}
void HdlcReliability::resend_outstanding_() {
this->resend_held_ = false;
this->vn_ = this->va_;
this->send_pending_();
}
// Resending the whole queue after every timeout lets two peers whose acknowledgements were lost keep sending long
// bursts that collide again. The peer answers the oldest frame with its N(R), which also covers frames it already has.
void HdlcReliability::resend_oldest_() {
this->resend_held_ = true;
this->vn_ = this->va_;
this->send_pending_();
}
@@ -213,8 +222,8 @@ void HdlcReliability::on_timeout_() {
return;
}
this->retries_++;
ESP_LOGV(TAG, "%s: Timeout, resending %u frames", this->name_, this->outstanding_());
this->resend_outstanding_();
ESP_LOGV(TAG, "%s: Timeout, resending frame %u, %u unacknowledged", this->name_, this->va_, this->outstanding_());
this->resend_oldest_();
this->start_timer_();
}
@@ -228,6 +237,7 @@ void HdlcReliability::start_reset_() {
this->vr_ = 0;
this->retries_ = 0;
this->rej_sent_ = false;
this->resend_held_ = false;
this->ack_sent_();
this->cancel_timeout(RETRANSMIT_TIMER_ID);
this->request_loop_();
@@ -262,6 +272,11 @@ void HdlcReliability::process_ack_(uint8_t nr) {
this->head_ = (this->head_ + acked) % this->max_queue_length_;
this->va_ = nr;
this->retries_ = 0;
if (this->resend_held_) {
this->resend_held_ = false;
if (this->vn_ != this->vs_)
this->request_loop_();
}
if (this->outstanding_() == 0) {
this->cancel_timeout(RETRANSMIT_TIMER_ID);
} else {
@@ -17,7 +17,8 @@ namespace esphome::packet_interface {
* - SABM resets both peers' sequence numbers, and UA answers it.
*
* Each frame is the HDLC control byte, the payload, then a CRC-16 of both in little endian order.
* Unacknowledged frames are resent after the timeout; after max_retries the link is reset.
* After the timeout the oldest unacknowledged frame is resent, and the rest follow once the peer answers it, so
* a lost acknowledgement costs one frame of airtime. After max_retries the link is reset.
*/
class HdlcReliability : public PacketInterface {
public:
@@ -63,6 +64,7 @@ class HdlcReliability : public PacketInterface {
bool send_supervisory_(uint8_t type);
bool send_pending_();
void resend_outstanding_();
void resend_oldest_();
void retry_send_();
/// An RR is owed: at once, or after the ack delay unless an I-frame carries it first.
void owe_ack_(bool now);
@@ -96,6 +98,7 @@ class HdlcReliability : public PacketInterface {
bool ack_pending_ : 1 {false}; // an RR is owed
bool ack_due_ : 1 {false}; // and should be sent now
bool rej_sent_ : 1 {false};
bool resend_held_ : 1 {false}; // only the oldest frame is resent until the peer acknowledges something
bool peer_frame_seen_ : 1 {false}; // a numbered frame has arrived since the link came up
bool oversize_warned_ : 1 {false};
bool reset_wait_logged_ : 1 {false}; // the queue filled while waiting for this reset to be answered
@@ -176,19 +176,24 @@ def stack_schema() -> dict:
return {cv.Optional(kind.key): kind.schema() for kind in STACK_ORDER}
def check_session(config: ConfigType) -> None:
"""Layers that need packets back from the peer need a session layer, whose keep-alives send them."""
if CONF_SESSION in config:
return
def layer_needing_session(config: ConfigType) -> str | None:
"""The key of the first layer in this stack that needs packets back from the peer, if any."""
for kind in STACK_ORDER:
if (layer := config.get(kind.key)) is not None and kind.get_type(
layer
).needs_session(layer):
raise cv.Invalid(
f"This '{kind.key}' needs packets from the peer, so it needs a '{CONF_SESSION}' layer, whose "
"keep-alives make sure they are sent",
path=[kind.key],
)
return kind.key
return None
def check_session(config: ConfigType) -> None:
"""Layers that need packets back from the peer need a session layer, whose keep-alives send them."""
if CONF_SESSION not in config and (key := layer_needing_session(config)):
raise cv.Invalid(
f"This '{key}' needs packets from the peer, so it needs a '{CONF_SESSION}' layer, whose "
"keep-alives make sure they are sent",
path=[key],
)
def check_single_peer(config: ConfigType, destination: int) -> None:
@@ -22,18 +22,25 @@ CONF_MAX_RETRIES = "max_retries"
# The control byte and the CRC-16
FRAME_OVERHEAD = 3
# Unless the link works out a longer one from how long its packets take, as a radio link does
DEFAULT_TIMEOUT = cv.TimePeriodMilliseconds(milliseconds=200)
HdlcReliability = packet_interface_ns.class_("HdlcReliability", PacketInterface)
def _ack_delay_within_timeout(config: ConfigType) -> ConfigType:
def check_ack_delay(config: ConfigType, timeout: cv.TimePeriod) -> None:
"""The peer, configured the same, must hear the acknowledgement before its timeout."""
if (
config[CONF_ACK_DELAY].total_milliseconds
>= config[CONF_TIMEOUT].total_milliseconds
):
if config[CONF_ACK_DELAY].total_milliseconds >= timeout.total_milliseconds:
raise cv.Invalid(
f"Must be shorter than '{CONF_TIMEOUT}'", path=[CONF_ACK_DELAY]
f"Must be shorter than '{CONF_TIMEOUT}', which is {timeout.total_milliseconds}ms",
path=[CONF_ACK_DELAY],
)
def _ack_delay_within_timeout(config: ConfigType) -> ConfigType:
# Without a timeout, the link checks against the one it chooses
if (timeout := config.get(CONF_TIMEOUT)) is not None:
check_ack_delay(config, timeout)
return config
@@ -42,7 +49,7 @@ HDLC_SCHEMA = cv.All(
{
cv.GenerateID(): cv.declare_id(HdlcReliability),
# Retransmitting more often than the main loop runs would exhaust the retries at once
cv.Optional(CONF_TIMEOUT, default="200ms"): cv.All(
cv.Optional(CONF_TIMEOUT): cv.All(
cv.positive_time_period_milliseconds,
cv.Range(min=cv.TimePeriod(milliseconds=50)),
),
@@ -76,7 +83,7 @@ async def build_hdlc(
psram=True,
)
var = cg.new_Pvariable(config[CONF_ID], lower, tx_slots, queue_length)
cg.add(var.set_ack_timeout(config[CONF_TIMEOUT]))
cg.add(var.set_ack_timeout(config.get(CONF_TIMEOUT, DEFAULT_TIMEOUT)))
cg.add(var.set_ack_delay(config[CONF_ACK_DELAY]))
cg.add(var.set_max_retries(config[CONF_MAX_RETRIES]))
await cg.register_component(var, config)
@@ -0,0 +1,64 @@
#pragma once
#include <cstdint>
namespace esphome::packet_interface {
/**
* Decides whether a half-duplex radio link may send while its radio reports that it is receiving a packet.
*
* Sending is refused while the radio is busy, so the packet being received is not lost. A busy period starts when a
* send first finds the radio busy, and ends when a send finds it free or end_busy() is called. Once a busy period has
* lasted max_busy_ms, sends go ahead, so a busy flag that never clears cannot stop sending for good, however often
* sends are tried. Code generation sets max_busy_ms from the time the radio takes to receive the largest packet.
*
* On a link whose peer replies, sending also takes turns: after a send, a send in a later loop pass waits up to
* turnaround_ms, the time the peer takes to start a reply and the radio to notice it, unless a packet arrives first.
* Without this, the next frame of a burst goes out on top of the peer's acknowledgement. Sends in the same loop pass,
* such as the fragments of one packet, are not held back.
*/
class ListenBeforeTalk {
public:
static constexpr uint32_t DEFAULT_MAX_BUSY_MS = 2000;
void set_max_busy(uint32_t max_busy_ms) { this->max_busy_ms_ = max_busy_ms; }
uint32_t get_max_busy() const { return this->max_busy_ms_; }
void set_turnaround(uint32_t turnaround_ms) { this->turnaround_ms_ = turnaround_ms; }
/// True if a packet may be sent at \p now, in the loop pass that started at \p pass; \p busy says whether the
/// radio is receiving.
bool may_send(bool busy, uint32_t now, uint32_t pass) {
if (!busy) {
this->busy_ = false;
return !this->turn_held_ || pass == this->sent_pass_ || now - this->sent_ms_ >= this->turnaround_ms_;
}
if (!this->busy_) {
this->busy_ = true;
this->busy_since_ms_ = now;
}
return now - this->busy_since_ms_ >= this->max_busy_ms_;
}
/// Ends the busy period, when the radio is seen to be free other than by a send.
void end_busy() { this->busy_ = false; }
/// A packet was sent, ending at \p now, in the loop pass that started at \p pass.
void sent(uint32_t now, uint32_t pass) {
this->turn_held_ = this->turnaround_ms_ != 0;
this->sent_ms_ = now;
this->sent_pass_ = pass;
}
/// A packet arrived, so the peer has taken its turn.
void received() { this->turn_held_ = false; }
/// How long the current busy period has lasted at \p now.
uint32_t busy_for(uint32_t now) const { return now - this->busy_since_ms_; }
protected:
uint32_t busy_since_ms_{0};
uint32_t max_busy_ms_{DEFAULT_MAX_BUSY_MS};
uint32_t sent_ms_{0};
uint32_t sent_pass_{0};
uint32_t turnaround_ms_{0};
bool busy_{false};
bool turn_held_{false};
};
} // namespace esphome::packet_interface
@@ -0,0 +1,70 @@
#include "radio_link.h"
#include <cinttypes>
#include "esphome/core/application.h"
#include "esphome/core/log.h"
namespace esphome::packet_interface {
ESPHOME_LOG_TAG(TAG, "packet_interface.radio");
bool RadioLinkBase::check_size_(size_t size) const {
if (size <= this->max_packet_size_)
return true;
ESP_LOGW(TAG, "Packet of %zu bytes is larger than %zu", size, this->max_packet_size_);
return false;
}
bool RadioLinkBase::may_send_(bool busy) {
if (busy)
this->enable_loop();
return this->listen_before_talk_.may_send(busy, this->current_time_ms(), App.get_loop_component_start_time());
}
bool RadioLinkBase::sent_(bool sent, bool busy) {
if (busy) {
uint32_t busy_ms = this->listen_before_talk_.busy_for(this->current_time_ms());
// The radio listens again, and a reception that starts now must be waited for afresh
this->listen_before_talk_.end_busy();
// The limit is longer than any packet takes, so the radio's busy indication is stuck or the channel is jammed
ESP_LOGW(TAG, "Radio busy for %" PRIu32 "ms, %s", busy_ms,
sent ? LOG_STR_LITERAL("sent anyway") : LOG_STR_LITERAL("tried to send anyway, which failed"));
}
if (sent)
this->listen_before_talk_.sent(this->current_time_ms(), App.get_loop_component_start_time());
return sent;
}
bool RadioLinkBase::skip_empty_() const {
ESP_LOGV(TAG, "Empty packet not sent");
return true;
}
void RadioLinkBase::radio_not_ready_(bool failed) {
if (!failed || this->failed_warned_)
return;
this->failed_warned_ = true;
ESP_LOGW(TAG, "%s: The radio failed to set up, so nothing can be sent", this->name_);
}
void RadioLinkBase::radio_free_() {
this->listen_before_talk_.end_busy();
this->disable_loop();
}
void RadioLinkBase::receive_(const std::vector<uint8_t> &packet, float rssi, float snr) {
// The radio takes packets up to its own limit, so a larger one is from a device configured differently
if (packet.size() > this->max_packet_size_) {
ESP_LOGV(TAG, "%s: Packet of %zu bytes is larger than %zu, dropped", this->name_, packet.size(),
this->max_packet_size_);
this->note_received_(false);
return;
}
this->note_received_(true);
this->listen_before_talk_.received();
PacketMetaData meta_data;
meta_data.rssi = rssi;
meta_data.snr = snr;
this->on_receive_from_interface_(PacketBuffer(packet.data(), packet.size()), meta_data);
}
} // namespace esphome::packet_interface
@@ -0,0 +1,101 @@
#pragma once
#include <vector>
#include "esphome/components/packet_interface/listen_before_talk.h"
#include "esphome/components/packet_interface/packet_interface.h"
#include "esphome/core/hal.h"
namespace esphome::packet_interface {
/// The parts of RadioLink that do not depend on the radio.
class RadioLinkBase : public PacketInterface {
public:
void set_max_busy(uint32_t max_busy_ms) { this->listen_before_talk_.set_max_busy(max_busy_ms); }
void set_turnaround(uint32_t turnaround_ms) { this->listen_before_talk_.set_turnaround(turnaround_ms); }
protected:
explicit RadioLinkBase(size_t max_packet_size) : PacketInterface(max_packet_size) {}
/// The time now, not the loop's start: earlier sends in the same loop pass may have waited seconds for the radio.
virtual uint32_t current_time_ms() const { return millis(); }
/// False if a packet of this size is too large.
bool check_size_(size_t size) const;
/// False if sending must wait, as the radio is busy or the peer may be about to reply; starts loop() to watch a
/// busy radio.
bool may_send_(bool busy);
/**
* Returns \p sent, after ending the busy period and warning if the packet was sent over a radio that seemed busy.
* Called only once the radio has the packet, as a log line can run an automation that sends again and overwrites
* the buffer it came from.
*/
bool sent_(bool sent, bool busy);
/// Returns true for an empty packet, which the radios cannot send, so there is nothing to retry.
bool skip_empty_() const;
/// Warns once when a send finds the radio failed; until its setup has run, sends are refused quietly.
void radio_not_ready_(bool failed);
/// Ends the busy period when loop() finds the radio free.
void radio_free_();
void receive_(const std::vector<uint8_t> &packet, float rssi, float snr);
// First, so it fills the spare byte at the end of PacketInterface
bool failed_warned_{false};
ListenBeforeTalk listen_before_talk_;
};
/**
* A packet interface link over a packet radio: each packet is one radio packet, with the RSSI and SNR of received
* packets in the metadata. Sending waits for the radio to finish transmitting. A radio cannot hear while it sends, so
* sending is refused while the radio is receiving a packet. A reliability layer sends the packet again shortly, and
* entity_transport after a delay; other callers drop it, logging at debug level at most. While a busy period lasts,
* loop() watches the radio and ends the period as soon as the radio is free, so a later reception starts a new one.
*
* Radio provides is_receiving(), register_listener(Listener *) and transmit_packet(const uint8_t *, size_t), which
* returns an Error whose value 0 means success. Listener declares on_packet(packet, rssi, snr). MaxPacketSize is the
* radio's limit.
*/
template<typename Radio, typename Listener, typename Error, size_t MaxPacketSize>
class RadioLink : public RadioLinkBase, public Listener {
public:
RadioLink(Radio *radio, size_t max_packet_size) : RadioLinkBase(max_packet_size), radio_(radio) {}
void setup() override {
this->radio_->register_listener(this);
this->disable_loop();
}
// Runs only during a busy period; a busy flag that never clears keeps it running. A radio that failed meanwhile
// is not read again, as reading it may wait on the radio every time
void loop() override {
if (!this->radio_->is_ready() || !this->radio_->is_receiving())
this->radio_free_();
}
bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) override {
// The radio is set up after the layers above, which may send from their own setup
if (!this->radio_->is_ready()) {
this->radio_not_ready_(this->radio_->is_failed());
return false;
}
size_t size = data.size();
if (size == 0)
return this->skip_empty_();
bool busy = this->radio_->is_receiving();
if (!this->check_size_(size) || !this->may_send_(busy))
return false;
if (data.is_contiguous()) {
auto span = data.as_span();
return this->sent_(this->radio_->transmit_packet(span.data(), span.size()) == Error{}, busy);
}
uint8_t buf[MaxPacketSize];
data.copy_to(buf, size);
return this->sent_(this->radio_->transmit_packet(buf, size) == Error{}, busy);
}
void on_packet(const std::vector<uint8_t> &packet, float rssi, float snr) override {
this->receive_(packet, rssi, snr);
}
protected:
Radio *radio_;
};
} // namespace esphome::packet_interface
@@ -0,0 +1,311 @@
"""Shared code generation for the packet interface links over packet radios, such as the SX126x and SX127x."""
from collections.abc import Callable, Iterator
import logging
import math
import esphome.codegen as cg
from esphome.components.const import CONF_MAX_PACKET_SIZE
import esphome.config_validation as cv
from esphome.const import CONF_FRAGMENTATION, CONF_ID, CONF_TIMEOUT
from esphome.core import CORE
from esphome.cpp_generator import MockObjClass
import esphome.final_validate as fv
from esphome.types import ConfigType
from . import new_packet_interface, packet_interface_schema, reliability_layers
from .layers import (
ADDRESSING,
CONF_ADDRESSING,
CONF_PEERS,
CONF_RELIABILITY,
STACK_ORDER,
)
from .layers.basic_fragmentation import HEADER_SIZE as FRAGMENT_HEADER_SIZE
from .layers.hdlc_reliability import (
CONF_ACK_DELAY,
CONF_MAX_QUEUE_LENGTH,
DEFAULT_TIMEOUT,
)
_LOGGER = logging.getLogger(__name__)
# The largest packet a radio receives, from any device on the channel, given the radio's settings
ReceiveLimit = Callable[[ConfigType], int]
# The radios' payload length register is 8 bits
MAX_PACKET_SIZE = 255
# The smallest max_packet_size that packet_interface_schema() takes
MIN_PACKET_SIZE = 16
# Listen before talk holds a send back for at most the airtime of the largest packet, and never less than this
MIN_MAX_BUSY_MS = 2000
# Room for the preamble detection and the radio's own delays
MARGIN = 1.25
# The radio drivers stop waiting for a packet to be sent after this long
TRANSMIT_TIMEOUT_MS = 4000
# An acknowledgement, with room for the layers below the reliability layer, such as addressing and the rolling code
ACK_PACKET_SIZE = 32
# From the end of a packet to the start of the peer's reply: a loop pass to read the packet, one to answer it, and the
# radio's start-up
REPLY_START_MS = 50
# A LoRa packet's explicit header is in its first 8 symbols
LORA_HEADER_SYMBOLS = 8
def _lora_symbol_s(radio: ConfigType) -> float:
bandwidth_hz = (
float(str(radio["bandwidth"]).removesuffix("kHz").replace("_", ".")) * 1000
)
return (1 << radio["spreading_factor"]) / bandwidth_hz
def packet_airtime_ms(radio: ConfigType, size: int) -> float:
"""The time a radio configured as in radio takes to send a packet of size bytes.
LoRa follows the Semtech formula for an explicit header; the low data rate optimization is assumed when a symbol
takes more than 16 ms, as the drivers enable it. Other modulations count the preamble, sync word, length byte,
payload and CRC at the bitrate, treating the preamble size as bytes, which gives the longer time.
"""
if str(radio["modulation"]) == "LORA":
spreading_factor = radio["spreading_factor"]
coding_rate = int(str(radio["coding_rate"])[-1]) - 4
symbol_s = _lora_symbol_s(radio)
low_data_rate = 1 if symbol_s > 0.016 else 0
crc = 16 if radio.get("crc_enable", False) else 0
payload_symbols = 8 + max(
math.ceil(
(8 * size - 4 * spreading_factor + 28 + crc)
/ (4 * (spreading_factor - 2 * low_data_rate))
)
* (coding_rate + 4),
0,
)
return (radio["preamble_size"] + 4.25 + payload_symbols) * symbol_s * 1000
bytes_sent = (
radio["preamble_size"] + len(radio.get("sync_value", [])) + 1 + size + 2
)
return bytes_sent * 8 / radio["bitrate"] * 1000
def turnaround_ms(radio: ConfigType) -> int:
"""How long, after sending, to wait for the peer's reply to start and for the radio to receive its header, so
the peer's reply is not sent over.
"""
if str(radio["modulation"]) == "LORA":
symbols = radio["preamble_size"] + 4.25 + LORA_HEADER_SYMBOLS
header_ms = symbols * _lora_symbol_s(radio) * 1000
else:
header_bytes = radio["preamble_size"] + len(radio.get("sync_value", [])) + 1
header_ms = header_bytes * 8 / radio["bitrate"] * 1000
return math.ceil((header_ms + REPLY_START_MS) * MARGIN)
def max_busy_ms(radio: ConfigType, max_packet_size: int) -> int:
"""How long listen before talk may hold a send back, for packets of up to max_packet_size bytes."""
return max(
MIN_MAX_BUSY_MS, math.ceil(packet_airtime_ms(radio, max_packet_size) * MARGIN)
)
def _fits_transmit_time(radio: ConfigType, size: int) -> bool:
return packet_airtime_ms(radio, size) * MARGIN <= TRANSMIT_TIMEOUT_MS
def _largest_sendable(radio: ConfigType, limit: int) -> int | None:
"""The largest max_packet_size, up to limit, whose packets the radio sends within the drivers' wait."""
return next(
(
size
for size in range(limit, MIN_PACKET_SIZE - 1, -1)
if _fits_transmit_time(radio, size)
),
None,
)
def channel_packet_size(radio: ConfigType, receive_limit: int) -> int:
"""The largest packet any device on the channel can send: no more than the radio receives, and no more than a
device with these radio settings is allowed to send.
"""
return _largest_sendable(radio, receive_limit) or receive_limit
def reliability_timeout_ms(
radio: ConfigType, packet_size: int, ack_delay_ms: int
) -> int:
"""The shortest reliability timeout: before acknowledging, the peer may be sending, or receiving from another
device, a packet of packet_size bytes.
"""
airtime = packet_airtime_ms(radio, packet_size) + packet_airtime_ms(
radio, ACK_PACKET_SIZE
)
return math.ceil(airtime * MARGIN) + ack_delay_ms
def _check_transmit_time(config: ConfigType, radio: ConfigType) -> None:
"""The radio drivers give up on a packet that takes longer to send than they wait."""
size = config[CONF_MAX_PACKET_SIZE]
if _fits_transmit_time(radio, size):
return
largest = _largest_sendable(radio, size - 1)
advice = (
f"set '{CONF_MAX_PACKET_SIZE}' to {largest} or less"
if largest is not None
else "use faster radio settings"
)
raise cv.Invalid(
f"With these radio settings a packet of {size} bytes takes {packet_airtime_ms(radio, size):.0f} ms to "
f"send, longer than the radio waits for; {advice}",
path=[CONF_MAX_PACKET_SIZE],
)
def _check_reliability_timeouts(
config: ConfigType, radio: ConfigType, packet_size: int
) -> None:
"""A reliability timeout shorter than a packet and its acknowledgement take would send packets again too soon."""
for path, layer in reliability_layers(config):
if (timeout := layer.get(CONF_TIMEOUT)) is None:
continue
needed = reliability_timeout_ms(
radio, packet_size, layer[CONF_ACK_DELAY].total_milliseconds
)
if timeout.total_milliseconds < needed:
raise cv.Invalid(
f"With these radio settings a packet and its acknowledgement can take {needed} ms, so this must be "
f"at least {needed}ms; leave it out to use that",
path=[*path, CONF_TIMEOUT],
)
def _stacks(config: ConfigType) -> Iterator[tuple[ConfigType, int]]:
"""The link's stacks of layers, on the link or in each peer, each with the largest packet below it."""
size = config[CONF_MAX_PACKET_SIZE]
if (addressing := config.get(CONF_ADDRESSING)) is None:
yield config, size
return
size = ADDRESSING.get_type(addressing).packet_size(addressing, size)
yield from ((stack, size) for stack in addressing.get(CONF_PEERS, [config]))
def _radio_packets_per_send(stack: ConfigType, size: int) -> int:
"""How many radio packets one send through the stack can send one after another, each waited for in turn."""
if (reliability := stack.get(CONF_RELIABILITY)) is not None:
# It sends, and after a timeout sends again, every packet in its queue at once
return reliability[CONF_MAX_QUEUE_LENGTH]
if (fragmentation := stack.get(CONF_FRAGMENTATION)) is None:
return 1
for kind in STACK_ORDER:
if kind.key == CONF_FRAGMENTATION:
break
if (layer := stack.get(kind.key)) is not None:
size = kind.get_type(layer).packet_size(layer, size)
fragment = size - FRAGMENT_HEADER_SIZE
if fragment <= 0:
return 1
return math.ceil(fragmentation[CONF_MAX_PACKET_SIZE] / fragment)
def _warn_long_sends(config: ConfigType, radio: ConfigType) -> None:
"""The radio drivers wait for each packet to be sent, so a send of several packets holds up everything else."""
airtime = packet_airtime_ms(radio, config[CONF_MAX_PACKET_SIZE])
for stack, size in _stacks(config):
count = _radio_packets_per_send(stack, size)
if count > 1 and count * airtime > TRANSMIT_TIMEOUT_MS:
_LOGGER.warning(
"A send through '%s' can send %d radio packets in a row, holding up other components for about "
"%.1f s while the radio sends them; reduce '%s' or the reliability '%s', or use faster radio "
"settings",
stack[CONF_ID].id,
count,
count * airtime / 1000,
CONF_MAX_PACKET_SIZE,
CONF_MAX_QUEUE_LENGTH,
)
def radio_link_schema(
class_: MockObjClass, radio_id_key: str, radio_class: MockObjClass
) -> cv.Schema:
"""Schema for a radio link, referring to its radio by radio_id_key."""
return packet_interface_schema(
class_, MAX_PACKET_SIZE, MAX_PACKET_SIZE, chooses_reliability_timeout=True
).extend({cv.GenerateID(radio_id_key): cv.use_id(radio_class)})
def _two_way_layer(config: ConfigType) -> str | None:
"""The first layer on the link or in a peer that keeps state for one peer, so needs packets back from it."""
for stack in (config, *config.get(CONF_ADDRESSING, {}).get(CONF_PEERS, [])):
for kind in STACK_ORDER:
if (layer := stack.get(kind.key)) is not None and kind.get_type(
layer
).single_peer(layer):
return kind.key
return None
def takes_turns(config: ConfigType) -> bool:
"""Whether sends wait for the peer to reply: only a reliability layer's peer answers each packet at once."""
return next(reliability_layers(config), None) is not None
def radio_link_final_validate(
radio_id_key: str,
payload_length_key: str,
rx_start_key: str,
check: Callable[[ConfigType, ConfigType], None] | None = None,
receive_limit: ReceiveLimit = lambda radio: MAX_PACKET_SIZE,
) -> Callable[[ConfigType], ConfigType]:
"""Final validation for a radio link: packets vary in length, the radio listens after sending when a layer needs
replies, and check(link, radio) checks the rest.
"""
def validator(config: ConfigType) -> ConfigType:
radio = fv.get_declaring_config(config[radio_id_key])
if radio[payload_length_key] != 0:
raise cv.Invalid(
f"Packets vary in length, so the radio's '{payload_length_key}' must be 0",
path=[radio_id_key],
)
if not radio[rx_start_key] and (layer := _two_way_layer(config)) is not None:
raise cv.Invalid(
f"This '{layer}' needs packets from the peer, but the radio sleeps after sending unless "
f"'{rx_start_key}' is true",
path=[radio_id_key],
)
if check is not None:
check(config, radio)
_check_transmit_time(config, radio)
_check_reliability_timeouts(
config, radio, channel_packet_size(radio, receive_limit(radio))
)
_warn_long_sends(config, radio)
return config
return validator
async def new_radio_link(
config: ConfigType,
radio_id_key: str,
receive_limit: ReceiveLimit = lambda radio: MAX_PACKET_SIZE,
) -> None:
"""Create a radio link, with timings worked out from the radio's settings and the largest packet on the channel."""
radio_config = fv.get_declaring_config(config[radio_id_key], CORE.config)
packet_size = channel_packet_size(radio_config, receive_limit(radio_config))
# A reliability layer without a timeout gets one long enough for a packet and its acknowledgement
for _, layer in reliability_layers(config):
if CONF_TIMEOUT not in layer:
needed = reliability_timeout_ms(
radio_config, packet_size, layer[CONF_ACK_DELAY].total_milliseconds
)
layer[CONF_TIMEOUT] = cv.TimePeriodMilliseconds(
milliseconds=max(DEFAULT_TIMEOUT.total_milliseconds, needed)
)
radio = await cg.get_variable(config[radio_id_key])
var = await new_packet_interface(config, radio, config[CONF_MAX_PACKET_SIZE])
cg.add(var.set_max_busy(max_busy_ms(radio_config, packet_size)))
# Taking turns would hold up a run of one-way sends, and a reliability layer sends again what it refuses
if takes_turns(config):
cg.add(var.set_turnaround(turnaround_ms(radio_config)))
@@ -46,6 +46,8 @@ class XxteaEncryption : public PacketInterface {
void setup() override;
void dump_config() override;
bool send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) override;
// One encrypted packet per packet, so a fragmentation layer above sees the link's room
size_t get_send_capacity() const override { return this->lower_->get_send_capacity(); }
void set_key(std::initializer_list<uint32_t> key);
@@ -0,0 +1,49 @@
from esphome.components import packet_interface
from esphome.components.packet_interface.radio_link import (
new_radio_link,
radio_link_final_validate,
radio_link_schema,
)
import esphome.config_validation as cv
from esphome.types import ConfigType
from .. import (
CONF_MODULATION,
CONF_PAYLOAD_LENGTH,
CONF_RX_START,
CONF_SX126X_ID,
CONF_SYNC_VALUE,
SX126x,
SX126xListener,
sx126x_ns,
)
CODEOWNERS = ["@clydebarrow"]
DEPENDENCIES = ["sx126x"]
SX126xPacketInterface = sx126x_ns.class_(
"SX126xPacketInterface", packet_interface.PacketInterface, SX126xListener
)
CONFIG_SCHEMA = radio_link_schema(SX126xPacketInterface, CONF_SX126X_ID, SX126x)
def _check_fsk(config: ConfigType, radio: ConfigType) -> None:
"""Without LoRa, the radio can tell that a packet is arriving only from its sync word, which listen before talk
needs.
"""
if radio[CONF_MODULATION] != "LORA" and not radio[CONF_SYNC_VALUE]:
raise cv.Invalid(
f"Without LoRa modulation the radio needs a '{CONF_SYNC_VALUE}', so that the link can tell when a packet "
"is arriving and not send over it",
path=[CONF_SX126X_ID],
)
FINAL_VALIDATE_SCHEMA = radio_link_final_validate(
CONF_SX126X_ID, CONF_PAYLOAD_LENGTH, CONF_RX_START, _check_fsk
)
async def to_code(config: ConfigType) -> None:
await new_radio_link(config, CONF_SX126X_ID)
@@ -0,0 +1,10 @@
#pragma once
#include "esphome/components/packet_interface/radio_link.h"
#include "esphome/components/sx126x/sx126x.h"
namespace esphome::sx126x {
using SX126xPacketInterface = packet_interface::RadioLink<SX126x, SX126xListener, SX126xError, SX126X_MAX_PACKET_SIZE>;
} // namespace esphome::sx126x
+2
View File
@@ -99,6 +99,8 @@ class SX126x final : public Component {
bool cancel_transmit_async(SX126xTransmitListener *listener);
bool is_transmitting() const { return this->radio_.is_transmitting(); }
void register_listener(SX126xListener *listener) { this->listeners_.push_back(listener); }
// True while a packet is being received, or has been received and not yet read; sending would lose it.
bool is_receiving() { return this->radio_.is_receiving(); }
Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() { return &this->packet_trigger_; }
private:
@@ -246,18 +246,20 @@ void SX126xCommands::calibrate_image(uint32_t frequency) {
}
}
// The IRQ mask also routes to DIO1; DIO2 and DIO3 stay unused.
void SX126xCommands::set_dio_irq_params_(uint16_t irq) {
// Only the dio1 interrupts are routed to DIO1; DIO2 and DIO3 stay unused.
void SX126xCommands::set_dio_irq_params_(uint16_t flags, uint16_t dio1) {
uint8_t buf[8];
put_be16(buf, irq);
put_be16(buf + 2, irq);
put_be16(buf, flags);
put_be16(buf + 2, dio1);
put_be16(buf + 4, IRQ_RADIO_NONE);
put_be16(buf + 6, IRQ_RADIO_NONE);
this->write_opcode_(RADIO_SET_DIOIRQPARAMS, buf, 8);
}
void SX126xCommands::receive() {
this->set_dio_irq_params_(IRQ_RX_DONE | IRQ_RX_TX_TIMEOUT | IRQ_CRC_ERROR);
// A valid header or sync word is flagged for SX126xRadio::is_receiving(), but not signalled on DIO1
const uint16_t irq = IRQ_RX_DONE | IRQ_RX_TX_TIMEOUT | IRQ_CRC_ERROR;
this->set_dio_irq_params_(irq | IRQ_HEADER_VALID | IRQ_SYNCWORD_VALID, irq);
uint8_t buf[3];
@@ -273,7 +275,7 @@ void SX126xCommands::receive() {
}
void SX126xCommands::transmit(uint32_t timeout_ms) {
this->set_dio_irq_params_(IRQ_TX_DONE | IRQ_RX_TX_TIMEOUT);
this->set_dio_irq_params_(IRQ_TX_DONE | IRQ_RX_TX_TIMEOUT, IRQ_TX_DONE | IRQ_RX_TX_TIMEOUT);
uint8_t buf[3];
+1 -1
View File
@@ -41,7 +41,7 @@ class SX126xCommands {
private:
void read_opcode_(uint8_t opcode, uint8_t *data, uint8_t size);
void write_opcode_(uint8_t opcode, const uint8_t *data, uint8_t size);
void set_dio_irq_params_(uint16_t irq);
void set_dio_irq_params_(uint16_t flags, uint16_t dio1);
void read_register_(uint16_t reg, uint8_t *data, uint8_t size);
void write_register_(uint16_t reg, const uint8_t *data, uint8_t size);
static void encode_packet_params(const RadioProfile &profile, AppliedProfile &applied);
@@ -195,6 +195,26 @@ bool SX126xRadio::restore_() {
return this->bus().ok();
}
bool SX126xRadio::is_receiving() {
if (this->state_ == RadioState::RADIO_STATE_HOLDING_RX) {
return true;
}
// A radio that sleeps after sending is not listening, and reading it would wake it
if (this->busy_ || this->state_ != RadioState::RADIO_STATE_IDLE || !this->applied_.rx_start) {
return false;
}
// DIO1 signals a received packet that loop() has not read yet
if (this->pending_irq_ != 0 || this->dio1_pin_->digital_read()) {
return true;
}
this->busy_ = true;
this->bus().begin();
const uint16_t status = this->commands_.read_irq();
this->busy_ = false;
// A failed read counts as receiving, so the link holds the send and warns if the radio stays unreadable
return !this->bus().ok() || (status & (IRQ_HEADER_VALID | IRQ_SYNCWORD_VALID)) != 0;
}
RadioEffects SX126xRadio::poll(uint32_t now, std::vector<uint8_t> &packet) {
if (this->busy_) {
return {};
+3
View File
@@ -104,6 +104,9 @@ class SX126xRadio {
bool can_configure() const { return !this->busy_ && !this->is_transmitting(); }
bool can_change_mode() const { return !this->busy_ && this->state_ == RadioState::RADIO_STATE_IDLE; }
size_t max_packet_size() const { return this->applied_.max_packet_size(); }
// True while a packet is being received, or has been received and not yet read, so a send would lose it.
// Reads the chip only when the radio is idle and listening; any other state reports false, a failed read true.
bool is_receiving();
// Requires can_configure(). Resets the chip and applies the requested profile.
RadioEffects configure(const RadioProfile &requested, std::span<char, 16> version);
@@ -0,0 +1,72 @@
from esphome.components import packet_interface
from esphome.components.packet_interface import CONF_MAX_PACKET_SIZE
from esphome.components.packet_interface.radio_link import (
MAX_PACKET_SIZE,
new_radio_link,
radio_link_final_validate,
radio_link_schema,
)
import esphome.config_validation as cv
from esphome.types import ConfigType
from .. import (
CONF_MODULATION,
CONF_PACKET_MODE,
CONF_PAYLOAD_LENGTH,
CONF_RX_START,
CONF_SX127X_ID,
CONF_SYNC_VALUE,
SX127x,
SX127xListener,
sx127x_ns,
)
CODEOWNERS = ["@clydebarrow"]
DEPENDENCIES = ["sx127x"]
# Outside LoRa mode the 64 byte FIFO also holds the length byte
FSK_MAX_PACKET_SIZE = 63
SX127xPacketInterface = sx127x_ns.class_(
"SX127xPacketInterface", packet_interface.PacketInterface, SX127xListener
)
CONFIG_SCHEMA = radio_link_schema(SX127xPacketInterface, CONF_SX127X_ID, SX127x)
def _check_fsk(config: ConfigType, radio: ConfigType) -> None:
"""Without LoRa, the radio must send packets, not a continuous bit stream, and holds fewer bytes.
It can tell that a packet is arriving only from its sync word, which listen before talk needs.
"""
if radio[CONF_MODULATION] == "LORA":
return
if not radio.get(CONF_PACKET_MODE, False):
raise cv.Invalid(
f"Without LoRa modulation the radio's '{CONF_PACKET_MODE}' must be true, as a link sends packets",
path=[CONF_SX127X_ID],
)
if not radio.get(CONF_SYNC_VALUE):
raise cv.Invalid(
f"Without LoRa modulation the radio needs a '{CONF_SYNC_VALUE}', so that the link can tell when a "
"packet is arriving and not send over it",
path=[CONF_SX127X_ID],
)
if config[CONF_MAX_PACKET_SIZE] > FSK_MAX_PACKET_SIZE:
raise cv.Invalid(
f"Without LoRa modulation the radio sends at most {FSK_MAX_PACKET_SIZE} bytes",
path=[CONF_MAX_PACKET_SIZE],
)
def _receive_limit(radio: ConfigType) -> int:
return MAX_PACKET_SIZE if radio[CONF_MODULATION] == "LORA" else FSK_MAX_PACKET_SIZE
FINAL_VALIDATE_SCHEMA = radio_link_final_validate(
CONF_SX127X_ID, CONF_PAYLOAD_LENGTH, CONF_RX_START, _check_fsk, _receive_limit
)
async def to_code(config: ConfigType) -> None:
await new_radio_link(config, CONF_SX127X_ID, _receive_limit)
@@ -0,0 +1,10 @@
#pragma once
#include "esphome/components/packet_interface/radio_link.h"
#include "esphome/components/sx127x/sx127x.h"
namespace esphome::sx127x {
using SX127xPacketInterface = packet_interface::RadioLink<SX127x, SX127xListener, SX127xError, SX127X_MAX_PACKET_SIZE>;
} // namespace esphome::sx127x
+45 -21
View File
@@ -62,15 +62,20 @@ void SX127x::read_fifo_(std::vector<uint8_t> &packet) {
this->disable();
}
void SX127x::write_fifo_(const uint8_t *data, size_t len) {
// Burst write: the radio moves to the next register after each byte, except for REG_FIFO
void SX127x::write_registers_(uint8_t reg, const uint8_t *data, size_t len) {
this->enable();
this->write_byte(REG_FIFO | 0x80);
for (size_t i = 0; i < len; i++) {
this->transfer_byte(data[i]);
}
this->write_byte(reg | 0x80);
this->write_array(data, len);
this->disable();
}
void SX127x::write_register16_(uint8_t msb_reg, uint16_t value) {
uint8_t bytes[2];
put_be16(bytes, value);
this->write_registers_(msb_reg, bytes, sizeof(bytes));
}
void SX127x::setup() {
// setup reset
this->rst_pin_->setup();
@@ -155,9 +160,9 @@ const LogString *SX127x::configure_radio_() {
// set freq
uint64_t frf = ((uint64_t) this->frequency_ << 19) / FXOSC;
this->write_register_(REG_FRF_MSB, (uint8_t) ((frf >> 16) & 0xFF));
this->write_register_(REG_FRF_MID, (uint8_t) ((frf >> 8) & 0xFF));
this->write_register_(REG_FRF_LSB, (uint8_t) ((frf >> 0) & 0xFF));
uint8_t frf_bytes[3];
put_be24(frf_bytes, static_cast<uint32_t>(frf));
this->write_registers_(REG_FRF_MSB, frf_bytes, sizeof(frf_bytes));
// enter standby mode
if (!this->set_mode_(MOD_FSK, MODE_STDBY)) {
@@ -208,14 +213,12 @@ void SX127x::configure_fsk_ook_() {
this->write_register_(REG_RX_BW, progmem_read_byte(&BW_FSK_OOK[this->bandwidth_]));
// set fdev
uint32_t fdev = std::min((this->deviation_ * 4096) / 250000, (uint32_t) 0x3FFF);
this->write_register_(REG_FDEV_MSB, (uint8_t) ((fdev >> 8) & 0xFF));
this->write_register_(REG_FDEV_LSB, (uint8_t) ((fdev >> 0) & 0xFF));
uint16_t fdev = clamp_at_most((this->deviation_ * 4096) / 250000, uint32_t{0x3FFF});
this->write_register16_(REG_FDEV_MSB, fdev);
// set bitrate
uint64_t bitrate = (FXOSC + this->bitrate_ / 2) / this->bitrate_; // round up
this->write_register_(REG_BITRATE_MSB, (uint8_t) ((bitrate >> 8) & 0xFF));
this->write_register_(REG_BITRATE_LSB, (uint8_t) ((bitrate >> 0) & 0xFF));
uint16_t bitrate = (FXOSC + this->bitrate_ / 2) / this->bitrate_; // round up
this->write_register16_(REG_BITRATE_MSB, bitrate);
// configure rx and afc
this->write_register_(REG_AFC_BW, progmem_read_byte(&BW_FSK_OOK[this->afc_bandwidth_]));
@@ -235,7 +238,7 @@ void SX127x::configure_fsk_ook_() {
this->write_register_(REG_PAYLOAD_LENGTH_LSB, this->payload_length_);
this->write_register_(REG_PACKET_CONFIG_1, crc_mode | FIXED_LENGTH);
} else {
this->write_register_(REG_PAYLOAD_LENGTH_LSB, this->get_max_packet_size() - 1);
this->write_register_(REG_PAYLOAD_LENGTH_LSB, this->get_max_packet_size());
this->write_register_(REG_PACKET_CONFIG_1, crc_mode | VARIABLE_LENGTH);
}
this->write_register_(REG_PACKET_CONFIG_2, PACKET_MODE);
@@ -264,8 +267,7 @@ void SX127x::configure_fsk_ook_() {
} else {
this->write_register_(REG_PREAMBLE_DETECT, PREAMBLE_DETECTOR_OFF);
}
this->write_register_(REG_PREAMBLE_SIZE_MSB, this->preamble_size_ >> 8);
this->write_register_(REG_PREAMBLE_SIZE_LSB, this->preamble_size_ & 0xFF);
this->write_register16_(REG_PREAMBLE_SIZE_MSB, this->preamble_size_);
// config sync generation and setup ook threshold
uint8_t bitsync = this->bitsync_ ? BIT_SYNC_ON : BIT_SYNC_OFF;
@@ -293,8 +295,7 @@ void SX127x::configure_lora_() {
// config preamble
if (this->preamble_size_ >= 6) {
this->write_register_(REG_PREAMBLE_LEN_MSB, this->preamble_size_ >> 8);
this->write_register_(REG_PREAMBLE_LEN_LSB, this->preamble_size_ & 0xFF);
this->write_register16_(REG_PREAMBLE_LEN_MSB, this->preamble_size_);
}
// optimize detection
@@ -325,7 +326,8 @@ size_t SX127x::get_max_packet_size() {
if (this->applied_.modulation == MOD_LORA) {
return SX127X_MAX_PACKET_SIZE;
}
return 64;
// The 64 byte FIFO also holds the length byte
return 63;
}
SX127xError SX127x::transmit_packet(const uint8_t *data, size_t len) {
@@ -390,7 +392,7 @@ SX127xError SX127x::start_transmit_(SX127xTransmitListener *listener, const uint
} else if (this->applied_.payload_length == 0) {
this->write_register_(REG_FIFO, len);
}
this->write_fifo_(data, len);
this->write_registers_(REG_FIFO, data, len);
if (!this->enter_tx_()) {
this->fail_(set_mode_failure());
return SX127xError::SX127X_ERROR_NOT_READY;
@@ -451,6 +453,28 @@ bool SX127x::restore_() {
return this->applied_.rx_start ? this->enter_rx_() : this->set_mode_(this->applied_.modulation, MODE_SLEEP);
}
bool SX127x::is_receiving() {
if (this->state_ == RadioState::RADIO_STATE_HOLDING_RX) {
return true;
}
// A radio that sleeps after sending is not listening
if (this->state_ != RadioState::RADIO_STATE_IDLE || !this->applied_.rx_start || this->dio0_pin_ == nullptr) {
return false;
}
const bool lora = this->applied_.modulation == MOD_LORA;
// In receive mode DIO0 signals a received packet that loop() has not read yet. In LoRa it also signals TX_DONE
// after the TX mode action.
if (this->dio0_pin_->digital_read() && (!lora || (this->read_register_(REG_IRQ_FLAGS) & RX_DONE) != 0)) {
return true;
}
if (!lora) {
// Set from the sync word until the packet has been read; the preamble flag stays set when no sync word follows
return (this->read_register_(REG_IRQ_FLAGS_1) & IRQ_FLAGS_1_SYNC_ADDRESS_MATCH) != 0;
}
return (this->read_register_(REG_MODEM_STAT) &
(MODEM_STAT_SIGNAL_DETECTED | MODEM_STAT_SIGNAL_SYNCHRONIZED | MODEM_STAT_HEADER_VALID)) != 0;
}
bool SX127x::packet_waiting_() {
if (this->applied_.modulation == MOD_LORA) {
const uint8_t flags = this->read_register_(REG_IRQ_FLAGS);
+4 -1
View File
@@ -126,6 +126,8 @@ class SX127x final : public Component,
bool cancel_transmit_async(SX127xTransmitListener *listener);
bool is_transmitting() const { return this->state_ == RadioState::RADIO_STATE_TRANSMITTING; }
void register_listener(SX127xListener *listener) { this->listeners_.push_back(listener); }
// True while a packet is being received, or has been received and not yet read; sending would lose it.
bool is_receiving();
Trigger<std::vector<uint8_t>, float, float> *get_packet_trigger() { return &this->packet_trigger_; }
protected:
@@ -164,7 +166,8 @@ class SX127x final : public Component,
// True once the send has ended, with its outcome in result
bool poll_transmit_(uint32_t now, SX127xError &result);
SX127xError finish_transmit_(SX127xError result);
void write_fifo_(const uint8_t *data, size_t len);
void write_registers_(uint8_t reg, const uint8_t *data, size_t len);
void write_register16_(uint8_t msb_reg, uint16_t value);
void read_fifo_(std::vector<uint8_t> &packet);
void write_register_(uint8_t reg, uint8_t value);
void call_listeners_(const std::vector<uint8_t> &packet, float rssi, float snr);
+12
View File
@@ -46,6 +46,7 @@ enum SX127xReg : uint8_t {
REG_PAYLOAD_LENGTH_LSB = 0x32,
REG_FIFO_THRESH = 0x35,
REG_IMAGE_CAL = 0x3B,
REG_IRQ_FLAGS_1 = 0x3E,
REG_IRQ_FLAGS2 = 0x3F,
// LoRa registers
REG_FIFO_ADDR_PTR = 0x0D,
@@ -261,6 +262,17 @@ enum SX127xIrqFlags : uint8_t {
CAD_DETECTED = 0x01,
};
enum SX127xIrqFlags1 : uint8_t {
IRQ_FLAGS_1_PREAMBLE_DETECT = 0x02,
IRQ_FLAGS_1_SYNC_ADDRESS_MATCH = 0x01,
};
enum SX127xModemStat : uint8_t {
MODEM_STAT_SIGNAL_DETECTED = 0x01,
MODEM_STAT_SIGNAL_SYNCHRONIZED = 0x02,
MODEM_STAT_HEADER_VALID = 0x08,
};
enum SX127xIrqFlags2 : uint8_t {
PACKET_SENT = 0x08,
PAYLOAD_READY = 0x04,
+4
View File
@@ -0,0 +1,4 @@
"""TCP links. The packet_interface platform carries packets over a TCP connection."""
CODEOWNERS = ["@clydebarrow"]
DOMAIN = "tcp"
@@ -0,0 +1,132 @@
import esphome.codegen as cg
from esphome.components import binary_sensor, packet_interface, socket
from esphome.components.const import (
CONF_ALLOWED_IPS,
CONF_CONNECTED,
CONF_HOST,
CONF_RECONNECT_INTERVAL,
CONF_ROLE,
)
from esphome.components.packet_interface import (
CONF_MAX_PACKET_SIZE,
new_packet_interface,
packet_interface_schema,
)
from esphome.components.packet_interface.layers import (
CONF_ADDRESSING,
CONF_RELIABILITY,
CONF_SESSION,
)
from esphome.components.packet_interface.layers.basic_session import CONF_KEEP_ALIVE
import esphome.config_validation as cv
from esphome.const import (
CONF_ID,
CONF_PORT,
CONF_TIMEOUT,
DEVICE_CLASS_CONNECTIVITY,
ENTITY_CATEGORY_DIAGNOSTIC,
)
from esphome.types import ConfigType
CODEOWNERS = ["@clydebarrow"]
DEPENDENCIES = ["network"]
def AUTO_LOAD(config: ConfigType | None = None) -> list[str]:
"""The binary_sensor component only for the connected sensor; without a config, as tooling calls it, both."""
if not config or CONF_CONNECTED in config:
return ["socket", "binary_sensor"]
return ["socket"]
# Each packet and its 2 byte length must fit the socket link's 1024 byte send buffer
MAX_PACKET_SIZE = 1022
tcp_ns = cg.esphome_ns.namespace("tcp")
TcpPacketInterface = tcp_ns.class_(
"TcpPacketInterface", packet_interface.PacketInterface
)
def _timeout(config: ConfigType) -> ConfigType:
"""Default the timeout to three keep-alive intervals, and require it to be longer than one."""
keep_alive = config[CONF_KEEP_ALIVE].total_milliseconds
if (timeout := config.get(CONF_TIMEOUT)) is None:
config[CONF_TIMEOUT] = cv.positive_time_period_milliseconds(
f"{keep_alive * 3}ms"
)
elif timeout.total_milliseconds <= keep_alive:
raise cv.Invalid("Must be longer than keep_alive", path=[CONF_TIMEOUT])
return config
BASE_SCHEMA = packet_interface_schema(
TcpPacketInterface,
MAX_PACKET_SIZE,
MAX_PACKET_SIZE,
# TCP resends what is lost, joins exactly two devices, and its connection state is the session
provides=(CONF_ADDRESSING, CONF_RELIABILITY, CONF_SESSION),
).extend(
{
cv.Required(CONF_PORT): cv.port,
cv.Optional(
CONF_RECONNECT_INTERVAL, default="5s"
): cv.positive_time_period_milliseconds,
cv.Optional(CONF_KEEP_ALIVE, default="10s"): cv.All(
cv.positive_time_period_milliseconds,
cv.Range(min=cv.TimePeriod(seconds=1), max=cv.TimePeriod(hours=1)),
),
# Nothing received for this long closes the connection; it must be longer than the peer's keep_alive
cv.Optional(CONF_TIMEOUT): cv.All(
cv.positive_time_period_milliseconds,
cv.Range(max=cv.TimePeriod(hours=3)),
),
cv.Optional(CONF_CONNECTED): binary_sensor.binary_sensor_schema(
device_class=DEVICE_CLASS_CONNECTIVITY,
entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
),
}
)
CONFIG_SCHEMA = cv.All(
cv.typed_schema(
{
"client": cv.All(
BASE_SCHEMA.extend({cv.Required(CONF_HOST): socket.ipv4_host}),
_timeout,
),
"server": cv.All(
BASE_SCHEMA.extend(
{cv.Optional(CONF_ALLOWED_IPS): socket.IPV4_ALLOW_SCHEMA}
),
_timeout,
),
},
key=CONF_ROLE,
default_type="client",
),
# A client uses one socket; a server one listener and one accepted socket
socket.consume_role_sockets("tcp.packet_interface"),
)
async def to_code(config: ConfigType) -> None:
rx_buffer = cg.static_buffer(
config[CONF_ID], cg.uint8, config[CONF_MAX_PACKET_SIZE]
)
var = await new_packet_interface(config, rx_buffer)
if config[CONF_ROLE] == "server":
socket.require_tcp_listener()
cg.add(var.set_server(True))
socket.add_ipv4_allow(
var.set_allow, config.get(CONF_ALLOWED_IPS), config[CONF_ID]
)
else:
socket.require_tcp_client_link()
cg.add(var.set_host(config[CONF_HOST]))
cg.add(var.set_port(config[CONF_PORT]))
cg.add(var.set_reconnect_interval(config[CONF_RECONNECT_INTERVAL]))
cg.add(var.set_keep_alive(config[CONF_KEEP_ALIVE]))
cg.add(var.set_receive_timeout(config[CONF_TIMEOUT]))
binary_sensors = binary_sensor.sub_binary_sensors(config)
await binary_sensors(CONF_CONNECTED, var.set_connected_binary_sensor)
@@ -0,0 +1,182 @@
#include "tcp_packet_interface.h"
#include "esphome/core/application.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
namespace esphome::tcp {
using packet_interface::PacketBuffer;
using packet_interface::PacketMetaData;
ESPHOME_LOG_TAG(TAG, "tcp.packet_interface");
// The packet length before each packet
static constexpr size_t LENGTH_SIZE = 2;
// A peer that sends without a pause must not hold the main loop here; a frame being read carries over to the next pass
static constexpr uint8_t MAX_FRAMES_PER_LOOP = 8;
TcpPacketInterface::TcpPacketInterface(std::span<uint8_t> rx_buffer)
: packet_interface::PacketInterface(rx_buffer.size()), rx_buffer_(rx_buffer) {
this->capabilities_ = packet_interface::CAPABILITY_RELIABILITY | packet_interface::CAPABILITY_SESSION |
packet_interface::CAPABILITY_ADDRESSING;
}
void TcpPacketInterface::setup() {
this->link_.begin(TAG);
#ifdef USE_SOCKET_TCP_LISTENER
this->listener_.begin(TAG);
#endif
#ifdef USE_BINARY_SENSOR
if (this->connected_binary_sensor_ != nullptr)
this->connected_binary_sensor_->publish_initial_state(false);
#endif
}
void TcpPacketInterface::dump_config() {
bool server = false;
#ifdef USE_SOCKET_TCP_LISTENER
server = this->server_;
#endif
ESP_LOGCONFIG(TAG,
"TCP Packet Interface '%s':\n"
" Role: %s\n"
" Address: %s:%u\n"
" Reconnect Interval: %" PRIu32 "ms\n"
" Keep Alive: %" PRIu32 "ms\n"
" Timeout: %" PRIu32 "ms\n"
" Max Packet Size: %zu",
this->name_, server ? LOG_STR_LITERAL("server") : LOG_STR_LITERAL("client"),
server ? LOG_STR_LITERAL("*") : this->link_.host(), this->link_.port(),
this->link_.reconnect_interval(), this->keep_alive_ms_, this->timeout_ms_, this->max_packet_size_);
#ifdef USE_SOCKET_TCP_LISTENER
this->listener_.dump_config();
#endif
#ifdef USE_BINARY_SENSOR
LOG_BINARY_SENSOR(" ", "Connected", this->connected_binary_sensor_);
#endif
}
void TcpPacketInterface::on_shutdown() {
this->link_.close();
#ifdef USE_SOCKET_TCP_LISTENER
this->listener_.close();
#endif
}
void TcpPacketInterface::loop() {
#ifdef USE_SOCKET_TCP_LISTENER
if (this->server_) {
// A new client is accepted only once the drop of the last has been reported
this->listener_.poll(this->link_, !this->connected_);
} else {
this->link_.poll();
}
#else
this->link_.poll();
#endif
if (this->link_.connected() != this->connected_)
this->on_connection_(this->link_.connected());
if (!this->connected_)
return;
this->read_();
if (!this->connected_)
return;
uint32_t now = App.get_loop_component_start_time();
if (now - this->last_rx_ms_ > this->timeout_ms_) {
ESP_LOGW(TAG, "%s: Nothing received for %" PRIu32 "ms, closing the connection", this->name_, this->timeout_ms_);
this->link_.close();
this->link_.note_attempt();
this->on_connection_(false);
return;
}
if (now - this->last_tx_ms_ >= this->keep_alive_ms_)
this->queue_frame_(nullptr, 0);
this->flush_();
}
void TcpPacketInterface::flush_() { this->tx_waiting_ = !this->link_.flush_tx(); }
size_t TcpPacketInterface::get_send_capacity() const {
if (!this->tx_waiting_)
return SIZE_MAX;
return this->link_.tx_free() / (this->max_packet_size_ + LENGTH_SIZE);
}
void TcpPacketInterface::on_connection_(bool connected) {
ESP_LOGD(TAG, "%s: Connection %s", this->name_, connected ? LOG_STR_LITERAL("up") : LOG_STR_LITERAL("down"));
this->connected_ = connected;
this->tx_waiting_ = false;
this->rx_have_ = 0;
this->last_rx_ms_ = this->last_tx_ms_ = App.get_loop_component_start_time();
#ifdef USE_BINARY_SENSOR
if (this->connected_binary_sensor_ != nullptr)
this->connected_binary_sensor_->publish_state(connected);
#endif
this->session_callback_.call(connected);
}
void TcpPacketInterface::read_() {
for (uint8_t frames = 0; frames != MAX_FRAMES_PER_LOOP;) {
ssize_t count;
if (this->rx_have_ < LENGTH_SIZE) {
count = this->link_.read(this->rx_header_ + this->rx_have_, LENGTH_SIZE - this->rx_have_);
} else {
count = this->link_.read(this->rx_buffer_.data() + this->rx_have_ - LENGTH_SIZE,
this->rx_length_ + LENGTH_SIZE - this->rx_have_);
}
// Nothing more for now; a dropped link is seen on the next loop
if (count <= 0)
return;
this->last_rx_ms_ = App.get_loop_component_start_time();
this->rx_have_ += count;
if (this->rx_have_ < LENGTH_SIZE)
continue;
if (this->rx_have_ == LENGTH_SIZE) {
this->rx_length_ = encode_uint16(this->rx_header_[1], this->rx_header_[0]);
if (this->rx_length_ > this->max_packet_size_) {
// The stream cannot be resynchronised, so start a new connection
ESP_LOGW(TAG, "%s: Packet of %u bytes is larger than %zu, closing the connection", this->name_,
this->rx_length_, this->max_packet_size_);
this->link_.close();
this->link_.note_attempt();
this->on_connection_(false);
return;
}
}
if (this->rx_have_ == this->rx_length_ + LENGTH_SIZE) {
this->rx_have_ = 0;
frames++;
// A zero length packet is a keep-alive
if (this->rx_length_ != 0)
this->on_receive_from_interface_(PacketBuffer(this->rx_buffer_.data(), this->rx_length_), {});
}
}
}
bool TcpPacketInterface::queue_frame_(const PacketBuffer *data, size_t size) {
if (this->link_.tx_free() < size + LENGTH_SIZE)
return false;
uint8_t *tail = this->link_.tx_tail();
tail[0] = static_cast<uint8_t>(size);
tail[1] = static_cast<uint8_t>(size >> 8);
if (data != nullptr)
data->copy_to(tail + LENGTH_SIZE, size);
this->link_.tx_commit(size + LENGTH_SIZE);
this->last_tx_ms_ = App.get_loop_component_start_time();
return true;
}
bool TcpPacketInterface::send_to_interface(const PacketBuffer &data, const PacketMetaData &meta_data) {
size_t size = data.size();
if (size > this->max_packet_size_) {
ESP_LOGW(TAG, "%s: Packet of %zu bytes is larger than %zu", this->name_, size, this->max_packet_size_);
return false;
}
if (!this->connected_ || !this->queue_frame_(&data, size))
return false;
// A write that fails closes the link and discards what was queued, this packet included
this->flush_();
return this->link_.connected();
}
} // namespace esphome::tcp
@@ -0,0 +1,93 @@
#pragma once
#include <cstdint>
#include <span>
#include "esphome/components/packet_interface/packet_interface.h"
#include "esphome/components/socket/tcp_client_link.h"
#ifdef USE_SOCKET_TCP_LISTENER
#include "esphome/components/socket/tcp_listener.h"
#endif
#ifdef USE_BINARY_SENSOR
#include "esphome/components/binary_sensor/binary_sensor.h"
#endif
namespace esphome::tcp {
/**
* A packet interface link over one TCP connection, as a client that connects to a host, or a server that accepts
* one client at a time.
*
* Each packet is sent as a 2 byte length, little endian, then the packet. TCP delivers the stream in order and
* resends what is lost, and the connection joins exactly two devices, so the link provides the reliability,
* addressing and session capabilities itself. Its connection state is the session state.
*
* Each packet is written to the socket as it is sent, so the link takes packets as fast as the socket does and keeps
* the default, unlimited, send capacity; a packet is refused only while the connection is down or the socket is full.
*
* A zero length packet is a keep-alive, sent when nothing else has been sent for keep_alive. TCP can take minutes to
* notice a peer that has gone without closing the connection, so the link closes it, and reconnects or accepts again,
* when nothing has been received for the timeout, which must be longer than the peer's keep-alive interval.
*/
class TcpPacketInterface : public packet_interface::PacketInterface {
public:
/// @param rx_buffer Holds the packet being received; its size is the largest packet, and it must outlive the link
explicit TcpPacketInterface(std::span<uint8_t> rx_buffer);
void setup() override;
void loop() override;
void dump_config() override;
void on_shutdown() override;
bool send_to_interface(const packet_interface::PacketBuffer &data,
const packet_interface::PacketMetaData &meta_data) override;
/**
* Unlimited while the socket takes what is sent. Once frames wait for it, how many more full frames fit. A socket
* that stalls part way through a fragmented packet still cuts it short.
*/
size_t get_send_capacity() const override;
void set_host(const char *host) { this->link_.set_host(host); }
void set_port(uint16_t port) { this->link_.set_port(port); }
void set_reconnect_interval(uint32_t interval_ms) { this->link_.set_reconnect_interval(interval_ms); }
void set_keep_alive(uint32_t keep_alive_ms) { this->keep_alive_ms_ = keep_alive_ms; }
/// The connection is closed when nothing has been received for this long; the peer's keep_alive sets the pace.
void set_receive_timeout(uint32_t timeout_ms) { this->timeout_ms_ = timeout_ms; }
#ifdef USE_SOCKET_TCP_LISTENER
void set_server(bool server) { this->server_ = server; }
#ifdef USE_SOCKET_IPV4_ALLOW
void set_allow(const socket::Ipv4AllowEntry *entries, size_t count) { this->listener_.set_allow(entries, count); }
#endif
#endif
#ifdef USE_BINARY_SENSOR
SUB_BINARY_SENSOR(connected)
#endif
bool is_connected() const { return this->connected_; }
protected:
void on_connection_(bool connected);
void read_();
bool queue_frame_(const packet_interface::PacketBuffer *data, size_t size);
void flush_();
socket::TcpClientLink link_;
#ifdef USE_SOCKET_TCP_LISTENER
socket::TcpListener listener_;
#endif
const std::span<uint8_t> rx_buffer_;
uint32_t keep_alive_ms_{10000};
uint32_t timeout_ms_{30000};
uint32_t last_rx_ms_{0};
uint32_t last_tx_ms_{0};
uint16_t rx_length_{0};
// Bytes of the current frame received so far, counting the 2 byte length
uint16_t rx_have_{0};
uint8_t rx_header_[2]{};
bool connected_ : 1 {false};
bool tx_waiting_ : 1 {false}; // frames are queued that the socket has not taken yet
#ifdef USE_SOCKET_TCP_LISTENER
bool server_ : 1 {false};
#endif
};
} // namespace esphome::tcp
-6
View File
@@ -1,6 +0,0 @@
from tests.testing_helpers import ComponentManifestOverride
def override_manifest(manifest: ComponentManifestOverride) -> None:
# bmi270 declares i2c on its motion platform, which the harness does not walk
manifest.dependencies = manifest.dependencies + ["i2c", "motion"]
+15 -4
View File
@@ -36,6 +36,7 @@ sensor:
name: "BMI270 Accel Z"
accuracy_decimals: 4
# Gyroscope axes (unit: °/s)
- platform: motion
motion_id: bmi270_motion
type: gyroscope_x
@@ -75,11 +76,21 @@ motion:
- platform: bmi270
id: bmi270_motion
i2c_id: i2c_bus
accelerometer_range: 8G
accelerometer_odr: 200HZ
gyroscope_range: 1000DPS
gyroscope_odr: 400HZ
# Accelerometer full-scale range: 2G | 4G | 8G | 16G
accelerometer_range: 4G
# Accelerometer output data rate: 12_5HZ | 25HZ | 50HZ | 100HZ |
# 200HZ | 400HZ | 800HZ | 1600HZ
accelerometer_odr: 100HZ
# Gyroscope full-scale range: 125DPS | 250DPS | 500DPS | 1000DPS | 2000DPS
gyroscope_range: 2000DPS
# Gyroscope output data rate: 25HZ | 50HZ | 100HZ | 200HZ |
# 400HZ | 800HZ | 1600HZ | 3200HZ
gyroscope_odr: 200HZ
aux_device: BMM150
aux_address: 0x10
axis_map:
x: y
y: x
-48
View File
@@ -1,48 +0,0 @@
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "esphome/components/bmi270/bmm150_aux.h"
namespace esphome::bmi270::bmm150::testing {
// The axis decode before it used encode_value_le, kept as the reference
static BMM150Data reference_convert(const BMM150Trim &trim, const uint8_t *raw) {
int16_t x = (int16_t) (((int16_t) (int8_t) raw[1] * 32) | (raw[0] >> 3));
int16_t y = (int16_t) (((int16_t) (int8_t) raw[3] * 32) | (raw[2] >> 3));
int16_t z = (int16_t) (((int16_t) (int8_t) raw[5] * 128) | (raw[4] >> 1));
uint16_t rhall = (uint16_t) (((uint16_t) raw[7] << 6) | (raw[6] >> 2));
return BMM150Data{
.x = bmm150_compensate_xy(trim, trim.x1, trim.x2, x, rhall),
.y = bmm150_compensate_xy(trim, trim.y1, trim.y2, y, rhall),
.z = bmm150_compensate_z(trim, z, rhall),
};
}
TEST(BMM150Convert, MatchesTheReferenceForEveryWordOfEachField) {
const BMM150Trim trim{.x1 = 0,
.y1 = 0,
.x2 = 26,
.y2 = 26,
.xy2 = -3,
.xy1 = 29,
.z2 = 760,
.z3 = 0,
.z4 = 0,
.z1 = 24786,
.xyz1 = 7101};
// Sweep one field through every 16-bit value while the others hold mid-range readings
for (int field = 0; field < 4; field++) {
for (uint32_t word = 0; word <= 0xFFFF; word++) {
uint8_t raw[8] = {0x10, 0x12, 0x20, 0xF0, 0x30, 0x08, 0x40, 0x1A};
raw[2 * field] = word & 0xFF;
raw[2 * field + 1] = word >> 8;
const BMM150Data got = bmm150_convert(trim, raw);
const BMM150Data want = reference_convert(trim, raw);
ASSERT_THAT(got.x, ::testing::NanSensitiveFloatEq(want.x)) << "field " << field << " word 0x" << std::hex << word;
ASSERT_THAT(got.y, ::testing::NanSensitiveFloatEq(want.y)) << "field " << field << " word 0x" << std::hex << word;
ASSERT_THAT(got.z, ::testing::NanSensitiveFloatEq(want.z)) << "field " << field << " word 0x" << std::hex << word;
}
}
}
} // namespace esphome::bmi270::bmm150::testing
@@ -1,69 +0,0 @@
#ifdef USE_HOST
#include <gtest/gtest.h>
#include <array>
#include <cstring>
#include "esphome/components/bmi270/bmi270.h"
#include "esphome/components/bmi270/bmi270_config.h"
namespace esphome::bmi270::testing {
// Host builds upload in 256-byte bursts
static constexpr size_t MAX_BURST = 256;
// A BMI270 register file: writes go to consecutive registers, except INIT_DATA, which streams into
// the config memory at the word address set in INIT_ADDR_0/1
class Bmi270Bus final : public i2c::I2CBus {
public:
std::array<uint8_t, 128> regs{};
std::array<uint8_t, sizeof(BMI270_CONFIG_FILE)> config_memory{};
unsigned upload_writes{0};
Bmi270Bus() {
this->regs[BMI270_REG_CHIP_ID] = BMI270_CHIP_ID_VALUE;
this->regs[BMI270_REG_INTERNAL_STATUS] = BMI270_INTERNAL_STATUS_INIT_OK;
}
i2c::ErrorCode write_readv(uint8_t address, const uint8_t *data, size_t size, uint8_t *out,
size_t out_size) override {
if (size == 0)
return i2c::ERROR_INVALID_ARGUMENT;
uint8_t reg = data[0];
if (size > 1) {
if (reg == BMI270_REG_INIT_ADDR_0 || reg == BMI270_REG_INIT_ADDR_0 + 1 || reg == BMI270_REG_INIT_DATA)
++this->upload_writes;
if (reg == BMI270_REG_INIT_DATA) {
size_t offset =
2 * ((this->regs[BMI270_REG_INIT_ADDR_0] & 0x0F) | (this->regs[BMI270_REG_INIT_ADDR_0 + 1] << 4));
if (offset + size - 1 > this->config_memory.size())
return i2c::ERROR_INVALID_ARGUMENT;
std::memcpy(this->config_memory.data() + offset, data + 1, size - 1);
} else {
for (size_t i = 1; i < size; i++)
this->regs[(reg + i - 1) & 0x7F] = data[i];
}
}
for (size_t i = 0; i < out_size; i++)
out[i] = this->regs[(reg + i) & 0x7F];
return i2c::ERROR_OK;
}
};
TEST(BMI270ConfigUpload, UploadsTheWholeConfigFileInOrder) {
Bmi270Bus bus;
BMI270Component imu;
imu.set_i2c_bus(&bus);
imu.set_i2c_address(0x68);
imu.setup();
EXPECT_FALSE(imu.is_failed());
EXPECT_EQ(0, std::memcmp(bus.config_memory.data(), BMI270_CONFIG_FILE, sizeof(BMI270_CONFIG_FILE)));
EXPECT_EQ(bus.regs[BMI270_REG_INIT_CTRL], BMI270_INIT_CTRL_LOAD_DONE);
// One INIT_ADDR write and one INIT_DATA write per burst
EXPECT_EQ(bus.upload_writes, 2 * ((sizeof(BMI270_CONFIG_FILE) + MAX_BURST - 1) / MAX_BURST));
}
} // namespace esphome::bmi270::testing
#endif
@@ -1,9 +1,11 @@
import esphome.codegen as cg
from esphome.components.logger import request_log_listener
from tests.testing_helpers import ComponentManifestOverride
def override_manifest(manifest: ComponentManifestOverride) -> None:
async def to_code_testing(config: object) -> None:
request_log_listener()
cg.add_define("PACKET_INTERFACE_ADDRESSING_PORT_COUNT", 4)
cg.add_define("USE_PACKET_INTERFACE_BASIC_ADDRESSING")
cg.add_define("USE_PACKET_INTERFACE_BASIC_FRAGMENTATION")
@@ -3,6 +3,8 @@
#include <functional>
#include <memory>
#include <vector>
#include <string>
#include "esphome/components/logger/logger.h"
#include "esphome/components/packet_interface/basic_fragmentation.h"
#include "esphome/components/packet_interface/hdlc_reliability.h"
#include "esphome/core/application.h"
@@ -26,6 +28,8 @@ class MockLink : public PacketInterface {
// Before the packet is read, as a log line in a real link would run it
if (this->on_send)
this->on_send();
if (this->sent.size() == this->accept)
return false;
this->sent.push_back(to_vector(data));
return true;
}
@@ -39,6 +43,27 @@ class MockLink : public PacketInterface {
std::vector<Packet> sent;
std::function<void()> on_send;
size_t capacity{SIZE_MAX};
// Packets taken before the link refuses more
size_t accept{SIZE_MAX};
};
// Collects each warning logged
class Warnings {
public:
Warnings() : previous_(logger::global_logger) {
this->logger_.pre_setup();
this->logger_.set_log_level(ESPHOME_LOG_LEVEL_WARN);
this->logger_.add_log_callback(this, [](void *instance, uint8_t, const char *, const char *message, size_t len) {
static_cast<Warnings *>(instance)->lines.emplace_back(message, len);
});
}
~Warnings() { logger::global_logger = this->previous_; }
std::vector<std::string> lines;
private:
logger::Logger *previous_;
logger::Logger logger_{0};
};
struct BufferHolder {
@@ -167,6 +192,19 @@ TEST_F(BasicFragmentationTest, NotStartedWithoutRoomForAllFragments) {
EXPECT_FALSE(a.send(make_packet(101)));
}
TEST_F(BasicFragmentationTest, PacketCutShortIsWarned) {
Peer a(&this->link_a_);
Warnings warnings;
this->link_a_.accept = 0;
EXPECT_FALSE(a.send(make_packet(30)));
EXPECT_TRUE(warnings.lines.empty()); // nothing was sent
this->link_a_.accept = 1;
EXPECT_FALSE(a.send(make_packet(30)));
EXPECT_EQ(this->link_a_.sent.size(), 1u);
ASSERT_EQ(warnings.lines.size(), 1u);
EXPECT_NE(warnings.lines[0].find("Packet cut short, fragment 1 of 3"), std::string::npos);
}
TEST_F(BasicFragmentationTest, InterleavedSourcesNotMixed) {
Peer a(&this->link_a_), c(&this->link_a_), b(&this->link_b_);
a.send(make_packet(20));
@@ -257,6 +257,65 @@ TEST_F(HdlcReliabilityTest, LostAckDoesNotDuplicate) {
EXPECT_TRUE(a.send({0x01}));
}
// Runs a layer's loop until it stops asking, without delivering what it sends
static void run_until_idle(TestHdlc &hdlc) {
for (int i = 0; i != 10 && !hdlc.is_idle(); i++)
hdlc.loop();
}
static size_t count_info(const std::vector<Frame> &frames) {
size_t count = 0;
for (const auto &frame : frames)
count += is_info(frame);
return count;
}
TEST_F(HdlcReliabilityTest, TimeoutResendsOnlyOldestFrame) {
Peer a, b;
pump(a, b);
for (uint8_t i = 0; i != 3; i++)
ASSERT_TRUE(a.send({i}));
pump(a, b, nullptr, [](const Frame &frame) { return is_ack(frame); });
ASSERT_EQ(b.received.size(), 3);
ASSERT_EQ(a.hdlc->outstanding_(), 3);
a.hdlc->on_timeout_();
run_until_idle(*a.hdlc);
EXPECT_EQ(count_info(a.link.sent), 1);
// The peer's answer to the duplicate acknowledges all three
pump(a, b);
EXPECT_EQ(b.received.size(), 3);
EXPECT_EQ(a.hdlc->outstanding_(), 0);
}
TEST_F(HdlcReliabilityTest, RestFollowOnceOldestAcknowledged) {
Peer a, b;
pump(a, b);
for (uint8_t i = 0; i != 3; i++)
ASSERT_TRUE(a.send({i}));
pump(a, b, [](const Frame &frame) { return is_info(frame); });
ASSERT_TRUE(b.received.empty());
a.hdlc->on_timeout_();
run_until_idle(*a.hdlc);
EXPECT_EQ(count_info(a.link.sent), 1);
pump(a, b);
EXPECT_EQ(b.received, (std::vector<Frame>{{0}, {1}, {2}}));
EXPECT_EQ(a.hdlc->outstanding_(), 0);
}
TEST_F(HdlcReliabilityTest, NewFrameWaitsWhileOldestIsResent) {
Peer a, b;
pump(a, b);
ASSERT_TRUE(a.send({0}));
pump(a, b, [](const Frame &frame) { return is_info(frame); });
a.hdlc->on_timeout_();
run_until_idle(*a.hdlc);
ASSERT_TRUE(a.send({1}));
run_until_idle(*a.hdlc);
EXPECT_EQ(count_info(a.link.sent), 1);
pump(a, b);
EXPECT_EQ(b.received, (std::vector<Frame>{{0}, {1}}));
}
TEST_F(HdlcReliabilityTest, QueueFull) {
Peer a(2), b(2);
pump(a, b);
@@ -0,0 +1,94 @@
#include <gtest/gtest.h>
#include "esphome/components/packet_interface/listen_before_talk.h"
namespace esphome::packet_interface::lbt_testing {
static constexpr uint32_t START = 10000;
static constexpr uint32_t MAX_BUSY = ListenBeforeTalk::DEFAULT_MAX_BUSY_MS;
TEST(ListenBeforeTalkTest, SendsWhenNotBusy) {
ListenBeforeTalk lbt;
EXPECT_TRUE(lbt.may_send(false, START, START));
}
TEST(ListenBeforeTalkTest, RefusesWhileBusyUpToLimit) {
ListenBeforeTalk lbt;
EXPECT_FALSE(lbt.may_send(true, START, START));
// Refused every 50 ms, as the reliability layer retries
uint32_t now = START;
while (now - START < MAX_BUSY - 50) {
now += 50;
EXPECT_FALSE(lbt.may_send(true, now, now));
}
now += 50;
EXPECT_TRUE(lbt.may_send(true, now, now));
EXPECT_EQ(lbt.busy_for(now), MAX_BUSY);
}
TEST(ListenBeforeTalkTest, BusyFlagThatNeverClearsReleasedForSlowSends) {
ListenBeforeTalk lbt;
// A send every 10 s, as session keep-alives, always finding the radio busy
EXPECT_FALSE(lbt.may_send(true, START, START));
EXPECT_TRUE(lbt.may_send(true, START + 10000, START + 10000));
}
TEST(ListenBeforeTalkTest, FreeRadioEndsBusyPeriod) {
ListenBeforeTalk lbt;
EXPECT_FALSE(lbt.may_send(true, START, START));
EXPECT_TRUE(lbt.may_send(false, START + 1500, START + 1500));
// A new busy period starts, so the earlier one does not count
EXPECT_FALSE(lbt.may_send(true, START + MAX_BUSY + 100, START + MAX_BUSY + 100));
EXPECT_EQ(lbt.busy_for(START + MAX_BUSY + 100), 0);
}
TEST(ListenBeforeTalkTest, EndBusyStartsNewPeriod) {
ListenBeforeTalk lbt;
EXPECT_FALSE(lbt.may_send(true, START, START));
// The link saw the radio free between sends, so a later reception is a new busy period
lbt.end_busy();
EXPECT_FALSE(lbt.may_send(true, START + MAX_BUSY + 100, START + MAX_BUSY + 100));
EXPECT_EQ(lbt.busy_for(START + MAX_BUSY + 100), 0);
}
TEST(ListenBeforeTalkTest, LimitCanBeLonger) {
ListenBeforeTalk lbt;
lbt.set_max_busy(8000);
EXPECT_FALSE(lbt.may_send(true, START, START));
EXPECT_FALSE(lbt.may_send(true, START + 7999, START + 7999));
EXPECT_TRUE(lbt.may_send(true, START + 8000, START + 8000));
}
static constexpr uint32_t TURNAROUND = 250;
TEST(ListenBeforeTalkTest, SendInLaterPassWaitsForTurnaround) {
ListenBeforeTalk lbt;
lbt.set_turnaround(TURNAROUND);
lbt.sent(START + 300, START);
EXPECT_FALSE(lbt.may_send(false, START + 320, START + 320));
EXPECT_FALSE(lbt.may_send(false, START + 300 + TURNAROUND - 1, START + 520));
EXPECT_TRUE(lbt.may_send(false, START + 300 + TURNAROUND, START + 540));
}
TEST(ListenBeforeTalkTest, SendInSamePassNotHeld) {
ListenBeforeTalk lbt;
lbt.set_turnaround(TURNAROUND);
// The next fragment of the same packet
lbt.sent(START + 300, START);
EXPECT_TRUE(lbt.may_send(false, START + 301, START));
}
TEST(ListenBeforeTalkTest, ReceptionEndsTurnaround) {
ListenBeforeTalk lbt;
lbt.set_turnaround(TURNAROUND);
lbt.sent(START + 300, START);
lbt.received();
EXPECT_TRUE(lbt.may_send(false, START + 320, START + 320));
}
TEST(ListenBeforeTalkTest, NoTurnaroundByDefault) {
ListenBeforeTalk lbt;
lbt.sent(START + 300, START);
EXPECT_TRUE(lbt.may_send(false, START + 320, START + 320));
}
} // namespace esphome::packet_interface::lbt_testing
@@ -0,0 +1,213 @@
#include <gtest/gtest.h>
#include <cstdint>
#include <vector>
#include "esphome/components/packet_interface/radio_link.h"
#include "esphome/core/application.h"
namespace esphome::packet_interface::radio_link_testing {
using Packet = std::vector<uint8_t>;
static constexpr uint32_t START = 10000;
static constexpr uint32_t MAX_BUSY = ListenBeforeTalk::DEFAULT_MAX_BUSY_MS;
class FakeListener {
public:
virtual void on_packet(const std::vector<uint8_t> &packet, float rssi, float snr) = 0;
};
enum class FakeError { NONE, BUSY };
class FakeRadio : public Component {
public:
bool is_receiving() { return this->receiving; }
void register_listener(FakeListener *listener) { this->listener = listener; }
void fail() { this->mark_failed(); }
FakeError transmit_packet(const uint8_t *data, size_t length) {
this->sent.emplace_back(data, data + length);
return this->result;
}
FakeListener *listener{nullptr};
std::vector<Packet> sent;
bool receiving{false};
FakeError result{FakeError::NONE};
};
// Reads the time that set_time() sets
class TestLink : public RadioLink<FakeRadio, FakeListener, FakeError, 16> {
public:
using RadioLink::RadioLink;
uint8_t not_understood_count() const { return this->not_understood_count_; }
protected:
uint32_t current_time_ms() const override { return App.get_loop_component_start_time(); }
};
static void set_time(uint32_t now) { LoopBlockingGuard guard{nullptr, nullptr, now}; }
class RadioLinkTest : public ::testing::Test {
protected:
void SetUp() override {
this->radio_.call();
this->link_.call();
}
bool send_() {
static const Packet PACKET{1, 2, 3};
return this->link_.send_to_interface(PacketBuffer(PACKET), {});
}
FakeRadio radio_;
TestLink link_{&radio_, 16};
};
TEST_F(RadioLinkTest, LoopRunsOnlyWhileBusy) {
EXPECT_EQ(this->radio_.listener, &this->link_);
EXPECT_TRUE(this->link_.is_idle());
set_time(START);
this->radio_.receiving = true;
EXPECT_FALSE(this->send_());
EXPECT_TRUE(this->link_.is_in_loop_state());
this->link_.loop();
EXPECT_TRUE(this->link_.is_in_loop_state());
this->radio_.receiving = false;
this->link_.loop();
EXPECT_TRUE(this->link_.is_idle());
EXPECT_TRUE(this->radio_.sent.empty());
}
TEST_F(RadioLinkTest, ReceptionAfterStalePeriodIsNotSentOver) {
set_time(START);
this->radio_.receiving = true;
EXPECT_FALSE(this->send_());
// The reception ends with no send to see it
this->radio_.receiving = false;
this->link_.loop();
// A new reception, longer after the first than the limit, still holds the send back
set_time(START + MAX_BUSY + 100);
this->radio_.receiving = true;
EXPECT_FALSE(this->send_());
EXPECT_TRUE(this->radio_.sent.empty());
}
TEST_F(RadioLinkTest, BusyFlagThatNeverClearsIsSentOver) {
set_time(START);
this->radio_.receiving = true;
EXPECT_FALSE(this->send_());
this->link_.loop();
set_time(START + MAX_BUSY);
EXPECT_TRUE(this->send_());
ASSERT_EQ(this->radio_.sent.size(), 1u);
EXPECT_EQ(this->radio_.sent[0], (Packet{1, 2, 3}));
}
TEST_F(RadioLinkTest, EmptyPacketCountsAsSentWithoutTransmitting) {
static const Packet EMPTY;
EXPECT_TRUE(this->link_.send_to_interface(PacketBuffer(EMPTY), {}));
EXPECT_TRUE(this->radio_.sent.empty());
}
TEST_F(RadioLinkTest, FailedRadioRefusesSends) {
this->radio_.fail();
EXPECT_FALSE(this->send_());
EXPECT_FALSE(this->send_());
EXPECT_TRUE(this->radio_.sent.empty());
}
TEST_F(RadioLinkTest, RadioFailingWhileBusyEndsBusyPeriod) {
set_time(START);
this->radio_.receiving = true;
EXPECT_FALSE(this->send_());
EXPECT_TRUE(this->link_.is_in_loop_state());
this->radio_.fail();
this->link_.loop();
EXPECT_TRUE(this->link_.is_idle());
}
TEST_F(RadioLinkTest, ReceivedPacketCarriesSignal) {
Packet received;
PacketMetaData meta;
this->link_.add_packet_interface_listener([&](const PacketBuffer &data, const PacketMetaData &meta_data) {
received.resize(data.size());
data.copy_to(received.data(), received.size());
meta = meta_data;
});
this->link_.on_packet({4, 5}, -80.0f, 7.5f);
EXPECT_EQ(received, (Packet{4, 5}));
EXPECT_FLOAT_EQ(meta.rssi, -80.0f);
EXPECT_FLOAT_EQ(meta.snr, 7.5f);
}
// After a send, a send in a later loop pass waits for the peer's reply, which may come at once
TEST_F(RadioLinkTest, LaterSendWaitsForPeerToReply) {
this->link_.set_turnaround(250);
set_time(START);
EXPECT_TRUE(this->send_());
EXPECT_TRUE(this->send_()); // the same loop pass, as the fragments of one packet
set_time(START + 100);
EXPECT_FALSE(this->send_());
set_time(START + 250);
EXPECT_TRUE(this->send_());
set_time(START + 300);
this->radio_.listener->on_packet(Packet{4, 5}, -50, 5);
EXPECT_TRUE(this->send_());
EXPECT_EQ(this->radio_.sent.size(), 4u);
}
// A packet in two parts, as a layer adds its header, is joined before it goes to the radio
TEST_F(RadioLinkTest, SplitPacketIsJoined) {
static const Packet HEADER{9, 8};
static const Packet BODY{1, 2, 3};
PacketBuffer body(BODY);
EXPECT_TRUE(this->link_.send_to_interface(PacketBuffer(HEADER.data(), HEADER.size(), &body, nullptr, 0), {}));
ASSERT_EQ(this->radio_.sent.size(), 1u);
EXPECT_EQ(this->radio_.sent[0], (Packet{9, 8, 1, 2, 3}));
}
TEST_F(RadioLinkTest, OversizedPacketRefused) {
static const Packet LARGEST(16, 0x55);
static const Packet OVERSIZED(17, 0x55);
EXPECT_FALSE(this->link_.send_to_interface(PacketBuffer(OVERSIZED), {}));
EXPECT_TRUE(this->radio_.sent.empty());
EXPECT_TRUE(this->link_.send_to_interface(PacketBuffer(LARGEST), {}));
EXPECT_EQ(this->radio_.sent.size(), 1u);
}
TEST_F(RadioLinkTest, TransmitErrorIsReported) {
this->radio_.result = FakeError::BUSY;
EXPECT_FALSE(this->send_());
this->radio_.result = FakeError::NONE;
EXPECT_TRUE(this->send_());
}
// The radio receives packets up to its own limit, which can be more than the link's
TEST_F(RadioLinkTest, OversizedReceptionDropped) {
std::vector<size_t> sizes;
this->link_.add_packet_interface_listener(
[&](const PacketBuffer &data, const PacketMetaData &) { sizes.push_back(data.size()); });
this->link_.on_packet(Packet(17, 0x55), -80.0f, 7.5f);
this->link_.on_packet(Packet(16, 0x55), -80.0f, 7.5f);
EXPECT_EQ(sizes, std::vector<size_t>{16});
}
// A send made over a busy flag that seemed stuck lets the radio listen again, so a reception that starts before
// loop() runs is waited for in a new busy period
TEST_F(RadioLinkTest, ForcedSendEndsBusyPeriod) {
set_time(START);
this->radio_.receiving = true;
EXPECT_FALSE(this->send_());
set_time(START + MAX_BUSY);
EXPECT_TRUE(this->send_());
set_time(START + MAX_BUSY + 100);
EXPECT_FALSE(this->send_());
EXPECT_EQ(this->radio_.sent.size(), 1u);
}
TEST_F(RadioLinkTest, AcceptedPacketEndsRunOfOversizedOnes) {
this->link_.on_packet(Packet(17, 0x55), -80.0f, 7.5f);
EXPECT_EQ(this->link_.not_understood_count(), 1);
this->link_.on_packet(Packet(16, 0x55), -80.0f, 7.5f);
EXPECT_EQ(this->link_.not_understood_count(), 0);
}
} // namespace esphome::packet_interface::radio_link_testing
@@ -29,9 +29,11 @@ class MockLink : public PacketInterface {
return true;
}
void inject(const Packet &packet) { this->on_receive_from_interface_(PacketBuffer(packet), {}); }
size_t get_send_capacity() const override { return this->capacity; }
std::vector<Packet> sent;
std::function<void()> on_send;
size_t capacity{SIZE_MAX};
};
static constexpr size_t ROLLING_TRAILER_SIZE = 16;
@@ -93,6 +95,16 @@ TEST_F(XxteaEncryptionTest, MaxPacketSizeAllowsForTrailerAndWords) {
EXPECT_EQ(c.encryption->get_max_packet_size(), 64 - TRAILER_SIZE);
}
// A link such as TCP can run out of room; a fragmentation layer above must see that
TEST_F(XxteaEncryptionTest, ForwardsTheLinksSendCapacity) {
Peer a;
EXPECT_EQ(a.encryption->get_send_capacity(), SIZE_MAX);
a.link.capacity = 1;
EXPECT_EQ(a.encryption->get_send_capacity(), 1u);
a.link.capacity = 0;
EXPECT_EQ(a.encryption->get_send_capacity(), 0u);
}
static void round_trip_all_sizes(bool rolling_code, size_t trailer_size) {
Peer a(0x12345678, 64, rolling_code), b(0x12345678, 64, rolling_code);
a.introduce(b);
@@ -0,0 +1,19 @@
sx126x:
cs_pin: ${cs_pin}
rst_pin: ${rst_pin}
busy_pin: ${busy_pin}
dio1_pin: ${dio1_pin}
hw_version: sx1262
rf_switch: true
frequency: 917MHz
modulation: LORA
crc_enable: true
packet_interface:
- platform: sx126x
id: sx126x_packet_interface
addressing:
address: 0x0001
destination: 0x0002
reliability:
ack_delay: 100ms
@@ -0,0 +1,59 @@
#include "sx126x_test_helpers.h"
namespace esphome::sx126x::testing {
// The radio link refuses to send while is_receiving(), as a send would lose the packet
TEST(SX126xReceiving, ReportsAPacketOnTheWayOrWaiting) {
RadioHardware hw;
hw.configure(true, true);
EXPECT_FALSE(hw.radio.is_receiving());
hw.irq = IRQ_HEADER_VALID;
EXPECT_TRUE(hw.radio.is_receiving());
hw.irq = IRQ_SYNCWORD_VALID;
EXPECT_TRUE(hw.radio.is_receiving());
hw.irq = IRQ_RX_DONE;
EXPECT_TRUE(hw.radio.is_receiving());
// Held by a send that found it waiting
EXPECT_EQ(hw.radio.transmit_packet(hw.packet), SX126xError::SX126X_ERROR_BUSY);
EXPECT_TRUE(hw.radio.is_receiving());
hw.radio.loop();
EXPECT_FALSE(hw.radio.is_receiving());
}
// The link would otherwise send over a reception it could not see
TEST(SX126xReceiving, FailedReadCountsAsReceiving) {
RadioHardware hw;
hw.configure(true, true);
hw.clear_trace();
hw.fail_at = 1; // BUSY stays high for the IRQ read
EXPECT_TRUE(hw.radio.is_receiving());
hw.clear_trace();
EXPECT_FALSE(hw.radio.is_receiving());
}
TEST(SX126xReceiving, NotWhileSendingOrAsleep) {
RadioHardware hw;
hw.configure(true, false);
hw.irq = IRQ_HEADER_VALID;
hw.clear_trace();
EXPECT_FALSE(hw.radio.is_receiving());
EXPECT_TRUE(hw.transactions.empty()); // A sleeping radio is not woken to ask
}
// A valid header or sync word is flagged, but only the end of a packet is signalled on DIO1
TEST(SX126xReceiving, ReceiveFlagsHeaderAndSyncWithoutSignallingThem) {
RadioHardware hw;
hw.configure(true, true);
const auto params = std::find_if(hw.transactions.rbegin(), hw.transactions.rend(), [](const auto &command) {
return !command.empty() && command[0] == RADIO_SET_DIOIRQPARAMS;
});
ASSERT_NE(params, hw.transactions.rend());
ASSERT_GE(params->size(), 5u);
const uint16_t flags = encode_uint16((*params)[1], (*params)[2]);
const uint16_t dio1 = encode_uint16((*params)[3], (*params)[4]);
EXPECT_EQ(flags & (IRQ_HEADER_VALID | IRQ_SYNCWORD_VALID), IRQ_HEADER_VALID | IRQ_SYNCWORD_VALID);
EXPECT_EQ(dio1 & (IRQ_HEADER_VALID | IRQ_SYNCWORD_VALID), 0);
EXPECT_NE(dio1 & IRQ_RX_DONE, 0);
}
} // namespace esphome::sx126x::testing
@@ -0,0 +1,9 @@
substitutions:
cs_pin: GPIO12
rst_pin: GPIO13
busy_pin: GPIO25
dio1_pin: GPIO26
packages:
spi: !include ../../test_build_components/common/spi/esp32-idf.yaml
sx126x: !include common-packet-interface.yaml
@@ -0,0 +1,17 @@
sx127x:
cs_pin: ${cs_pin}
rst_pin: ${rst_pin}
dio0_pin: ${dio0_pin}
frequency: 917MHz
modulation: LORA
preamble_size: 8
crc_enable: true
packet_interface:
- platform: sx127x
id: sx127x_packet_interface
addressing:
address: 0x0001
destination: 0x0002
reliability:
ack_delay: 100ms
@@ -0,0 +1,64 @@
#include "sx127x_test_helpers.h"
namespace esphome::sx127x::testing {
// The radio link refuses to send while is_receiving(), as a send would lose the packet
TEST(SX127xReceiving, LoRaReportsAPacketOnTheWayOrWaiting) {
RadioHardware hw;
hw.configure(true, true);
EXPECT_FALSE(hw.radio.is_receiving());
for (const uint8_t stat : {MODEM_STAT_SIGNAL_DETECTED, MODEM_STAT_SIGNAL_SYNCHRONIZED, MODEM_STAT_HEADER_VALID}) {
hw.regs[REG_MODEM_STAT] = stat;
EXPECT_TRUE(hw.radio.is_receiving()) << int(stat);
}
hw.regs[REG_MODEM_STAT] = 0;
hw.receive({0x01, 0x02});
EXPECT_TRUE(hw.radio.is_receiving());
// Held by a send that found it waiting
EXPECT_EQ(hw.radio.transmit_packet(hw.packet), SX127xError::SX127X_ERROR_BUSY);
EXPECT_TRUE(hw.radio.is_receiving());
hw.radio.loop();
EXPECT_FALSE(hw.radio.is_receiving());
}
TEST(SX127xReceiving, FskReportsAMatchedSyncWord) {
RadioHardware hw;
hw.configure(false, true);
EXPECT_FALSE(hw.radio.is_receiving());
hw.regs[REG_IRQ_FLAGS_1] = IRQ_FLAGS_1_PREAMBLE_DETECT;
EXPECT_FALSE(hw.radio.is_receiving());
hw.regs[REG_IRQ_FLAGS_1] = IRQ_FLAGS_1_SYNC_ADDRESS_MATCH;
EXPECT_TRUE(hw.radio.is_receiving());
hw.regs[REG_IRQ_FLAGS_1] = 0;
hw.receive({0x01, 0x02});
EXPECT_TRUE(hw.radio.is_receiving());
}
TEST(SX127xReceiving, NotAfterRawTxOrWhileSendingOrAsleep) {
RadioHardware hw;
hw.configure(true, true);
hw.radio.set_mode_tx(); // Its TX_DONE raises DIO0, which is not a packet
EXPECT_TRUE(hw.dio0.digital_read());
EXPECT_FALSE(hw.radio.is_receiving());
hw.radio.set_mode_rx();
TransmitListener listener;
hw.auto_complete = false;
ASSERT_EQ(hw.radio.start_transmit_async(&listener, hw.packet), SX127xError::SX127X_ERROR_NONE);
hw.regs[REG_MODEM_STAT] = MODEM_STAT_HEADER_VALID;
EXPECT_FALSE(hw.radio.is_receiving());
EXPECT_TRUE(hw.radio.cancel_transmit_async(&listener));
RadioHardware asleep;
asleep.configure(true, false);
asleep.regs[REG_MODEM_STAT] = MODEM_STAT_HEADER_VALID;
EXPECT_FALSE(asleep.radio.is_receiving());
}
TEST(SX127xReceiving, FskFifoHoldsTheLengthByte) {
RadioHardware hw;
hw.configure(false, true);
EXPECT_EQ(hw.radio.get_max_packet_size(), 63u);
EXPECT_EQ(hw.regs[REG_PAYLOAD_LENGTH_LSB], 63);
}
} // namespace esphome::sx127x::testing
@@ -0,0 +1,30 @@
#include "sx127x_test_helpers.h"
namespace esphome::sx127x::testing {
// Values from the datasheet formulas for the RadioHardware defaults (433.92 MHz, 4800 bps,
// 5 kHz deviation, 8 symbol preamble), independent of the code under test
static constexpr uint32_t FRF = 0x6C7AE1; // 433920000 * 2^19 / 32 MHz
static constexpr uint16_t BITRATE = 0x1A0B; // 32 MHz / 4800, rounded
static constexpr uint16_t FDEV = 0x0051; // 5000 * 2^19 / 32 MHz
static constexpr uint16_t PREAMBLE = 8;
static uint32_t reg16(const RadioHardware &hw, uint8_t msb) { return (hw.regs[msb] << 8) | hw.regs[msb + 1]; }
TEST(SX127xRegisters, FskWritesEachByteOfTheMultiByteSettings) {
RadioHardware hw;
hw.configure(false, false);
EXPECT_EQ((hw.regs[REG_FRF_MSB] << 16) | reg16(hw, REG_FRF_MID), FRF);
EXPECT_EQ(reg16(hw, REG_BITRATE_MSB), BITRATE);
EXPECT_EQ(reg16(hw, REG_FDEV_MSB), FDEV);
EXPECT_EQ(reg16(hw, REG_PREAMBLE_SIZE_MSB), PREAMBLE);
}
TEST(SX127xRegisters, LoraWritesEachByteOfTheMultiByteSettings) {
RadioHardware hw;
hw.configure(true, false);
EXPECT_EQ((hw.regs[REG_FRF_MSB] << 16) | reg16(hw, REG_FRF_MID), FRF);
EXPECT_EQ(reg16(hw, REG_PREAMBLE_LEN_MSB), PREAMBLE);
}
} // namespace esphome::sx127x::testing
@@ -28,7 +28,8 @@ class TestPin : public GPIOPin {
};
// An SX127x register file behind the real software SPI bus. The first byte of each
// transaction is the address, with bit 7 set for a write; FIFO reads and writes stream.
// transaction is the address, with bit 7 set for a write; FIFO reads and writes stream, and
// further bytes of any other write go to the next register.
class RadioHardware {
public:
RadioHardware() {
@@ -86,6 +87,7 @@ class RadioHardware {
this->radio.set_preamble_size(8);
this->radio.set_crc_enable(true);
this->radio.set_sync_value({0x12});
this->radio.set_rx_floor(-94); // FSK setup converts it to an int, so it must be set
}
~RadioHardware() {
// The configuration retry interval (id 0) must not outlive the radio
@@ -217,6 +219,8 @@ class RadioHardware {
this->fifo.push_back(value);
return;
}
// As on the chip, each further byte of a burst goes to the next register
this->addr_ = 0x80 | ((addr + 1) & 0x7F);
if (addr == REG_OP_MODE) {
this->write_mode_(value);
return;
@@ -0,0 +1,8 @@
substitutions:
cs_pin: GPIO12
rst_pin: GPIO13
dio0_pin: GPIO26
packages:
spi: !include ../../test_build_components/common/spi/esp32-idf.yaml
sx127x: !include common-packet-interface.yaml
+18
View File
@@ -0,0 +1,18 @@
from esphome.components import socket as socket_component
from esphome.core import CORE
from esphome.types import ConfigType
from tests.testing_helpers import ComponentManifestOverride
def override_manifest(manifest: ComponentManifestOverride) -> None:
async def to_code_testing(config: ConfigType) -> None:
socket_component.require_tcp_listener()
# No entity platforms are configured, so count the connected sensor to emit USE_BINARY_SENSOR
CORE.platform_counts["binary_sensor"] += 1
manifest.to_code = to_code_testing
manifest.dependencies = manifest.dependencies + [
"binary_sensor",
"packet_interface",
"socket",
]
+4
View File
@@ -0,0 +1,4 @@
packet_interface:
- platform: tcp
role: server
port: 6000
+36
View File
@@ -0,0 +1,36 @@
wifi:
ssid: MySSID
password: password1
packet_interface:
- platform: tcp
id: tcp_client_link
host: 192.168.1.50
port: 6060
keep_alive: 5s
encryption: Johnny Cash
fragmentation:
max_packet_size: 2048
connected:
name: TCP link connected
- platform: tcp
id: tcp_server_link
role: server
port: 6061
allowed_ips:
- 192.168.1.0/24
sensor:
- platform: template
id: tcp_sensor
lambda: return 1.0;
packet_transport:
- platform: packet_interface
packet_interface: tcp_client_link
sensors:
- tcp_sensor
- platform: packet_interface
packet_interface: tcp_server_link
sensors:
- tcp_sensor
@@ -0,0 +1,358 @@
#include <gtest/gtest.h>
#include <csignal>
#include <cstddef>
#include <fcntl.h>
#include <cstdint>
#include <memory>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
#include <vector>
#include "esphome/components/tcp/packet_interface/tcp_packet_interface.h"
#include "esphome/core/application.h"
#include "esphome/core/wake.h"
#ifdef USE_HOST
namespace esphome::tcp::testing {
// Copies a packet into a vector, for comparing in tests
static std::vector<uint8_t> to_vector(const esphome::packet_interface::PacketBuffer &data) {
std::vector<uint8_t> result(data.size());
data.copy_to(result.data(), result.size());
return result;
}
using packet_interface::PacketBuffer;
using packet_interface::PacketMetaData;
using Packet = std::vector<uint8_t>;
// The receive buffer is a base, so it is set up before the link's constructor sees it
struct TcpBufferStorage {
uint8_t rx_buffer_storage[64]{};
};
class TestTcp : public TcpBufferStorage, public TcpPacketInterface {
public:
TestTcp() : TcpPacketInterface(this->rx_buffer_storage) {
this->set_host("peer");
this->set_port(1);
}
socket::TcpClientLink &link() { return this->link_; }
};
// A layer stacked on the link, to check that the session state reaches it
class UpperLayer : public packet_interface::PacketInterface {
public:
explicit UpperLayer(PacketInterface *lower) : packet_interface::PacketInterface(lower->get_max_packet_size()) {
this->stack_on_(lower, packet_interface::CAPABILITY_ENCRYPTION);
}
bool send_to_interface(const PacketBuffer &, const PacketMetaData &) override { return true; }
};
struct End {
End() {
this->link.add_packet_interface_listener(
[this](const PacketBuffer &data, const PacketMetaData &) { this->received.push_back(to_vector(data)); });
this->link.add_on_session_state_callback([this](bool connected) { this->states.push_back(connected); });
this->link.setup();
}
bool send(const Packet &data) { return this->link.send_to_interface(PacketBuffer(data), {}); }
TestTcp link;
std::vector<Packet> received;
std::vector<bool> states;
};
class TcpPacketInterfaceTest : public ::testing::Test {
protected:
void SetUp() override {
signal(SIGPIPE, SIG_IGN);
App.~Application();
new (&App) Application();
static char name[] = "tcp-tests";
static char friendly_name[] = "";
App.pre_setup(name, sizeof(name) - 1, friendly_name, 0);
set_time(1000);
int fds[2];
ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0);
this->a.link.link().adopt(std::make_unique<socket::Socket>(fds[0]));
this->b.link.link().adopt(std::make_unique<socket::Socket>(fds[1]));
this->loops(1);
}
void TearDown() override {
this->a.link.link().close();
this->b.link.link().close();
App.~Application();
new (&App) Application(); // later tests and the test listener use App
}
static void set_time(uint32_t now) { LoopBlockingGuard guard{nullptr, nullptr, now}; }
void loops(int count) {
for (int i = 0; i != count; i++) {
this->a.link.loop();
this->b.link.loop();
}
}
End a, b;
};
TEST_F(TcpPacketInterfaceTest, ProvidesReliabilitySessionAndAddressing) {
for (auto capability : {packet_interface::CAPABILITY_RELIABILITY, packet_interface::CAPABILITY_SESSION,
packet_interface::CAPABILITY_ADDRESSING})
EXPECT_TRUE(this->a.link.has_capability(capability));
EXPECT_EQ(this->a.states, std::vector<bool>{true});
EXPECT_TRUE(this->a.link.is_connected());
}
TEST_F(TcpPacketInterfaceTest, PacketsBothWays) {
Packet big(64);
for (size_t i = 0; i != big.size(); i++)
big[i] = i;
ASSERT_TRUE(this->a.send({1, 2, 3}));
ASSERT_TRUE(this->a.send(big));
ASSERT_TRUE(this->b.send({9}));
this->loops(3);
EXPECT_EQ(this->b.received, (std::vector<Packet>{{1, 2, 3}, big}));
EXPECT_EQ(this->a.received, std::vector<Packet>{{9}});
EXPECT_FALSE(this->a.send(Packet(65)));
}
TEST_F(TcpPacketInterfaceTest, SessionReachesLayersAbove) {
UpperLayer upper(&this->a.link);
std::vector<bool> states;
upper.add_on_session_state_callback([&states](bool connected) { states.push_back(connected); });
EXPECT_TRUE(upper.has_capability(packet_interface::CAPABILITY_SESSION));
this->b.link.link().close(); // the peer goes away
this->loops(3);
EXPECT_EQ(states, std::vector<bool>{false});
}
TEST_F(TcpPacketInterfaceTest, KeepAliveKeepsIdleLinkUp) {
for (uint32_t now = 1000; now <= 61000; now += 5000) {
set_time(now);
this->loops(2);
}
EXPECT_TRUE(this->a.link.is_connected());
EXPECT_TRUE(this->b.link.is_connected());
EXPECT_TRUE(this->a.received.empty()); // keep-alives are not passed up
}
TEST_F(TcpPacketInterfaceTest, SilentPeerClosesLink) {
set_time(1000 + 30001);
this->a.link.loop(); // b has sent nothing for the default timeout of 30 s
EXPECT_FALSE(this->a.link.is_connected());
EXPECT_EQ(this->a.states, (std::vector<bool>{true, false}));
}
TEST_F(TcpPacketInterfaceTest, SlowerPeerMatchedByTimeout) {
// b sends keep-alives every 20 s; three of a's own 5 s intervals would close the link
this->a.link.set_keep_alive(5000);
this->a.link.set_receive_timeout(60000);
this->b.link.set_keep_alive(20000);
this->b.link.set_receive_timeout(60000);
for (uint32_t now = 1000; now <= 121000; now += 5000) {
set_time(now);
this->loops(2);
}
EXPECT_TRUE(this->a.link.is_connected());
EXPECT_TRUE(this->b.link.is_connected());
EXPECT_EQ(this->a.states, std::vector<bool>{true});
}
TEST_F(TcpPacketInterfaceTest, ConnectedSensorStartsFalse) {
TestTcp link;
binary_sensor::BinarySensor sensor;
link.set_connected_binary_sensor(&sensor);
link.setup();
EXPECT_TRUE(sensor.has_state());
EXPECT_FALSE(sensor.state);
}
TEST_F(TcpPacketInterfaceTest, OversizedLengthClosesLink) {
End c;
int fds[2];
ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0);
c.link.link().adopt(std::make_unique<socket::Socket>(fds[0]));
c.link.loop();
uint8_t header[2] = {0xFF, 0x00}; // 255 bytes, more than 64
ASSERT_EQ(::write(fds[1], header, sizeof(header)), 2);
c.link.loop();
EXPECT_FALSE(c.link.is_connected());
EXPECT_EQ(c.states, (std::vector<bool>{true, false}));
::close(fds[1]);
}
TEST_F(TcpPacketInterfaceTest, NotSentWhileDown) {
this->a.link.link().close();
this->a.link.loop();
EXPECT_FALSE(this->a.send({1}));
}
// A write that fails drops the link and the packet with it, so the packet is reported as not sent
TEST_F(TcpPacketInterfaceTest, FailedWriteReportsNotSent) {
this->b.link.link().close();
EXPECT_FALSE(this->a.send({1}));
}
TEST_F(TcpPacketInterfaceTest, FrameAssembledAcrossReads) {
End c;
int fds[2];
ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0);
c.link.link().adopt(std::make_unique<socket::Socket>(fds[0]));
c.link.loop();
// A keep-alive, then a 3 byte packet in three writes: half the length, the rest of it, then the payload
const uint8_t keep_alive[2] = {0x00, 0x00};
ASSERT_EQ(::write(fds[1], keep_alive, 2), 2);
c.link.loop();
const uint8_t length_low = 0x03;
ASSERT_EQ(::write(fds[1], &length_low, 1), 1);
c.link.loop();
const uint8_t length_high_and_start[2] = {0x00, 0xAA};
ASSERT_EQ(::write(fds[1], length_high_and_start, 2), 2);
c.link.loop();
EXPECT_TRUE(c.received.empty());
const uint8_t rest[2] = {0xBB, 0xCC};
ASSERT_EQ(::write(fds[1], rest, 2), 2);
c.link.loop();
EXPECT_EQ(c.received, (std::vector<Packet>{{0xAA, 0xBB, 0xCC}}));
EXPECT_TRUE(c.link.is_connected());
::close(fds[1]);
}
// A peer that sends without a pause is read a few frames at a time, so other components still run
TEST_F(TcpPacketInterfaceTest, FramesReadPerLoopAreLimited) {
End c;
int fds[2];
ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0);
c.link.link().adopt(std::make_unique<socket::Socket>(fds[0]));
c.link.loop();
const uint8_t frame[3] = {0x01, 0x00, 0x42};
for (int i = 0; i != 10; i++)
ASSERT_EQ(::write(fds[1], frame, sizeof(frame)), 3);
c.link.loop();
EXPECT_EQ(c.received.size(), 8u);
c.link.loop();
EXPECT_EQ(c.received.size(), 10u);
::close(fds[1]);
}
// Once frames wait for a peer that is not reading, the capacity reported is what still fits, so a fragmented packet
// is not started only to be cut short
TEST_F(TcpPacketInterfaceTest, CapacityFollowsBacklog) {
End c;
int fds[2];
ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, fds), 0);
c.link.link().adopt(std::make_unique<socket::Socket>(fds[0]));
c.link.loop();
EXPECT_EQ(c.link.get_send_capacity(), SIZE_MAX);
const Packet packet(c.link.get_max_packet_size(), 0x55);
for (int i = 0; i != 100000 && c.link.get_send_capacity() == SIZE_MAX; i++)
c.send(packet);
ASSERT_NE(c.link.get_send_capacity(), SIZE_MAX);
EXPECT_LT(c.link.get_send_capacity(), 1024 / (packet.size() + 2) + 1);
// Once the peer reads everything, the link takes what is sent again
ASSERT_EQ(fcntl(fds[1], F_SETFL, O_NONBLOCK), 0);
uint8_t sink[4096];
for (int i = 0; i != 1000 && c.link.get_send_capacity() != SIZE_MAX; i++) {
while (::read(fds[1], sink, sizeof(sink)) > 0) {
}
c.link.loop();
}
EXPECT_EQ(c.link.get_send_capacity(), SIZE_MAX);
::close(fds[1]);
}
// Waits in the main loop's select(), which marks the sockets that are ready to read
static void wait_for_sockets() { esphome::internal::wakeable_delay(5); }
// The server role, accepting connections on a loopback port
class TcpServerTest : public ::testing::Test {
protected:
void SetUp() override {
signal(SIGPIPE, SIG_IGN);
App.~Application();
new (&App) Application();
static char name[] = "tcp-tests";
static char friendly_name[] = "";
App.pre_setup(name, sizeof(name) - 1, friendly_name, 0);
set_time(1000);
this->port = free_port();
this->server.link.set_server(true);
this->server.link.set_port(this->port);
}
void TearDown() override {
this->server.link.on_shutdown();
for (int fd : this->clients)
::close(fd);
App.~Application();
new (&App) Application(); // later tests and the test listener use App
}
static void set_time(uint32_t now) { LoopBlockingGuard guard{nullptr, nullptr, now}; }
static uint16_t free_port() {
int fd = ::socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in addr{};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
socklen_t len = sizeof(addr);
EXPECT_EQ(::bind(fd, reinterpret_cast<struct sockaddr *>(&addr), len), 0);
EXPECT_EQ(::getsockname(fd, reinterpret_cast<struct sockaddr *>(&addr), &len), 0);
::close(fd);
return ntohs(addr.sin_port);
}
// Connects a client and runs the server's loop until it has accepted it
int connect_client() {
int fd = ::socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in addr{};
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr.sin_port = htons(this->port);
EXPECT_EQ(::connect(fd, reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr)), 0);
this->clients.push_back(fd);
for (int i = 0; i != 100 && !this->server.link.is_connected(); i++) {
this->server.link.loop();
wait_for_sockets();
}
return fd;
}
End server;
uint16_t port{0};
std::vector<int> clients;
};
TEST_F(TcpServerTest, AcceptsClientAndReceives) {
this->server.link.loop(); // starts listening
int client = this->connect_client();
ASSERT_TRUE(this->server.link.is_connected());
EXPECT_EQ(this->server.states, std::vector<bool>{true});
const uint8_t frame[3] = {0x01, 0x00, 0x42};
ASSERT_EQ(::write(client, frame, sizeof(frame)), 3);
for (int i = 0; i != 100 && this->server.received.empty(); i++) {
this->server.link.loop();
wait_for_sockets();
}
EXPECT_EQ(this->server.received, std::vector<Packet>{{0x42}});
}
TEST_F(TcpServerTest, AcceptsNextClientAfterDisconnect) {
this->server.link.loop();
int first = this->connect_client();
ASSERT_TRUE(this->server.link.is_connected());
::close(first);
this->clients.clear();
for (int i = 0; i != 100 && this->server.link.is_connected(); i++) {
this->server.link.loop();
wait_for_sockets();
}
EXPECT_EQ(this->server.states, (std::vector<bool>{true, false}));
this->connect_client();
EXPECT_TRUE(this->server.link.is_connected());
EXPECT_EQ(this->server.states, (std::vector<bool>{true, false, true}));
}
} // namespace esphome::tcp::testing
#endif
+2
View File
@@ -0,0 +1,2 @@
packages:
tcp: !include common.yaml
+39
View File
@@ -116,6 +116,45 @@ def test_timeout_not_with_session_on_peer(setup_core) -> None:
fv.full_config.reset(token)
def test_timeout_not_with_link_session(setup_core) -> None:
"""A link such as TCP does the session's job itself, so it has no session key but the same rule applies."""
from esphome.components.tcp.packet_interface import TcpPacketInterface
token = fv.full_config.set(
{
"packet_interface": [
{CONF_ID: ID("tcp_link", is_manual=True, type=TcpPacketInterface)}
]
}
)
try:
with pytest.raises(cv.Invalid, match="session") as error:
FINAL_VALIDATE_SCHEMA(
CONFIG_SCHEMA({"packet_interface": "tcp_link", CONF_TIMEOUT: "1min"})
)
assert error.value.path == [CONF_TIMEOUT]
finally:
fv.full_config.reset(token)
def test_timeout_not_with_link_session_on_peer(setup_core) -> None:
"""An addressing peer has what its link provides, as well as its own layers."""
from esphome.components.tcp.packet_interface import TcpPacketInterface
link = {
CONF_ID: ID("session_link", is_manual=True, type=TcpPacketInterface),
"addressing": {"peers": [{CONF_ID: ID("link_peer", is_manual=True)}]},
}
token = fv.full_config.set({"packet_interface": [link]})
try:
with pytest.raises(cv.Invalid, match="session"):
FINAL_VALIDATE_SCHEMA(
CONFIG_SCHEMA({"packet_interface": "link_peer", CONF_TIMEOUT: "1min"})
)
finally:
fv.full_config.reset(token)
@pytest.mark.parametrize(
("layers", "allowed"),
[
@@ -0,0 +1,330 @@
"""Unit tests for the sx126x and sx127x packet interface platforms."""
import math
import pytest
from esphome import config_validation as cv
from esphome.components.packet_interface import CONF_MAX_PACKET_SIZE, radio_link
from esphome.components.sx126x import packet_interface as sx126x_packet_interface
from esphome.components.sx127x import packet_interface as sx127x_packet_interface
import esphome.final_validate as fv
@pytest.mark.parametrize(
("schema", "radio_key"),
[
(sx126x_packet_interface.CONFIG_SCHEMA, "sx126x_id"),
(sx127x_packet_interface.CONFIG_SCHEMA, "sx127x_id"),
],
)
def test_max_packet_size_is_radio_limit(
setup_core, schema: cv.Schema, radio_key: str
) -> None:
"""A radio packet holds at most 255 bytes, which is also the default."""
assert schema({radio_key: "radio"})[CONF_MAX_PACKET_SIZE] == 255
with pytest.raises(cv.Invalid):
schema({radio_key: "radio", CONF_MAX_PACKET_SIZE: 256})
def _lora(**options: object) -> dict:
return {
"modulation": "LORA",
"spreading_factor": 7,
"bandwidth": "125_0kHz",
"coding_rate": "CR_4_5",
"preamble_size": 8,
"crc_enable": False,
**options,
}
@pytest.mark.parametrize(
("radio", "airtime_ms"),
[
# Worked by hand from the Semtech formula, for a 255 byte packet with an explicit header
(_lora(spreading_factor=7), 394.5),
(_lora(spreading_factor=7, crc_enable=True), 399.6),
(_lora(spreading_factor=10), 2254.8),
# A symbol takes over 16 ms, so the low data rate optimization lengthens the packet
(_lora(spreading_factor=12), 9019.4),
],
)
def test_lora_airtime(radio: dict, airtime_ms: float) -> None:
"""The airtime of the largest LoRa packet follows the Semtech formula."""
assert radio_link.packet_airtime_ms(radio, 255) == pytest.approx(
airtime_ms, abs=0.5
)
def test_max_busy_follows_airtime() -> None:
"""Listen before talk waits at least 2 s, and longer than the largest packet takes."""
assert radio_link.max_busy_ms(_lora(), 255) == 2000
assert radio_link.max_busy_ms(_lora(spreading_factor=12), 255) > 9019
fsk = {
"modulation": "FSK",
"preamble_size": 4,
"bitrate": 1200,
"sync_value": [1, 2],
}
assert radio_link.packet_airtime_ms(fsk, 64) == pytest.approx(
(4 + 2 + 1 + 64 + 2) * 8 / 1200 * 1000
)
@pytest.mark.parametrize(
("radio", "expected_ms"),
[
# (8 + 4.25 + 8) symbols of 8.192 ms, then 50 ms for the reply to start, with a quarter added
(_lora(spreading_factor=10), 270),
(_lora(spreading_factor=7), 89),
# 6 bytes of preamble, sync word and length at 4800 bit/s
(
{
"modulation": "FSK",
"preamble_size": 4,
"bitrate": 4800,
"sync_value": [0x12],
},
75,
),
],
)
def test_turnaround_covers_reply_header(radio: dict, expected_ms: int) -> None:
"""After sending, the link waits until the peer's reply would have started and its header been received."""
assert radio_link.turnaround_ms(radio) == expected_ms
@pytest.mark.parametrize(
("config", "expected"),
[
({}, False),
# A session's peer sends keep-alives on its own schedule, not a reply to each packet
({"session": {}}, False),
({"reliability": {}}, True),
({"addressing": {"peers": [{"session": {}}, {"reliability": {}}]}}, True),
],
)
def test_takes_turns_only_with_reliability(config: dict, expected: bool) -> None:
"""Only a reliability layer's peer answers each packet, and it sends again what turn taking refuses."""
assert radio_link.takes_turns(config) is expected
def _fsk(**options: object) -> dict:
return {
"modulation": "FSK",
"packet_mode": True,
"payload_length": 0,
"sync_value": [0x12],
"preamble_size": 4,
"bitrate": 4800,
**options,
}
class _FullConfig(dict):
"""Enough of the full configuration for the radio links' final validation."""
def __init__(self, domain: str, radio: dict) -> None:
super().__init__({domain: [{"rx_start": True, **radio}]})
self.domain = domain
def get_path_for_id(self, id_: object) -> list:
return [self.domain, 0, "id"]
def get_config_for_path(self, path: list) -> dict:
return self[path[0]][path[1]]
@pytest.mark.parametrize(
("module", "domain", "radio", "link", "match", "fix"),
[
(
sx126x_packet_interface,
"sx126x",
_lora(payload_length=10),
{},
"payload_length",
{"payload_length": 0},
),
(
sx127x_packet_interface,
"sx127x",
_lora(payload_length=10),
{},
"payload_length",
{"payload_length": 0},
),
(
sx127x_packet_interface,
"sx127x",
{
**_fsk(modulation="FSK", packet_mode=False),
},
{},
"packet_mode",
{"packet_mode": True},
),
(
sx127x_packet_interface,
"sx127x",
{
**_fsk(modulation="OOK"),
},
{CONF_MAX_PACKET_SIZE: 64},
"at most 63",
None,
),
(
sx127x_packet_interface,
"sx127x",
{
**_fsk(sync_value=[]),
},
{},
"sync_value",
{"sync_value": [0x12]},
),
(
sx126x_packet_interface,
"sx126x",
_fsk(sync_value=[]),
{},
"sync_value",
{"sync_value": [0x12, 0x34]},
),
],
)
def test_radio_settings_checked(
module: object,
domain: str,
radio: dict,
link: dict,
match: str,
fix: dict | None,
) -> None:
"""Packets vary in length; FSK or OOK on an SX127x needs packet mode and a sync word, and holds at most 63 bytes;
FSK on an SX126x needs a sync word.
"""
config = {f"{domain}_id": "radio", CONF_MAX_PACKET_SIZE: 63, **link}
token = fv.full_config.set(_FullConfig(domain, radio))
try:
with pytest.raises(cv.Invalid, match=match):
module.FINAL_VALIDATE_SCHEMA(config)
if fix is not None:
fv.full_config.set(_FullConfig(domain, {**radio, **fix}))
assert module.FINAL_VALIDATE_SCHEMA(config)
finally:
fv.full_config.reset(token)
@pytest.mark.parametrize(
("link", "match"),
[
({}, None),
({"encryption": "secret"}, None),
({"reliability": {}}, "reliability"),
(
{
"addressing": {
"address": 1,
"peers": [
{"id": "a", "destination": 2, "session": {}},
{"id": "b", "destination": 3},
],
}
},
"session",
),
],
)
def test_rx_start_needed_for_replies(setup_core, link: dict, match: str | None) -> None:
"""A radio that sleeps after sending suits only a link whose layers need no packets back."""
sleeping = _lora(payload_length=0, rx_start=False)
config = sx126x_packet_interface.CONFIG_SCHEMA({"sx126x_id": "radio", **link})
token = fv.full_config.set(_FullConfig("sx126x", sleeping))
try:
if match is None:
assert sx126x_packet_interface.FINAL_VALIDATE_SCHEMA(config)
return
with pytest.raises(cv.Invalid, match=f"'{match}'.*rx_start"):
sx126x_packet_interface.FINAL_VALIDATE_SCHEMA(config)
finally:
fv.full_config.reset(token)
def _final_validate(radio: dict, link: dict) -> None:
config = sx126x_packet_interface.CONFIG_SCHEMA({"sx126x_id": "radio", **link})
token = fv.full_config.set(_FullConfig("sx126x", {"payload_length": 0, **radio}))
try:
sx126x_packet_interface.FINAL_VALIDATE_SCHEMA(config)
finally:
fv.full_config.reset(token)
def test_packet_must_fit_transmit_time(setup_core) -> None:
"""The radios give up on a packet that takes longer than 4 s to send, so the largest packet must take less."""
slow = _lora(spreading_factor=12)
with pytest.raises(cv.Invalid, match=r"255 bytes takes 9019 ms.*to 7\d or less"):
_final_validate(slow, {})
_final_validate(slow, {CONF_MAX_PACKET_SIZE: 64})
_final_validate(_lora(), {})
def test_reliability_timeout_follows_airtime(setup_core) -> None:
"""A reliability timeout must allow for the peer's largest packet and the acknowledgement."""
needed = radio_link.reliability_timeout_ms(_lora(), 255, 0)
assert needed == math.ceil(
(
radio_link.packet_airtime_ms(_lora(), 255)
+ radio_link.packet_airtime_ms(_lora(), radio_link.ACK_PACKET_SIZE)
)
* radio_link.MARGIN
)
assert radio_link.reliability_timeout_ms(_lora(), 255, 100) == needed + 100
with pytest.raises(cv.Invalid, match=f"at least {needed}ms"):
_final_validate(_lora(), {"reliability": {"timeout": "200ms"}})
# Left out, the link works it out when generating code
_final_validate(_lora(), {"reliability": {}})
_final_validate(_lora(), {"reliability": {"timeout": f"{needed}ms"}})
# The worked out timeout allows for any ack_delay, so one longer than 200 ms needs no timeout set
_final_validate(_lora(spreading_factor=9), {"reliability": {"ack_delay": "250ms"}})
def test_suggested_size_is_allowed(setup_core) -> None:
"""The suggested max_packet_size is never below the smallest one allowed."""
slowest = _lora(spreading_factor=12, bandwidth="7_8kHz")
with pytest.raises(cv.Invalid, match="use faster radio settings"):
_final_validate(slowest, {CONF_MAX_PACKET_SIZE: 16})
def test_channel_packet_size(setup_core) -> None:
"""Other devices can send no more than the radio receives, nor more than their own checks allow."""
assert radio_link.channel_packet_size(_lora(), 255) == 255
assert radio_link.channel_packet_size(_lora(spreading_factor=12), 255) == 77
assert radio_link.channel_packet_size(_fsk(), 63) == 63
def test_reliability_timeout_allows_for_other_devices(setup_core) -> None:
"""A small max_packet_size still needs a timeout that allows for the largest packet another device can send."""
needed = radio_link.reliability_timeout_ms(_lora(), 255, 0)
with pytest.raises(cv.Invalid, match=f"at least {needed}ms"):
_final_validate(
_lora(),
{
CONF_MAX_PACKET_SIZE: 16,
"reliability": {
"timeout": f"{radio_link.reliability_timeout_ms(_lora(), 16, 0)}ms"
},
},
)
def test_long_sends_warned(setup_core, caplog: pytest.LogCaptureFixture) -> None:
"""A send of many radio packets, each waited for, is warned about."""
slow = _lora(spreading_factor=10)
_final_validate(slow, {CONF_MAX_PACKET_SIZE: 64})
assert "radio packets in a row" not in caplog.text
_final_validate(slow, {CONF_MAX_PACKET_SIZE: 64, "fragmentation": {}})
# 1024 bytes in fragments of 62
assert "can send 17 radio packets in a row" in caplog.text
+5 -1
View File
@@ -62,7 +62,8 @@ def test_reliability_defaults(setup_core) -> None:
config = uart_packet_interface.CONFIG_SCHEMA({CONF_RELIABILITY: None})
reliability = config[CONF_RELIABILITY]
assert reliability["type"] == "hdlc"
assert reliability["timeout"].total_milliseconds == 200
# Left out, so that the link can choose one; otherwise the layer uses 200 ms
assert "timeout" not in reliability
assert reliability[CONF_MAX_QUEUE_LENGTH] == 4
assert reliability["max_retries"] == 5
@@ -92,6 +93,9 @@ def test_ack_delay_shorter_than_timeout(setup_core) -> None:
uart_packet_interface.CONFIG_SCHEMA(
{CONF_RELIABILITY: {"timeout": "500ms", "ack_delay": "500ms"}}
)
# Without a timeout, the link's default of 200 ms applies
with pytest.raises(cv.Invalid, match="shorter than 'timeout', which is 200ms"):
uart_packet_interface.CONFIG_SCHEMA({CONF_RELIABILITY: {"ack_delay": "250ms"}})
def test_layer_types_registered() -> None:
@@ -0,0 +1,84 @@
"""Unit tests for the tcp packet interface platform."""
import pytest
from esphome import config_validation as cv
from esphome.components import socket
from esphome.components.packet_interface import CONF_MAX_PACKET_SIZE
from esphome.components.tcp import packet_interface as tcp_packet_interface
from esphome.core import CORE
def test_client_and_server(setup_core) -> None:
"""A client needs a host; a server listens on its port."""
client = tcp_packet_interface.CONFIG_SCHEMA({"host": "192.168.1.50", "port": 6060})
assert client["role"] == "client"
assert client[CONF_MAX_PACKET_SIZE] == 1022
assert tcp_packet_interface.CONFIG_SCHEMA({"role": "server", "port": 6060})
with pytest.raises(cv.Invalid):
tcp_packet_interface.CONFIG_SCHEMA({"port": 6060})
@pytest.mark.parametrize("layer", ["reliability", "session", "addressing"])
def test_provided_layers_rejected(setup_core, layer: str) -> None:
"""TCP provides these itself, so they cannot be configured on it."""
with pytest.raises(cv.Invalid, match=f"provides '{layer}' itself"):
tcp_packet_interface.CONFIG_SCHEMA(
{"host": "192.168.1.50", "port": 6060, layer: {"address": 1}}
)
def test_rolling_code_rejected(setup_core) -> None:
"""The rolling code needs the session's keep-alives, which TCP does not send through the layers."""
with pytest.raises(cv.Invalid, match="cannot be used on this link"):
tcp_packet_interface.CONFIG_SCHEMA(
{
"host": "192.168.1.50",
"port": 6060,
"encryption": {"key": "secret", "rolling_code_enable": True},
}
)
def test_auto_load_binary_sensor_for_connected(setup_core) -> None:
"""The binary_sensor component is loaded only for the connected sensor."""
assert tcp_packet_interface.AUTO_LOAD() == ["socket", "binary_sensor"]
assert tcp_packet_interface.AUTO_LOAD({}) == ["socket", "binary_sensor"]
config = {"host": "192.168.1.50", "port": 6060}
assert tcp_packet_interface.AUTO_LOAD(config) == ["socket"]
config["connected"] = {"name": "Link"}
assert tcp_packet_interface.AUTO_LOAD(config) == ["socket", "binary_sensor"]
def test_timeout(setup_core) -> None:
"""The timeout follows keep_alive unless given, and must be longer than it."""
base = {"host": "192.168.1.50", "port": 6060}
config = tcp_packet_interface.CONFIG_SCHEMA({**base, "keep_alive": "2s"})
assert config["timeout"].total_milliseconds == 6000
# A peer that sends keep-alives less often is matched with a longer timeout
config = tcp_packet_interface.CONFIG_SCHEMA({**base, "timeout": "90s"})
assert config["timeout"].total_milliseconds == 90000
with pytest.raises(cv.Invalid, match="longer than keep_alive"):
tcp_packet_interface.CONFIG_SCHEMA(
{**base, "keep_alive": "5s", "timeout": "5s"}
)
with pytest.raises(cv.Invalid):
tcp_packet_interface.CONFIG_SCHEMA({**base, "keep_alive": "2h"})
with pytest.raises(cv.Invalid):
tcp_packet_interface.CONFIG_SCHEMA({**base, "timeout": "4h"})
@pytest.mark.parametrize(
("role", "tcp", "listen"), [("client", 1, 0), ("server", 1, 1)]
)
def test_sockets_reserved(setup_core, role: str, tcp: int, listen: int) -> None:
"""A client reserves one socket; a server also reserves a listener."""
config = {"role": role, "port": 6060}
if role == "client":
config["host"] = "192.168.1.50"
tcp_packet_interface.CONFIG_SCHEMA(config)
name = "tcp.packet_interface"
assert CORE.data[socket.KEY_SOCKET_CONSUMERS_TCP][name] == tcp
assert (
CORE.data.get(socket.KEY_SOCKET_CONSUMERS_TCP_LISTEN, {}).get(name, 0) == listen
)