Compare commits

...
Author SHA1 Message Date
J. Nick Koston c2e364d7bf Test that the property returns the stored version 2026-11-18 11:44:25 -06:00
J. Nick Koston 1ff447f4e6 [core] Add CORE.framework_version 2026-11-18 11:43:09 -06:00
Leandro 791d6e15ee [mqtt] Connect as soon as the network is up, not 5 s after boot (#22871) 2026-11-18 11:11:03 -06:00
J. Nick Koston d2b505e76c [bmi270] Feed the watchdog during the config upload (#22862) 2026-11-18 11:08:24 -06:00
J. Nick Koston 0cca1f8c02 [bmi270] Keep the config file in flash on ESP8266, upload it without the heap and simplify the component (#22778) 2026-11-18 11:08:23 -06:00
Martin Klingensmith 3bcd0da1f4 [uart] Accept alternate hardware UART pins on LibreTiny (#22863) 2026-11-18 10:44:53 -06:00
Martin Klingensmith 3e54c5b46d [pioneer_wt] Add Pioneer WT mini split climate component (#22865) 2026-11-18 10:24:00 -06:00
J. Nick Koston e7f7fc162b [qwiic_pir] Set a warning on read failures instead of logging every loop (#22854) 2026-11-18 07:10:30 -05:00
rwrozelle b3474a1ed5 [ci] Add a silent failure review skill (#22846) 2026-11-17 22:33:16 -06:00
Jesse Hills 69037820fa Merge branch 'beta' into dev 2026-11-18 16:07:40 +13:00
Jesse Hills 6c28ef21d9 Merge pull request #22866 from esphome/bump-2026.11.0b7
2026.11.0b7
2026-11-18 16:07:21 +13:00
Jesse Hills ab6e3d9bf0 Bump version to 2026.11.0b7 2026-11-18 15:35:39 +13:00
J. Nick Koston 10ef6e371b [i2c] Stop bus recovery clock pulses once SDA is released (#22852) 2026-11-18 15:35:35 +13:00
J. Nick Koston c84cd04cf7 [modem] Wait for registration before attaching and recover SIM7670 data mode and CMUX (#22816) 2026-11-18 15:35:35 +13:00
J. Nick Koston fb6d7bf265 [scd30] Stop overriding the I2C bus clock-stretch limit on ESP8266 (#22512) 2026-11-18 15:35:35 +13:00
David WoodhouseandJ. Nick Koston 3ad8e35be8 [mqtt] Don't start the broker lookup before the network is up (#22843)
Co-authored-by: J. Nick Koston <nick@home-assistant.io>
2026-11-18 15:35:35 +13:00
Mattheinrichs 11f9f20b61 [cst816] Ignore idle 0xFF touch frames and invalid coordinates (#22435) 2026-11-18 15:35:28 +13:00
Jacopo Labardi b6d0961f25 [logger] Qualify the host clock function (#22838) 2026-11-18 15:31:22 +13:00
David Woodhouse 6046d067aa [climate] Don't fail on a platform entry that only holds nested climates (#22844) 2026-11-18 15:30:52 +13:00
Jonathan Swoboda 690c5f2fb6 [mlx90393] Enable the Wire library on ESP32 Arduino (#22801) 2026-11-18 15:30:52 +13:00
J. Nick Koston 654954f684 [api] Make the event order backpressure test wait until the pipe is full (#22112) 2026-11-18 15:30:44 +13:00
J. Nick Koston e5728407db [i2c] Stop bus recovery clock pulses once SDA is released (#22852) 2026-11-17 18:06:32 -06:00
J. Nick Koston 0cf5af743e [modem] Wait for registration before attaching and recover SIM7670 data mode and CMUX (#22816) 2026-11-17 18:05:44 -06:00
J. Nick Koston 7ffead44fe [scd30] Stop overriding the I2C bus clock-stretch limit on ESP8266 (#22512) 2026-11-17 18:25:29 -05:00
54 changed files with 3003 additions and 492 deletions

No files matched your search

+3
View File
@@ -20,6 +20,9 @@ flagging in a review; read the matching skill for the detail behind any item.
Only raise findings that the diff actually introduces or changes. Do not ask for
drive-by cleanup of pre-existing code the PR did not touch.
For error paths that fail without telling the user (early returns, swallowed
errors, ignored results), the `silent-failure-review` skill has its own checklist.
## Scope: shared code does not ride a component PR
Check the file list first. A PR titled for one component (`[ld2450] ...`) must
@@ -0,0 +1,71 @@
---
name: silent-failure-review
description: Find code paths in a branch's diff that fail without telling the user - early returns, swallowed errors, ignored return values, half-done cleanup, and checks that are only safe under an unstated assumption. Use when asked for a silent failure review or before pushing a PR for review.
---
# Silent failure review
Report only. Do not edit files.
## Scope
The diff of the checked-out branch against its base. Fetch the base first (`git fetch upstream dev`, or
`git fetch origin dev` when there is no `upstream` remote); a stale base pulls in commits the branch only merged.
Then run `git merge-base upstream/dev HEAD` (or `origin/dev`) on its own. If it fails or prints nothing (often a
shallow clone; `git fetch --unshallow` fixes that), say the review could not run and stop; never report "no
findings" then. Diff against that commit with `git diff <base>`. The diff includes uncommitted changes but not
untracked files, so also read in full every file `git status --porcelain --untracked-files=all` lists as `??`.
Use another branch only if the user names one. If neither remote exists, say so and stop. Read each changed
function in full, and its callers, not just the hunks. When a failure depends on how a library call behaves,
read that library's code too.
## What to look for
1. **Early returns and skips:** a `return` or `continue` taken before a check or a fetch. Name the assumption
it relies on and the case that breaks it (a later release, a lost file, an older install).
2. **Swallowed errors:** `except` that logs, passes or returns a default; `OSError` tolerated where the next
step needs the file. In C++: an error code mapped to a default, or a status flag that is never set.
3. **Ignored results:** a `False`, `None`, exit code, `bool` or `ErrorCode` that the caller does not check.
4. **Half-done state:** a failure between two writes that leaves a marker, stamp, lock or filter saying
something is done when it is not; cleanup missing on an error path.
5. **Stale stored state:** markers, stamps or saved preferences (NVS, flash) written by an older version that
the new code trusts.
6. **Unclear late failure:** an error that surfaces later (CMake, compile, boot) instead of where it starts,
with a message that does not point back to the cause.
7. **Defaults standing in for errors:** `x or default`, `.get(key, default)` or an empty object takes the
place of a value that is missing or could not be read, and the code carries on as if it were real.
8. **Unwatched work:** a thread, task or subprocess is started and nothing ever looks at how it ended.
9. **Wrong value on an error branch:** the error is detected, but the branch returns success, `None` or the
wrong code instead of passing it on.
10. **State reset or skipped:** for each counter, flag, retry or timeout the diff adds or changes, find every
place that writes it, and check that no path resets or skips it before it can do its job.
11. **Boundaries:** length and buffer comparisons (`>=` against `>`, `len` against `len + 1`), the exact-fit
case and the empty case.
12. **Unjudged results:** a test or script that prints a result but never fails on it.
Moved code counts too: if the original had the same flaw, say so, but still report it. Report only flaws in
changed or moved lines; unchanged callers are context. If the branch has an open PR (`gh pr view --json number`
finds it), read its reviews (`gh pr view <n> --comments` and
`gh api --paginate repos/esphome/esphome/pulls/<n>/comments`) and skip what they already raised.
Before reporting a candidate, follow it to the line that proves it and quote that line. If you cannot
confirm it, drop it or mark it as likely.
## Skip
- Code that ignores a failure and has a comment explaining why.
- Tests that provoke an error and check for it.
- Optional tidy-up steps (removing a temp file, say) that may fail with only a log line.
## Report
One entry per finding, most severe first:
- **HIGH / MEDIUM / LOW** - one-line title, `file:line`. HIGH: wrong result or lost data. MEDIUM: a
misleading or delayed failure. LOW: affects only logs or diagnostics.
- **Confidence:** confirmed, or likely and why it could not be confirmed.
- **Risk:** the concrete input or state, and what the user sees.
- **Fix:** the smallest change.
- **Test:** the test that fails before the fix, or for on-device code, the steps to reproduce it on a board.
No findings: say so in one line. Keep the report short; no summary of what the PR does.
+2
View File
@@ -66,6 +66,8 @@ file does, and it is the authority when they disagree. The most useful starting
* `breaking-changes`: what is public API, deprecation patterns and migration notes.
* `pr-workflow`, `code-review`, `hardware-test`, `display-test`: creating PRs, reviewing them, and testing
on real boards and panels.
* `silent-failure-review`: code paths in a branch's diff that fail without telling the user, checked
before a PR goes up for review.
* **Formatting:**
* **Python:** Uses `ruff` for linting and formatting. Configuration is in `pyproject.toml`.
+1
View File
@@ -494,6 +494,7 @@ esphome/components/pcm5122/* @remcom
esphome/components/pd_pioneer_ir/* @martinsah
esphome/components/pi4ioe5v6408/* @jesserockz
esphome/components/pid/* @OttoWinter
esphome/components/pioneer_wt/* @martinsah
esphome/components/pipsolar/* @andreashergert1984
esphome/components/pixoo/* @jesserockz
esphome/components/pm1006/* @habbie
+70 -136
View File
@@ -1,5 +1,6 @@
#include "bmi270.h"
#include "bmi270_config.h"
#include "esphome/core/application.h"
#include "esphome/core/log.h"
#include "esphome/core/hal.h"
#include "esphome/core/progmem.h"
@@ -21,48 +22,40 @@ 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_() {
// 1. Disable advanced power-save so the config port is accessible
// The config port is only reachable with advanced power save off
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) {
// 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))
// 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)
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);
if (this->write_register(BMI270_REG_INIT_DATA, cfg + index, burst) != i2c::ERROR_OK)
progmem_memcpy(buf + 1, BMI270_CONFIG_FILE + index, burst);
if (this->write(buf, burst + 1) != i2c::ERROR_OK)
return false;
index += burst;
// 256 bursts at 50 kHz, or through an I2C multiplexer, outlast the ESP8266 soft watchdog
App.feed_wdt();
}
// 4. Signal end of config load
if (!this->write_byte(BMI270_REG_INIT_CTRL, BMI270_INIT_CTRL_LOAD_DONE))
return false;
delay(20); // spec: wait ≥20 ms for init to complete
delay(20); // The datasheet asks for at least 20 ms before INTERNAL_STATUS is valid
// 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;
@@ -73,74 +66,52 @@ 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);
// 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_)))
if (!this->setup_check(this->load_config_file_(), LOG_STR("Config file upload failed")))
return;
// 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)))
// 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)))
return;
delay(5);
// 8. Re-enable advanced power save (optional; keeps current low between reads)
// Disabled here for simplicity – leave in performance mode
// bit1 = fifo_self_wakeup
// Advanced power save stays off; FIFO self-wakeup on
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) {
this->magnetometer_ready_ = this->setup_magnetometer_();
const LogString *failed_step = this->setup_magnetometer_();
this->magnetometer_ready_ = failed_step == nullptr;
if (!this->magnetometer_ready_) {
ESP_LOGW(TAG, "BMM150 magnetometer setup failed; continuing without it");
ESP_LOGW(TAG, "BMM150 magnetometer setup failed at %s; continuing without it", LOG_STR_ARG(failed_step));
}
}
#endif
ESP_LOGCONFIG(TAG, "BMI270 initialised successfully");
}
#ifdef USE_BMI270_BMM150
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.
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;
uint32_t start = millis();
while (true) {
uint8_t status = 0;
@@ -148,98 +119,63 @@ bool BMI270Component::wait_for_aux_idle_(uint32_t timeout_ms) {
return false;
if ((status & BMI270_STATUS_AUX_BUSY) == 0)
return true;
if (millis() - start >= timeout_ms)
if (millis() - start >= AUX_IDLE_TIMEOUT_MS)
return false;
delay(1);
}
}
bool BMI270Component::write_aux_register_(uint8_t reg, uint8_t value) {
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);
return this->write_byte(BMI270_REG_AUX_WR_DATA, value) && this->write_byte(BMI270_REG_AUX_WR_ADDR, reg) &&
this->wait_for_aux_idle_();
}
bool BMI270Component::read_aux_block_(uint8_t reg, uint8_t *buf) {
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);
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);
}
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;
// 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");
// 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)) {
ESP_LOGW(TAG, "BMM150 power-on write timed out");
return false;
}
if (!this->write_aux_register_(BMM150_REG_POWER_CONTROL, BMM150_CMD_POWER_ON))
return LOG_STR("power-on");
delay(BMM150_START_UP_TIME_MS);
if (!this->write_aux_register_(BMM150_REG_POWER_CONTROL, BMM150_CMD_SOFT_RESET)) {
ESP_LOGW(TAG, "BMM150 soft-reset write timed out");
return false;
}
if (!this->write_aux_register_(BMM150_REG_POWER_CONTROL, BMM150_CMD_SOFT_RESET))
return LOG_STR("soft reset");
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)) {
ESP_LOGW(TAG, "BMM150 chip-ID read failed");
return false;
}
if (!this->read_aux_block_(BMM150_REG_CHIP_ID, chip_id))
return LOG_STR("chip ID read");
if (chip_id[0] != BMM150_CHIP_ID_VALUE) {
ESP_LOGW(TAG, "BMM150 not detected (chip ID 0x%02X, expected 0x%02X)", chip_id[0], BMM150_CHIP_ID_VALUE);
return false;
ESP_LOGW(TAG, "BMM150 chip ID 0x%02X, expected 0x%02X", chip_id[0], BMM150_CHIP_ID_VALUE);
return LOG_STR("chip ID check");
}
if (!this->read_magnetometer_trim_()) {
ESP_LOGW(TAG, "BMM150 trim data read failed");
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");
}
this->mag_trim_ = bmm150_parse_trim(trim);
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_aux_register_(BMM150_REG_OP_MODE, BMM150_CMD_NORMAL_MODE_ODR_30HZ))
return LOG_STR("normal mode");
// 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;
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;
}
#endif // USE_BMI270_BMM150
@@ -249,9 +185,10 @@ void BMI270Component::dump_config() {
if (this->is_failed())
return;
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",
ESP_LOGCONFIG(TAG,
" Accel range : %s\n"
" Gyro range : %s",
LOG_STR_ARG(AccelRangeStrings::get_log_str(this->accel_range_, AccelRangeStrings::LAST_INDEX)),
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) {
@@ -262,9 +199,6 @@ 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;
+8 -24
View File
@@ -12,18 +12,15 @@
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; // temperature (2 bytes big-endian ish)
static constexpr uint8_t BMI270_REG_TEMP_MSB = 0x23;
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)
// 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 BMI270_REG_PWR_CONF = 0x7C;
static constexpr uint8_t BMI270_REG_PWR_CTRL = 0x7D;
@@ -80,7 +77,6 @@ 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,
@@ -88,7 +84,6 @@ 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,
@@ -100,7 +95,6 @@ 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,
@@ -109,7 +103,6 @@ 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,
@@ -130,14 +123,11 @@ 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; }
@@ -153,21 +143,15 @@ class BMI270Component final : public motion::MotionComponent, public i2c::I2CDev
bool update_data(motion::MotionData &data) override;
bool load_config_file_();
#ifdef USE_BMI270_BMM150
// 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.
// 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
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};
+2 -1
View File
@@ -1,5 +1,6 @@
#pragma once
#include <cstdint>
#include "esphome/core/hal.h"
namespace esphome::bmi270 {
@@ -44,7 +45,7 @@ POSSIBILITY OF SUCH DAMAGE.
after every power cycle, before any sensor data can be read.
--------------------------------------------------------------------------- */
static constexpr uint8_t BMI270_CONFIG_FILE[] = {
static constexpr uint8_t BMI270_CONFIG_FILE[] PROGMEM = {
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,11 +3,8 @@
#include <cstdint>
#include "esphome/core/helpers.h"
// 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.
// BMM150 magnetometer behind the BMI270's aux interface; it is not on the main I2C bus, so it is not
// its own component
namespace esphome::bmi270::bmm150 {
static constexpr uint8_t BMM150_DEFAULT_I2C_ADDRESS = 0x10;
@@ -64,20 +61,23 @@ 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>(regs[BMM150_TRIM_X1 - BMM150_REG_TRIM_START]);
trim.y1 = static_cast<int8_t>(regs[BMM150_TRIM_Y1 - BMM150_REG_TRIM_START]);
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.z4 = static_cast<int16_t>(bmm150_trim_word(regs, BMM150_TRIM_Z4));
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.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.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>(regs[BMM150_TRIM_XY2 - BMM150_REG_TRIM_START]);
trim.xy1 = regs[BMM150_TRIM_XY1 - BMM150_REG_TRIM_START];
trim.xy2 = static_cast<int8_t>(bmm150_trim_byte(regs, BMM150_TRIM_XY2));
trim.xy1 = bmm150_trim_byte(regs, BMM150_TRIM_XY1);
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) {
// 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));
// 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;
return BMM150Data{
.x = bmm150_compensate_xy(trim, trim.x1, trim.x2, x, rhall),
.y = bmm150_compensate_xy(trim, trim.y1, trim.y2, y, rhall),
+28 -21
View File
@@ -17,6 +17,14 @@ 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")
@@ -57,50 +65,49 @@ 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="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(
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(
GYRO_RANGE_OPTIONS, upper=True
),
cv.Optional(CONF_GYROSCOPE_ODR, default="200HZ"): cv.enum(
cv.Optional(CONF_GYROSCOPE_ODR, default=DEFAULT_GYROSCOPE_ODR): 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
),
# Default matches the BMM150's fixed I2C address; irrelevant when aux_device is NONE.
cv.Optional(CONF_AUX_ADDRESS, default=0x10): cv.i2c_address,
cv.Optional(CONF_AUX_ADDRESS, default=DEFAULT_AUX_ADDRESS): 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)
# 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 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]))
# 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))
cg.add(var.set_aux_device_address(config[CONF_AUX_ADDRESS]))
if (address := config[CONF_AUX_ADDRESS]) != DEFAULT_AUX_ADDRESS:
cg.add(var.set_aux_device_address(address))
+15 -29
View File
@@ -180,23 +180,18 @@ void ArduinoI2CBus::recover_() {
return;
}
// From the specification:
// "If the data line (SDA) is stuck LOW, send nine clock pulses. The
// device that held the bus LOW should release it sometime within
// those nine clocks."
// We don't really have to detect if SDA is stuck low. We'll simply send
// nine clock pulses here, just in case SDA is stuck. Actual checks on
// the SDA line status will be done after the clock pulses.
// Make sure that switching to output mode will make SCL low, just in
// case other code has setup the pin for a HIGH signal.
digitalWrite(this->scl_pin_, LOW); // NOLINT
// Activate input and pull up resistor for the SDA pin, so it can be read during the pulses.
pinMode(this->sda_pin_, INPUT_PULLUP); // NOLINT
delayMicroseconds(half_period_usec);
for (auto i = 0; i < 9; i++) {
// Release pull up resistor and switch to output to make the signal LOW.
pinMode(this->scl_pin_, INPUT); // NOLINT
pinMode(this->scl_pin_, OUTPUT); // NOLINT
// Spec: "If the data line (SDA) is stuck LOW, send nine clock pulses."
// Pulse only while SDA is low: a device receiving a write ACKs every ninth pulse.
for (auto i = 0; i < 9 && digitalRead(this->sda_pin_) == LOW; i++) { // NOLINT
// Drive LOW. Set the level while the pin is a plain input: on RP2040 a write to an
// INPUT_PULLUP pin drives it, which would leave SCL low if the loop never runs.
pinMode(this->scl_pin_, INPUT); // NOLINT
digitalWrite(this->scl_pin_, LOW); // NOLINT
pinMode(this->scl_pin_, OUTPUT); // NOLINT
delayMicroseconds(half_period_usec);
// Release output and activate pull up resistor to make the signal HIGH.
@@ -223,14 +218,7 @@ void ArduinoI2CBus::recover_() {
}
}
// Activate input and pull resistor for the SDA pin, so we can verify
// that SDA is pulled HIGH in the following step.
pinMode(this->sda_pin_, INPUT_PULLUP); // NOLINT
digitalWrite(this->sda_pin_, LOW); // NOLINT
// By now, any stuck device ought to have sent all remaining bits of its
// transaction, meaning that it should have freed up the SDA line, resulting
// in SDA being pulled up.
// A device still holding SDA after nine pulses cannot be freed here.
if (digitalRead(this->sda_pin_) == LOW) { // NOLINT
ESP_LOGE(TAG, "Recovery failed: SDA is held LOW after clock pulse cycle");
this->recovery_result_ = RECOVERY_FAILED_SDA_LOW;
@@ -242,15 +230,13 @@ void ArduinoI2CBus::recover_() {
// a START or repeated START condition such that they all anticipate
// the sending of a target address, even if these START conditions are
// not positioned according to the proper format."
// While the 9 clock pulses from above might have drained all bits of a
// single byte within a transaction, a device might have more bytes to
// transmit. So here we'll generate a START condition to snap the device
// out of this state.
// SDA high does not mean the device is idle (it may be mid-byte); the START resets it.
// SCL and SDA are already high at this point, so we can generate a START
// condition by making the SDA signal LOW.
delayMicroseconds(half_period_usec);
pinMode(this->sda_pin_, INPUT); // NOLINT
pinMode(this->sda_pin_, OUTPUT); // NOLINT
pinMode(this->sda_pin_, INPUT); // NOLINT
digitalWrite(this->sda_pin_, LOW); // NOLINT
pinMode(this->sda_pin_, OUTPUT); // NOLINT
// From the specification:
// "A START condition immediately followed by a STOP condition (void
+5 -15
View File
@@ -346,14 +346,9 @@ void IDFI2CBus::recover_() {
return;
}
// From the specification:
// "If the data line (SDA) is stuck LOW, send nine clock pulses. The
// device that held the bus LOW should release it sometime within
// those nine clocks."
// We don't really have to detect if SDA is stuck low. We'll simply send
// nine clock pulses here, just in case SDA is stuck. Actual checks on
// the SDA line status will be done after the clock pulses.
for (auto i = 0; i < 9; i++) {
// Spec: "If the data line (SDA) is stuck LOW, send nine clock pulses."
// Pulse only while SDA is low: a device receiving a write ACKs every ninth pulse.
for (auto i = 0; i < 9 && gpio_get_level(sda_pin) == 0; i++) {
gpio_set_level(scl_pin, 0);
delayMicroseconds(half_period_usec);
gpio_set_level(scl_pin, 1);
@@ -378,9 +373,7 @@ void IDFI2CBus::recover_() {
}
}
// By now, any stuck device ought to have sent all remaining bits of its
// transaction, meaning that it should have freed up the SDA line, resulting
// in SDA being pulled up.
// A device still holding SDA after nine pulses cannot be freed here.
if (gpio_get_level(sda_pin) == 0) {
ESP_LOGE(TAG, "Recovery failed: SDA is held LOW after clock pulse cycle");
this->recovery_result_ = RECOVERY_FAILED_SDA_LOW;
@@ -392,10 +385,7 @@ void IDFI2CBus::recover_() {
// a START or repeated START condition such that they all anticipate
// the sending of a target address, even if these START conditions are
// not positioned according to the proper format."
// While the 9 clock pulses from above might have drained all bits of a
// single byte within a transaction, a device might have more bytes to
// transmit. So here we'll generate a START condition to snap the device
// out of this state.
// SDA high does not mean the device is idle (it may be mid-byte); the START resets it.
// SCL and SDA are already high at this point, so we can generate a START
// condition by making the SDA signal LOW.
delayMicroseconds(half_period_usec);
+56
View File
@@ -1,3 +1,4 @@
from dataclasses import dataclass
import json
import logging
from pathlib import Path
@@ -188,6 +189,61 @@ def get_board_pins() -> dict[str, int]:
return lookup_board_pins(get_libretiny_board())
@dataclass(frozen=True)
class HardwareUart:
"""A hardware UART of the configured board and the pin numbers it can use."""
port: int
tx_pins: tuple[int, ...]
rx_pins: tuple[int, ...]
# The board lists pin choices instead of a default pin for this direction
tx_pin_choices: bool
rx_pin_choices: bool
@property
def pin_choices(self) -> bool:
"""True when the pins must be passed when the UART starts."""
return self.tx_pin_choices or self.rx_pin_choices
def get_hardware_uarts() -> list[HardwareUart]:
"""Hardware UARTs of the configured board; empty for a board without pin data."""
board_pins = get_board_pins()
uarts = []
for port in range(3):
pins: dict[str, list[int]] = {"TX": [], "RX": []}
choices: dict[str, bool] = {"TX": False, "RX": False}
for role, role_pins in pins.items():
name = f"SERIAL{port}_{role}"
for key, pin in board_pins.items():
if key == name:
role_pins.append(pin)
elif key.startswith(f"{name}_"):
role_pins.append(pin)
choices[role] = True
if pins["TX"] or pins["RX"]:
uarts.append(
HardwareUart(
port,
tuple(pins["TX"]),
tuple(pins["RX"]),
choices["TX"],
choices["RX"],
)
)
return uarts
def has_software_serial() -> bool:
"""True when the family's Arduino core has SoftwareSerial (LT_ARD_HAS_SOFTSERIAL)."""
return get_libretiny_family() == FAMILY_RTL8710B
def can_choose_uart_pins() -> bool:
"""True when SerialClass::begin() takes the pins, which LibreTiny added in 1.12.0."""
return CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION] >= cv.Version(1, 12, 0)
def only_on_family(*, supported=None, unsupported=None):
"""Config validator for features only available on some LibreTiny families."""
if supported is not None and not isinstance(supported, list):
+165
View File
@@ -0,0 +1,165 @@
#include "at_reply.h"
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <strings.h>
namespace esphome::modem {
bool collect_reply(char *buf, size_t size, size_t &len, const char *data, size_t data_len, bool whole) {
const size_t capacity = size - 1;
if (whole) {
len = 0;
}
bool dropped = false;
if (data_len > capacity) {
memcpy(buf, data + data_len - capacity, capacity);
len = capacity;
dropped = true;
} else {
if (len + data_len > capacity) {
const size_t drop = len + data_len - capacity;
memmove(buf, buf + drop, len - drop);
len -= drop;
dropped = true;
}
memcpy(buf + len, data, data_len);
len += data_len;
}
buf[len] = '\0';
return dropped;
}
ReplyEnd reply_end(const char *data, size_t len, bool skip_first) {
const char *end = data + len;
const char *line = data;
if (skip_first) {
const auto *newline = static_cast<const char *>(memchr(data, '\n', len));
line = newline != nullptr ? newline + 1 : end;
}
while (line < end) {
const auto *newline = static_cast<const char *>(memchr(line, '\n', end - line));
if (newline == nullptr) {
break; // the line has not ended yet
}
size_t size = newline - line;
if (size != 0 && line[size - 1] == '\r') {
size--;
}
if (size == 2 && memcmp(line, "OK", 2) == 0) {
return ReplyEnd::REPLY_END_OK;
}
// esp_modem drops a CMUX frame without a line end, so the ": <reason>" part may be missing
if ((size == 5 && memcmp(line, "ERROR", 5) == 0) || (size >= 10 && memcmp(line, "+CME ERROR", 10) == 0) ||
(size >= 10 && memcmp(line, "+CMS ERROR", 10) == 0)) {
return ReplyEnd::REPLY_END_ERROR;
}
line = newline + 1;
}
return ReplyEnd::REPLY_END_NONE;
}
size_t flatten_reply(char *reply, size_t len) {
for (size_t i = 0; i < len; i++) {
if (reply[i] == '\r' || reply[i] == '\n') {
reply[i] = ' ';
}
}
while (len != 0 && reply[len - 1] == ' ') {
len--;
}
if (len >= 2 && memcmp(reply + len - 2, "OK", 2) == 0 && (len == 2 || reply[len - 3] == ' ')) {
len -= 2;
while (len != 0 && reply[len - 1] == ' ') {
len--;
}
}
size_t start = 0;
while (start < len && reply[start] == ' ') {
start++;
}
len -= start;
memmove(reply, reply + start, len);
reply[len] = '\0';
return len;
}
int registration_from_reply(const char *reply, const char *prefix) {
const size_t prefix_len = strlen(prefix);
for (const char *line = strstr(reply, prefix); line != nullptr; line = strstr(line + 1, prefix)) {
const char *start = line + prefix_len;
char *end = nullptr;
strtol(start, &end, 10);
if (end == start || *end != ',') {
continue;
}
start = end + 1;
const auto stat = static_cast<int32_t>(strtol(start, &end, 10));
if (end != start) {
return stat;
}
}
return REGISTRATION_UNKNOWN;
}
int merge_registration(int lte, int legacy) {
// A multimode modem can be registered or still searching on one network type while the other refuses it
if (is_registered(lte)) {
return lte;
}
if (is_registered(legacy)) {
return legacy;
}
// A definite answer from one query outweighs a timeout of the other
if (lte == REGISTRATION_SEARCHING || legacy == REGISTRATION_SEARCHING) {
return REGISTRATION_SEARCHING;
}
if (lte == REGISTRATION_DENIED || legacy == REGISTRATION_DENIED) {
return REGISTRATION_DENIED;
}
if (lte >= 0 || legacy >= 0) {
return lte >= 0 ? lte : legacy;
}
if (lte == REGISTRATION_NO_ANSWER || legacy == REGISTRATION_NO_ANSWER) {
return REGISTRATION_NO_ANSWER;
}
if (lte == REGISTRATION_UNSUPPORTED && legacy == REGISTRATION_UNSUPPORTED) {
return REGISTRATION_UNSUPPORTED;
}
return REGISTRATION_UNKNOWN;
}
bool reply_names_unsupported(const char *reply) {
static constexpr char PREFIX[] = "+CME ERROR:";
static constexpr char TEXT[] = "operation not supported";
const char *code = strstr(reply, PREFIX);
if (code == nullptr) {
return false;
}
code += sizeof(PREFIX) - 1;
while (*code == ' ') {
code++;
}
return strncasecmp(code, TEXT, sizeof(TEXT) - 1) == 0 || (code[0] == '4' && !isdigit(code[1]));
}
const char *sim_status(char *reply) {
static constexpr char PREFIX[] = "+CPIN:";
char *status = strstr(reply, PREFIX);
if (status == nullptr) {
return nullptr;
}
status += sizeof(PREFIX) - 1;
while (*status == ' ') {
status++;
}
// A URC in the same reply follows on its own line, which flatten_reply() turned into two spaces
char *end = strstr(status, " ");
if (end != nullptr) {
*end = '\0';
}
return status;
}
} // namespace esphome::modem
+67
View File
@@ -0,0 +1,67 @@
#pragma once
#include <cstddef>
#include <cstdint>
// Parsers for raw AT replies; free of esp_modem so they build and run in host unit tests
namespace esphome::modem {
enum class ReplyEnd : uint8_t {
REPLY_END_NONE, // no complete final result line yet
REPLY_END_OK, // an OK line
REPLY_END_ERROR, // an ERROR, +CME ERROR: or +CMS ERROR: line
};
// AT+CEREG? and AT+CREG? <stat> values (3GPP TS 27.007)
static constexpr int REGISTRATION_NOT_SEARCHING = 0;
static constexpr int REGISTRATION_HOME = 1;
static constexpr int REGISTRATION_SEARCHING = 2;
static constexpr int REGISTRATION_DENIED = 3;
static constexpr int REGISTRATION_REPORTED_UNKNOWN = 4;
static constexpr int REGISTRATION_ROAMING = 5;
static constexpr int REGISTRATION_SMS_ONLY_HOME = 6;
static constexpr int REGISTRATION_SMS_ONLY_ROAMING = 7;
static constexpr int REGISTRATION_EMERGENCY_ONLY = 8;
static constexpr int REGISTRATION_CSFB_NOT_PREFERRED_HOME = 9;
static constexpr int REGISTRATION_CSFB_NOT_PREFERRED_ROAMING = 10;
// Results beyond the 3GPP values
static constexpr int REGISTRATION_UNKNOWN = -1; // no readable answer
static constexpr int REGISTRATION_UNSUPPORTED = -2; // the query is not supported
static constexpr int REGISTRATION_NO_ANSWER = -3; // the query timed out
/// Registered on a network, so the data attach can be requested. SMS only and "CSFB not preferred" limit the
/// circuit switched side, not the packet data attach; emergency only (8) is not a registration.
inline bool is_registered(int registration) {
return registration == REGISTRATION_HOME || registration == REGISTRATION_ROAMING ||
(registration >= REGISTRATION_SMS_ONLY_HOME && registration <= REGISTRATION_SMS_ONLY_ROAMING) ||
(registration >= REGISTRATION_CSFB_NOT_PREFERRED_HOME &&
registration <= REGISTRATION_CSFB_NOT_PREFERRED_ROAMING);
}
/// Add data to the reply in buf (size includes the terminator, len is the current length). With whole, data is
/// everything received so far (UART) and replaces the reply; otherwise it is one new CMUX frame and is appended. A
/// reply longer than the buffer keeps its newest bytes, where the final line is. Returns true when bytes were dropped.
bool collect_reply(char *buf, size_t size, size_t &len, const char *data, size_t data_len, bool whole);
/// How the reply ends. Only a complete final result line counts, so ERROR inside a payload line does not; a +CME ERROR
/// line counts even without its reason, which a dropped CMUX frame can take away. With
/// skip_first, the first line is a cut-off fragment and is ignored.
ReplyEnd reply_end(const char *data, size_t len, bool skip_first);
/// Puts a raw reply on one line for the log and drops the final OK; returns the new length
size_t flatten_reply(char *reply, size_t len);
/// The <stat> after the first comma of the "<n>,<stat>" line starting with prefix (+CREG: and friends), or
/// REGISTRATION_UNKNOWN; a one-field line is an unsolicited notification and is skipped
int registration_from_reply(const char *reply, const char *prefix);
/// The state that tells most from the AT+CEREG? (LTE) and AT+CREG? (2G and 3G) results
int merge_registration(int lte, int legacy);
/// Whether an error reply says the command is not supported (+CME ERROR: 4 or its verbose text)
bool reply_names_unsupported(const char *reply);
/// The SIM status in a flattened AT+CPIN? reply, cut before any following line, or nullptr
const char *sim_status(char *reply);
} // namespace esphome::modem
+296 -47
View File
@@ -1,5 +1,6 @@
#ifdef USE_ESP32
#include "modem_component.h"
#include "at_reply.h"
#include "soc/soc_caps.h"
#include <driver/uart.h>
@@ -42,6 +43,14 @@ static constexpr uint32_t PROBE_TIMEOUT_MS = 100;
// A silent modem is not going to answer the next second, so its probes are spaced out, doubling up to a minute
static constexpr uint32_t PROBE_RETRY_DELAY_MS = 5000;
static constexpr uint32_t PROBE_RETRY_MAX_MS = 60000;
// A modem in command mode answers the ATE0 sent before the mode detection within this time
static constexpr uint32_t ECHO_OFF_TIMEOUT_MS = 100;
// The +++ escape needs a second of silence before it; esp_modem waits for the answer after it
static constexpr uint32_t ESCAPE_GUARD_MS = 1100;
// A SIM7670 left in CMUX by an ESP reset ignores every frame until this many flag bytes overflow its receive buffer;
// it then reinitialises its AT channel within about 2 s
static constexpr size_t CMUX_FLUSH_BYTES = 4096;
static constexpr uint32_t CMUX_FLUSH_SETTLE_MS = 3000;
// How long the task waits for the main loop to run on_sync before attaching
static constexpr uint32_t SYNC_ACK_TIMEOUT_MS = 5000;
// esp_modem's command strings and the log lines are built on this stack
@@ -56,6 +65,12 @@ static constexpr uint8_t PIN_MAX_UNCONFIRMED_SENDS = 2;
// The attachment is polled every 4 s; the signal and operator queries only every 4th poll
static constexpr uint32_t ATTACH_POLL_MS = 4000;
static constexpr uint8_t ATTACH_DIAG_EVERY = 4;
static constexpr uint8_t ATTACH_UNKNOWN_POLLS = 15; // about a minute of polls
// AT+CGATT=1: SIMCom documents up to 75 s, but a SIM7080G that is not registered yet held it for 141 s
static constexpr uint32_t ATTACH_TIMEOUT_MS = 150000;
// SIM status polls that fail before a warning, and between repeats of it
static constexpr uint8_t SIM_WARN_AFTER = 10;
static constexpr uint8_t SIM_WARN_EVERY = 60;
static constexpr int RADIO_STATE_MINIMUM = 0; // CFUN=0: radio off and the SIM powered down
static constexpr int RADIO_STATE_RF_OFF = 4; // CFUN=4: transmit and receive off, SIM still powered
static constexpr uint8_t UART_EVENT_QUEUE_SIZE = 10;
@@ -73,8 +88,22 @@ static const LogString *state_to_str(ModemState state) {
// Indexed by ModemFault
PROGMEM_STRING_TABLE(ModemFaultStrings, "", "Modem not responding", "Configured baud rate failed",
"init_at command failed", "SIM not ready", "SIM locked", "SIM PIN not sent; check pin_code",
"PIN record not saved", "APN or radio setup failed", "No network attachment", "PPP link failed",
"Modem teardown failed");
"PIN record not saved", "APN or radio setup failed", "No network attachment",
"Network registration denied", "PPP link failed", "Modem teardown failed");
// Indexed by the AT+CEREG? <stat> value
PROGMEM_STRING_TABLE(RegistrationStrings, "not searching", "registered", "searching", "denied", "unknown", "roaming",
"registered for SMS only", "roaming for SMS only", "emergency only",
"registered, CSFB not preferred", "roaming, CSFB not preferred", "other");
static const LogString *registration_to_str(int registration) {
if (registration == REGISTRATION_UNSUPPORTED) {
return LOG_STR("not supported");
}
if (registration < 0) {
return LOG_STR("not reported");
}
return RegistrationStrings::get_log_str(static_cast<uint8_t>(registration), RegistrationStrings::LAST_INDEX);
}
// Indexed by esp_modem::command_result
PROGMEM_STRING_TABLE(CommandResultStrings, "OK", "FAIL", "TIMEOUT");
@@ -586,6 +615,9 @@ ModemState ModemComponent::compute_next_state_() {
}
ModemState ModemComponent::handle_state_enabling_() {
// With echo on (SIM7670G after power-up), the modem sends esp_modem's PPP probe back and the detection takes it for
// a PPP reply; in PPP or CMUX these bytes are dropped as a bad frame
this->at_reply_("ATE0", ECHO_OFF_TIMEOUT_MS);
// Find the baud rate the modem answers at and leave it in command mode, synced
if (!this->dce_->set_mode(modem_mode::AUTODETECT)) {
// A failed detection keeps the previous mode, which would skip the baud rate search below
@@ -611,21 +643,18 @@ ModemState ModemComponent::handle_state_enabling_() {
exited = false;
const int bauds[] = {this->restored_baud_, this->baud_rate_, FALLBACK_BAUD_RATE};
bool found = false;
bool probed = false;
bool rejected = false;
for (size_t i = 0; i != std::size(bauds) && !found; i++) {
const int baud = bauds[i];
if (baud == 0 || baud == detected || std::find(bauds, bauds + i, baud) != bauds + i) {
continue;
}
if (uart_set_baudrate(static_cast<uart_port_t>(this->uart_port_), baud) != ESP_OK) {
if (this->set_uart_baud_(baud) != ESP_OK) {
ESP_LOGW(TAG, "UART rejected baud rate %d", baud);
this->set_fault_(ModemFault::MODEM_FAULT_BAUD);
rejected = true;
continue;
}
this->current_baud_rate_ = baud;
probed = true;
std::string output;
found = this->dce_->at("AT", output, PROBE_TIMEOUT_MS) == command_result::OK;
if (!found) {
@@ -633,11 +662,31 @@ ModemState ModemComponent::handle_state_enabling_() {
}
}
if (!found) {
// The detection at the current rate already failed; a UART that refused every other rate set BAUD
if (!probed && !rejected) {
// A modem left in data mode before PPP started, or stuck in CMUX, answers none of the probes; both recoveries
// go out at the rate the detection used
if (this->current_baud_rate_ != detected) {
const esp_err_t err = this->set_uart_baud_(detected);
if (err != ESP_OK) {
ESP_LOGW(TAG, "UART rejected baud rate %d (%s); data mode and CMUX recovery skipped", detected,
esp_err_to_name(err));
this->set_fault_(ModemFault::MODEM_FAULT_BAUD);
rejected = true;
}
}
// The escape before the flush is what a stuck SIM7670G responds to; the order is measured, not arbitrary
if (this->current_baud_rate_ == detected && (this->escape_data_mode_() || this->flush_cmux_())) {
exited = true;
break;
}
// A UART that refused a rate set BAUD
if (!rejected) {
this->not_responding_(detected);
}
return this->retry_(ModemState::MODEM_STATE_ENABLING, this->next_probe_delay_());
const uint32_t delay_ms = this->next_probe_delay_();
if (delay_ms == PROBE_RETRY_MAX_MS) {
this->answered_ = false; // silent for minutes, so the wiring hint applies again
}
return this->retry_(ModemState::MODEM_STATE_ENABLING, delay_ms);
}
ESP_LOGD(TAG, "Modem responded at baud %d", this->current_baud_rate_);
break;
@@ -671,10 +720,19 @@ ModemState ModemComponent::handle_state_enabling_() {
this->set_fault_(ModemFault::MODEM_FAULT_TEARDOWN);
return this->retry_(ModemState::MODEM_STATE_ENABLING, this->next_probe_delay_());
}
// The modem answers AT, so it is in command mode. A failed data mode exit leaves esp_modem's UART side in data mode,
// from where its later switch to CMUX fails at once, so its mode is set to match; this sends nothing to the modem.
if (!this->dce_->set_mode(modem_mode::RESUME_COMMAND_MODE)) {
ESP_LOGW(TAG, "esp_modem refused command mode; the switch to PPP may fail");
}
// esp_modem keeps the last line before OK as the reply, which can be the echoed command
if (this->dce_->set_echo(false) != command_result::OK) {
ESP_LOGW(TAG, "Failed to disable command echo");
}
// Verbose +CME ERROR text, so a failed command or a missing SIM says why; a modem without it keeps plain ERROR
if (this->dce_->config_mobile_termination_error(2) != command_result::OK) {
ESP_LOGW(TAG, "Modem refused verbose errors (AT+CMEE=2)");
}
// The SIM7670G only uses an APN written at CFUN=0 (else the attach fails with an ESM failure); CFUN=0 also drops a
// session left by a warm reboot. A modem that refuses gets the APN after the SIM check instead, as before.
@@ -690,6 +748,7 @@ ModemState ModemComponent::handle_state_enabling_() {
ESP_LOGW(TAG, "Failed to power the SIM up");
this->set_fault_(ModemFault::MODEM_FAULT_SETUP);
this->modem_synced_ = true; // it answers, so a disable() still tears it down
this->answered_ = true;
return this->retry_(ModemState::MODEM_STATE_ENABLING, this->next_probe_delay_());
}
this->probe_backoff_.store(0, std::memory_order_relaxed);
@@ -698,12 +757,11 @@ ModemState ModemComponent::handle_state_enabling_() {
ESP_LOGD(TAG, "Setting baud rate: %d -> %d", this->current_baud_rate_, this->baud_rate_);
if (this->dce_->set_baud(this->baud_rate_) == command_result::OK) {
delay(200); // NOLINT
if (uart_set_baudrate(static_cast<uart_port_t>(this->uart_port_), this->baud_rate_) != ESP_OK) {
if (this->set_uart_baud_(this->baud_rate_) != ESP_OK) {
ESP_LOGE(TAG, "UART rejected baud rate %d", this->baud_rate_);
this->set_fault_(ModemFault::MODEM_FAULT_BAUD);
return ModemState::MODEM_STATE_DISCONNECTING;
}
this->current_baud_rate_ = this->baud_rate_;
if (this->dce_->sync() != command_result::OK) {
ESP_LOGE(TAG, "Failed to sync modem at baud rate %d.", this->baud_rate_);
this->set_fault_(ModemFault::MODEM_FAULT_BAUD);
@@ -731,6 +789,7 @@ ModemState ModemComponent::handle_state_enabling_() {
ESP_LOGW(TAG, "Modem refused hardware flow control; UART overruns are possible");
}
this->modem_synced_ = true;
this->answered_ = true;
return ModemState::MODEM_STATE_SYNCED;
}
@@ -746,12 +805,13 @@ ModemState ModemComponent::handle_state_synced_() {
this->clear_config_fault_(ModemFault::MODEM_FAULT_INIT_AT);
}
this->connect_step_ = ConnectStep::CONNECT_STEP_START;
this->sim_polls_ = 0;
return ModemState::MODEM_STATE_CONNECTING;
}
ModemState ModemComponent::handle_state_connecting_() {
if (this->connect_step_ == ConnectStep::CONNECT_STEP_START) {
// ENABLING just synced; only a failed attachment read comes back here unsure of the modem
// ENABLING just synced; a command that timed out comes back here unsure of the modem
if (this->resync_) {
this->resync_ = false;
if (this->dce_->sync() != command_result::OK) {
@@ -792,35 +852,78 @@ ModemState ModemComponent::handle_state_connecting_() {
}
this->connect_step_ = ConnectStep::CONNECT_STEP_RADIO_ON;
this->attach_polls_ = 0;
}
if (this->connect_step_ == ConnectStep::CONNECT_STEP_RADIO_ON) {
// A modem still searching for a network refuses this; the attachment poll asks again
if (this->dce_->set_network_attachment_state(1) != command_result::OK) {
ESP_LOGD(TAG, "Network attachment request refused");
}
this->connect_step_ = ConnectStep::CONNECT_STEP_ATTACH_REQUESTED;
this->idle_polls_ = 0;
this->unknown_polls_ = 0;
}
int attached = 0;
if (this->dce_->get_network_attachment_state(attached) != command_result::OK) {
ESP_LOGW(TAG, "Failed to read the network attachment state");
this->set_fault_(ModemFault::MODEM_FAULT_NOT_ATTACHED);
this->connect_step_ = ConnectStep::CONNECT_STEP_START; // start over with a sync on the next pass
this->resync_ = true;
this->request_resync_();
return this->retry_(ModemState::MODEM_STATE_CONNECTING);
}
if (!attached) {
const int registration = this->read_registration_();
if (registration == REGISTRATION_NO_ANSWER) {
// The state is open, so the modem is checked with a sync instead
ESP_LOGW(TAG, "No answer to a registration query");
this->request_resync_();
this->set_fault_(ModemFault::MODEM_FAULT_NOT_ATTACHED);
return this->retry_(ModemState::MODEM_STATE_CONNECTING);
}
// "Not searching" for a few polls in a row means the attachment is off; right after CFUN=1 it is only brief
this->idle_polls_ = registration == REGISTRATION_NOT_SEARCHING ? static_cast<uint8_t>(this->idle_polls_ + 1) : 0;
const bool idle = this->idle_polls_ >= ATTACH_DIAG_EVERY;
// A state that cannot be read or means nothing here holds the request back only for a while
const bool unknown = registration == REGISTRATION_UNKNOWN || registration == REGISTRATION_REPORTED_UNKNOWN ||
(registration > REGISTRATION_ROAMING && !is_registered(registration));
this->unknown_polls_ = unknown ? static_cast<uint8_t>(this->unknown_polls_ + 1) : 0;
const bool unknown_too_long = this->unknown_polls_ >= ATTACH_UNKNOWN_POLLS;
if (this->connect_step_ == ConnectStep::CONNECT_STEP_RADIO_ON &&
(is_registered(registration) || registration == REGISTRATION_UNSUPPORTED || idle || unknown_too_long)) {
if (unknown_too_long) {
ESP_LOGI(TAG, "Registration state %d (%s) for %u polls; requesting the network attachment anyway", registration,
LOG_STR_ARG(registration_to_str(registration)), this->unknown_polls_);
this->unknown_polls_ = 0;
}
// Before registration a modem can hold the AT channel on this for minutes and drop every command meanwhile,
// so it waits for one; the fallbacks above send it anyway, and ATTACH_TIMEOUT_MS covers that hold
const command_result attach = this->at_reply_("AT+CGATT=1", ATTACH_TIMEOUT_MS);
if (attach == command_result::TIMEOUT) {
ESP_LOGW(TAG, "No answer to the network attachment request");
this->set_fault_(ModemFault::MODEM_FAULT_NOT_ATTACHED);
this->request_resync_();
return this->retry_(ModemState::MODEM_STATE_CONNECTING);
}
if (attach != command_result::OK) {
ESP_LOGW(TAG, "Network attachment request refused: %s", this->reply_);
}
this->connect_step_ = ConnectStep::CONNECT_STEP_ATTACH_REQUESTED;
return this->retry_(ModemState::MODEM_STATE_CONNECTING);
}
if (this->attach_polls_++ % ATTACH_DIAG_EVERY == 0) {
int rssi = 99, ber = 99, registration = -1, mode = -1; // -1 stays when the query fails
this->dce_->get_network_registration_state(registration);
int rssi = 99, ber = 99, mode = -1; // -1 stays when the query fails
this->dce_->get_signal_quality(rssi, ber);
this->dce_->get_network_system_mode(mode);
ESP_LOGW(TAG, "Modem not attached yet: registration %d, network type %d, CSQ %d, BER %d", registration, mode,
rssi, ber);
ESP_LOGW(TAG, "Modem not attached yet: registration %d (%s), network type %d, CSQ %d, BER %d", registration,
LOG_STR_ARG(registration_to_str(registration)), mode, rssi, ber);
if (unknown) {
ESP_LOGW(TAG, "Network attachment request held back while the registration state is unknown (%u of %u polls)",
this->unknown_polls_, ATTACH_UNKNOWN_POLLS);
}
if (registration == REGISTRATION_DENIED) {
// The modem's reason tells a rejected APN (ESM failure) from a SIM the network does not serve
const command_result reason_read = this->at_reply_("AT+CEER");
ESP_LOGW(TAG,
"The network refused registration (AT+CEER %s: %s); check the APN and that the SIM's plan covers "
"this modem's network types",
LOG_STR_ARG(result_to_str(reason_read)), this->reply_);
}
this->connect_step_ = ConnectStep::CONNECT_STEP_RADIO_ON; // request the attachment again
}
this->set_fault_(ModemFault::MODEM_FAULT_NOT_ATTACHED);
this->set_fault_(registration == REGISTRATION_DENIED ? ModemFault::MODEM_FAULT_REGISTRATION_DENIED
: ModemFault::MODEM_FAULT_NOT_ATTACHED);
return this->retry_(ModemState::MODEM_STATE_CONNECTING, ATTACH_POLL_MS);
}
@@ -923,11 +1026,114 @@ void ModemComponent::transition_to_(ModemState next_state) {
}
}
esp_err_t ModemComponent::set_uart_baud_(int baud) {
const esp_err_t err = uart_set_baudrate(static_cast<uart_port_t>(this->uart_port_), baud);
if (err == ESP_OK) {
this->current_baud_rate_ = baud;
}
return err;
}
bool ModemComponent::escape_data_mode_() {
delay(ESCAPE_GUARD_MS); // NOLINT
if (this->dce_->set_command_mode() != command_result::OK) {
ESP_LOGD(TAG, "No answer after the data mode escape");
return false;
}
ESP_LOGW(TAG, "Modem was left in data mode; escaped to command mode");
return true;
}
bool ModemComponent::flush_cmux_() {
// With RTS/CTS a silent modem can hold CTS off; the flag bytes would then stay queued and block every later write
if (this->rts_pin_ != nullptr) {
ESP_LOGW(TAG, "CMUX recovery is not available with RTS/CTS flow control");
return false;
}
static constexpr uint8_t CMUX_FLAG = 0xF9;
uint8_t flags[64];
memset(flags, CMUX_FLAG, sizeof(flags));
const auto port = static_cast<uart_port_t>(this->uart_port_);
for (size_t sent = 0; sent < CMUX_FLUSH_BYTES; sent += sizeof(flags)) {
if (this->dte_->write(flags, sizeof(flags)) != static_cast<int>(sizeof(flags))) {
ESP_LOGW(TAG, "CMUX flush: short write after %u bytes", static_cast<unsigned>(sent));
return false;
}
}
// 10 bits per byte, plus a margin
const uint32_t send_ms = CMUX_FLUSH_BYTES * 10 * 1000 / this->current_baud_rate_ + 100;
if (uart_wait_tx_done(port, pdMS_TO_TICKS(send_ms)) != ESP_OK) {
ESP_LOGW(TAG, "CMUX flush: transmit not finished after %u ms", static_cast<unsigned>(send_ms));
return false;
}
delay(CMUX_FLUSH_SETTLE_MS); // NOLINT
if (this->dce_->sync() != command_result::OK) {
ESP_LOGD(TAG, "No answer after the CMUX flush");
return false;
}
ESP_LOGW(TAG, "Modem was stuck in CMUX; reset it to command mode");
return true;
}
// A command timed out: the next pass checks with a sync that the modem still answers
void ModemComponent::request_resync_() {
this->connect_step_ = ConnectStep::CONNECT_STEP_START;
this->resync_ = true;
}
// One registration query: the <stat>, REGISTRATION_UNSUPPORTED, REGISTRATION_NO_ANSWER or REGISTRATION_UNKNOWN
int ModemComponent::read_stat_(const char *cmd, const char *prefix) {
const command_result result = this->at_reply_(cmd);
if (result == command_result::TIMEOUT) {
return REGISTRATION_NO_ANSWER;
}
if (result == command_result::FAIL && reply_names_unsupported(this->reply_)) {
return REGISTRATION_UNSUPPORTED;
}
const int stat = result == command_result::OK ? registration_from_reply(this->reply_, prefix) : REGISTRATION_UNKNOWN;
if (stat == REGISTRATION_UNKNOWN) {
// An error such as a SIM failure is a warning on the diagnostic polls, so it shows at the default log level
if (result == command_result::FAIL && this->attach_polls_ % ATTACH_DIAG_EVERY == 0) {
ESP_LOGW(TAG, "%s failed: %s", cmd, this->reply_);
} else {
ESP_LOGD(TAG, "%s gave no state: %s", cmd, this->reply_);
}
}
return stat;
}
// AT+CEREG covers LTE; on 2G and 3G the network registration is in AT+CREG, and AT+CGATT=1 is answered quickly once
// it is set. Returns the <stat> that tells most, or one of the negative REGISTRATION_ values.
int ModemComponent::read_registration_() {
const int lte = this->read_stat_("AT+CEREG?", "+CEREG:");
if (is_registered(lte)) {
return lte;
}
return merge_registration(lte, this->read_stat_("AT+CREG?", "+CREG:"));
}
void ModemComponent::not_responding_(int baud) {
ESP_LOGW(TAG, "Modem not responding at %d baud. Check power, PWRKEY and TX/RX wiring.", baud);
if (this->answered_) {
// It answered before, so the wiring is fine; a long command or a modem restart keeps it silent for minutes
ESP_LOGW(TAG, "Modem not responding at %d baud; it may be busy or restarting", baud);
} else {
ESP_LOGW(TAG, "Modem not responding at %d baud. Check power, PWRKEY and TX/RX wiring.", baud);
}
this->set_fault_(ModemFault::MODEM_FAULT_NO_RESPONSE);
}
void ModemComponent::sim_not_ready_(const char *reason) {
// A missing or broken SIM never gets ready; the status is polled every second, so only some polls warn
if (++this->sim_polls_ == SIM_WARN_AFTER + SIM_WARN_EVERY) {
this->sim_polls_ = SIM_WARN_AFTER;
}
if (this->sim_polls_ == SIM_WARN_AFTER) {
ESP_LOGW(TAG, "SIM not ready: %s. Check that a working SIM is inserted",
reason[0] != '\0' ? reason : LOG_STR_LITERAL("no reply"));
}
this->set_fault_(ModemFault::MODEM_FAULT_SIM_NOT_READY);
}
#ifdef USE_MODEM_SEND_AT
bool ModemComponent::send_at(const std::string &cmd, uint32_t timeout) { return this->send_at(cmd.c_str(), timeout); }
@@ -954,13 +1160,54 @@ bool ModemComponent::send_at(const char *cmd, uint32_t timeout) {
#endif
// at() keeps no text from a failed command, so the raw reply is collected into reply_ to show the +CME ERROR
command_result ModemComponent::at_reply_(const char *cmd, uint32_t timeout) {
std::string line = cmd; // poll commands fit the short string buffer
line += '\r';
this->reply_len_ = 0;
this->reply_[0] = '\0';
#ifdef CONFIG_ESP_MODEM_USE_INFLATABLE_BUFFER_IF_NEEDED
// The inflatable buffer gathers CMUX frames too, so every reply comes over whole each time
const bool whole = true;
#else
// esp_modem hands a UART reply over whole each time, and a CMUX reply one frame at a time
const modem_mode mode = this->dce_->get_mode();
const bool whole = mode != modem_mode::CMUX_MODE && mode != modem_mode::CMUX_MANUAL_MODE &&
mode != modem_mode::CMUX_MANUAL_DATA && mode != modem_mode::CMUX_MANUAL_COMMAND;
#endif
struct {
bool whole;
bool cut;
} state{whole, false};
const command_result result = this->dce_->command(
line,
[this, &state](const uint8_t *data, size_t len) {
// OK, or FAIL once an ERROR line has ended (the +CME ERROR reason may still be on its way), else TIMEOUT
state.cut |= collect_reply(this->reply_, sizeof(this->reply_), this->reply_len_,
reinterpret_cast<const char *>(data), len, state.whole);
switch (reply_end(this->reply_, this->reply_len_, state.cut)) {
case ReplyEnd::REPLY_END_OK:
return command_result::OK;
case ReplyEnd::REPLY_END_ERROR:
return command_result::FAIL;
default:
return command_result::TIMEOUT;
}
},
timeout);
this->reply_len_ = flatten_reply(this->reply_, this->reply_len_);
this->reply_cut_ = state.cut;
return result;
}
command_result ModemComponent::at_(const char *cmd, uint32_t timeout) {
std::string output;
const command_result result = this->dce_->at(cmd, output, timeout);
const command_result result = this->at_reply_(cmd, timeout);
// A reply longer than the buffer kept only its end
const char *cut = this->reply_cut_ ? LOG_STR_LITERAL("...") : "";
if (result == command_result::OK) {
ESP_LOGI(TAG, "AT '%s' -> OK: %s", cmd, output.c_str());
ESP_LOGI(TAG, "AT '%s' -> OK: %s%s", cmd, cut, this->reply_);
} else {
ESP_LOGW(TAG, "AT '%s' -> %s: %s", cmd, LOG_STR_ARG(result_to_str(result)), output.c_str());
ESP_LOGW(TAG, "AT '%s' -> %s: %s%s", cmd, LOG_STR_ARG(result_to_str(result)), cut, this->reply_);
}
return result;
}
@@ -973,25 +1220,27 @@ SimResult ModemComponent::prepare_sim_() {
return SimResult::SIM_RESULT_RETRY; // the save wakes the task
}
#endif
std::string output;
if (this->dce_->at("AT+CPIN?", output, COMMAND_TIMEOUT_MS) != command_result::OK) {
// The raw reply keeps the +CME ERROR text a missing SIM gives; status below points into it
const command_result result = this->at_reply_("AT+CPIN?");
if (result == command_result::TIMEOUT) {
// The next pass checks with a sync whether the modem or only the SIM interface is silent
ESP_LOGD(TAG, "No answer to the SIM status request");
this->sim_not_ready_(LOG_STR_LITERAL("no answer to AT+CPIN?"));
this->request_resync_();
return SimResult::SIM_RESULT_RETRY;
}
if (result != command_result::OK) {
// A SIM that is still starting answers with an error for a second or so
ESP_LOGD(TAG, "SIM status not readable yet: %s", output.c_str());
this->set_fault_(ModemFault::MODEM_FAULT_SIM_NOT_READY);
ESP_LOGD(TAG, "SIM status not readable yet: %s", this->reply_);
this->sim_not_ready_(this->reply_);
return SimResult::SIM_RESULT_RETRY;
}
// Anything else, such as an echoed command, is not a status and must not reach the lock checks below
const char *found = strstr(output.c_str(), "+CPIN:");
if (found != nullptr) {
found += sizeof("+CPIN:") - 1;
while (*found == ' ') {
found++;
}
}
const char *found = sim_status(this->reply_);
const StringRef status = found != nullptr ? StringRef(found) : StringRef();
if (status.empty()) {
ESP_LOGD(TAG, "SIM status not reported yet: %s", output.c_str());
this->set_fault_(ModemFault::MODEM_FAULT_SIM_NOT_READY);
ESP_LOGD(TAG, "SIM status not reported yet: %s", this->reply_);
this->sim_not_ready_(this->reply_);
return SimResult::SIM_RESULT_RETRY;
}
ESP_LOGD(TAG, "SIM: %s", status.c_str());
@@ -1019,8 +1268,8 @@ SimResult ModemComponent::prepare_sim_() {
this->set_fault_(ModemFault::MODEM_FAULT_SIM_LOCKED);
return SimResult::SIM_RESULT_LOCKED;
}
ESP_LOGW(TAG, "SIM not ready: %s", status.c_str()); // e.g. NOT READY or NOT INSERTED
this->set_fault_(ModemFault::MODEM_FAULT_SIM_NOT_READY);
ESP_LOGD(TAG, "SIM not ready: %s", status.c_str()); // e.g. NOT READY or NOT INSERTED
this->sim_not_ready_(status.c_str());
return SimResult::SIM_RESULT_RETRY;
}
#ifdef USE_MODEM_PIN_CODE
+22 -1
View File
@@ -62,6 +62,7 @@ enum class ModemFault : uint8_t {
MODEM_FAULT_PIN_RECORD,
MODEM_FAULT_SETUP,
MODEM_FAULT_NOT_ATTACHED,
MODEM_FAULT_REGISTRATION_DENIED,
MODEM_FAULT_PPP,
MODEM_FAULT_TEARDOWN,
};
@@ -151,6 +152,7 @@ class ModemComponent : public Component {
static constexpr uint32_t RETRY_DELAY_MS = 1000;
static constexpr size_t URC_LINE_SIZE = 128;
static constexpr size_t AT_COMMAND_SIZE = 128;
static constexpr size_t REPLY_SIZE = 256; // a longer reply keeps its newest bytes, so its final line counts
#ifdef USE_MODEM_POLL
static constexpr uint8_t CSQ_UNKNOWN = 99; // AT+CSQ rssi or ber the modem cannot tell
static constexpr uint8_t CSQ_RSSI_MAX = 31;
@@ -200,8 +202,20 @@ class ModemComponent : public Component {
void hand_over_(uint32_t pending);
/// Send an AT command from the task and log the result; blocks for up to the timeout
esp_modem::command_result at_(const char *cmd, uint32_t timeout = COMMAND_TIMEOUT_MS);
/// Send an AT command; reply_ gets the whole reply on one line, including any +CME ERROR text
esp_modem::command_result at_reply_(const char *cmd, uint32_t timeout = COMMAND_TIMEOUT_MS);
void publish_status_();
/// Send the +++ escape with its guard times; true when the modem answered
bool escape_data_mode_();
/// Overflow a stuck CMUX receiver with flag bytes; true when the modem answers AT afterwards
bool flush_cmux_();
void request_resync_();
int read_stat_(const char *cmd, const char *prefix);
int read_registration_();
/// Set the UART rate; current_baud_rate_ follows when the UART takes it
esp_err_t set_uart_baud_(int baud);
void not_responding_(int baud);
void sim_not_ready_(const char *reason);
void dump_connect_params_();
SimResult prepare_sim_();
#ifdef USE_MODEM_PIN_CODE
@@ -221,6 +235,9 @@ class ModemComponent : public Component {
const char *urc_line_{nullptr}; // the line urc_pending_ hands to loop(), inside urc_reader_
#endif
std::unique_ptr<esp_modem::DCE> dce_;
char reply_[REPLY_SIZE + 1]{}; // task only; the last reply, null-terminated
size_t reply_len_{0};
bool reply_cut_{false}; // the last reply was longer than reply_ and kept only its end
std::shared_ptr<esp_modem::DTE> dte_;
esp_netif_t *ppp_netif_{nullptr};
ESPPreferenceObject pref_;
@@ -291,6 +308,9 @@ class ModemComponent : public Component {
uint8_t init_at_count_{0};
uint8_t uart_port_{UART_NUM_MAX};
uint8_t attach_polls_{0};
uint8_t idle_polls_{0}; // polls in a row that reported "not searching"
uint8_t unknown_polls_{0}; // polls in a row with no usable registration state
uint8_t sim_polls_{0}; // failed SIM status reads in this attempt
#ifdef USE_MODEM_POLL
uint8_t poll_rssi_{CSQ_UNKNOWN}; // raw AT+CSQ answers
uint8_t poll_ber_{CSQ_UNKNOWN};
@@ -298,7 +318,8 @@ class ModemComponent : public Component {
#endif
bool connect_timeout_armed_{false};
bool modem_synced_{false}; // a modem that never answered has nothing to tear down
bool resync_{false}; // the attachment read failed, so CONNECTING syncs again first
bool answered_{false}; // the modem synced since boot, so its wiring and power are fine
bool resync_{false}; // a command timed out, so CONNECTING syncs again first
bool apn_pending_{false}; // ENABLING could not set the APN at CFUN=0, so CONNECTING sets it after the SIM check
#ifdef USE_MODEM_SEND_AT
char at_command_[AT_COMMAND_SIZE];
+6 -3
View File
@@ -325,8 +325,9 @@ bool MQTTClientComponent::can_proceed() {
void MQTTClientComponent::start_dnslookup_() {
this->status_set_warning();
// No lookup can start before the network is up: there is no DNS server to ask yet.
// Stay disconnected, and loop() calls this again.
if (!network::is_connected())
// Stay disconnected, and loop() calls this again as soon as it is up.
this->waiting_for_network_ = !network::is_connected();
if (this->waiting_for_network_)
return;
for (auto &subscription : this->subscriptions_) {
@@ -514,7 +515,9 @@ void MQTTClientComponent::loop() {
case MQTT_CLIENT_DISABLED:
return; // Return to avoid a reboot when disabled
case MQTT_CLIENT_DISCONNECTED:
if (now - this->connect_begin_ > 5000) {
// Back off 5 s after a failed attempt. Without a network no attempt was made, so the
// first one starts as soon as the network is up instead of 5 s after boot.
if (this->waiting_for_network_ || now - this->connect_begin_ > 5000) {
this->start_dnslookup_();
}
break;
+2
View File
@@ -436,6 +436,8 @@ class MQTTClientComponent final : public Component {
network::IPAddress ip_;
bool dns_resolved_{false};
bool dns_resolve_error_{false};
/// The last start_dnslookup_() found no network, so no attempt was made and there is nothing to back off from
bool waiting_for_network_{false};
bool enable_on_boot_{true};
#ifdef USE_MQTT_CRASH_LOG
bool crash_log_offered_{false};
+10
View File
@@ -0,0 +1,10 @@
"""Pioneer WT series mini splits, controlled through the serial port of the WiFi module."""
import esphome.codegen as cg
CODEOWNERS = ["@martinsah"]
DOMAIN = "pioneer_wt"
pioneer_wt_ns = cg.esphome_ns.namespace("pioneer_wt")
CONF_PIONEER_WT_ID = "pioneer_wt_id"
+33
View File
@@ -0,0 +1,33 @@
import esphome.codegen as cg
from esphome.components import climate, uart
import esphome.config_validation as cv
from esphome.types import ConfigType
from . import DOMAIN, pioneer_wt_ns
DEPENDENCIES = ["uart"]
PioneerWT = pioneer_wt_ns.class_(
"PioneerWT", climate.Climate, uart.UARTDevice, cg.Component
)
CONFIG_SCHEMA = (
climate.climate_schema(PioneerWT)
.extend(uart.UART_DEVICE_SCHEMA)
.extend(cv.COMPONENT_SCHEMA)
)
FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
DOMAIN,
baud_rate=115200,
require_tx=True,
require_rx=True,
data_bits=8,
parity="NONE",
stop_bits=1,
)
async def to_code(config: ConfigType) -> None:
var = await uart.new_uart_component(config)
await climate.register_climate(var, config)
@@ -0,0 +1,348 @@
#include "pioneer_wt.h"
#include <cinttypes>
#include <cmath>
#include <cstring>
#include <iterator>
#include "esphome/core/application.h"
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
namespace esphome::pioneer_wt {
ESPHOME_LOG_TAG(TAG, "pioneer_wt");
static constexpr uint32_t RESEND_INTERVAL_MS = 500;
static constexpr uint8_t MAX_ATTEMPTS = 4;
// Ask for a full status again if the AC has reported nothing for this long.
static constexpr uint32_t STATUS_REFRESH_MS = 5 * 60 * 1000;
// Until the first full status has arrived, ask again this often.
static constexpr uint32_t STATUS_RETRY_MS = 30 * 1000;
// A frame arrives in one burst; after a pause this long a partly received frame is dropped.
static constexpr uint32_t RX_GAP_MS = 100;
static constexpr float MIN_TEMPERATURE_C = 16.0f;
static constexpr float MAX_TEMPERATURE_C = 31.0f;
static constexpr uint8_t FAN_SPEED_COUNT = 7;
static constexpr const char *const FAN_SPEED_NAMES[FAN_SPEED_COUNT] PROGMEM = {
"Speed 1", "Speed 2", "Speed 3", "Speed 4", "Speed 5", "Speed 6", "Speed 7"};
// Reply to the AC's once-a-minute check, as the stock module sends it. The last body byte is the
// WiFi signal in dBm; a fixed -48 is enough for the AC.
static constexpr uint8_t PRESENCE_REPLY_FRAME[] PROGMEM = {0xA5, 0x01, 0x00, 0x23, 0x00, 0x00, 0x00, 0x12, 0x47,
0x09, 0x80, 0x0C, 0x02, 0x64, 0xFF, 0xFF, 0xFF, 0xD0};
// Climate mode for each value of ATTR_MODE
static constexpr uint8_t CLIMATE_MODES[] PROGMEM = {
climate::CLIMATE_MODE_HEAT_COOL, climate::CLIMATE_MODE_COOL, climate::CLIMATE_MODE_DRY,
climate::CLIMATE_MODE_FAN_ONLY, climate::CLIMATE_MODE_HEAT,
};
void PioneerWT::setup() {
this->set_supported_custom_fan_modes_static(FAN_SPEED_NAMES, FAN_SPEED_COUNT);
this->request_status_();
#ifdef USE_SWITCH
if (this->display_switch_ != nullptr)
this->display_switch_->restore();
if (this->beeper_switch_ != nullptr)
this->beeper_switch_->restore();
#endif
}
climate::ClimateTraits PioneerWT::traits() {
auto traits = climate::ClimateTraits();
traits.add_feature_flags(climate::CLIMATE_SUPPORTS_CURRENT_TEMPERATURE);
traits.set_supported_modes({climate::CLIMATE_MODE_OFF, climate::CLIMATE_MODE_HEAT_COOL, climate::CLIMATE_MODE_COOL,
climate::CLIMATE_MODE_HEAT, climate::CLIMATE_MODE_DRY, climate::CLIMATE_MODE_FAN_ONLY});
traits.set_supported_fan_modes({climate::CLIMATE_FAN_AUTO});
traits.set_supported_swing_modes({climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL});
traits.set_supported_presets({climate::CLIMATE_PRESET_NONE, climate::CLIMATE_PRESET_ECO});
traits.set_visual_min_temperature(MIN_TEMPERATURE_C);
traits.set_visual_max_temperature(MAX_TEMPERATURE_C);
// The AC keeps its setpoint in whole degrees Fahrenheit, so half degrees Celsius would not all be kept.
traits.set_visual_target_temperature_step(1.0f);
traits.set_visual_current_temperature_step(0.1f);
return traits;
}
void PioneerWT::loop() {
const uint32_t now = App.get_loop_component_start_time();
if (const size_t count = this->available()) {
this->last_rx_ = now;
this->read_available(
[this](uint8_t byte) {
if (const size_t len = this->reader_.feed(byte))
this->handle_frame_(this->reader_.frame(), len);
},
count);
if (this->reader_.take_checksum_error()) {
ESP_LOGD(TAG, "Dropped a frame with a wrong checksum");
}
} else if (this->reader_.partial() && now - this->last_rx_ >= RX_GAP_MS) {
// Only on an idle pass: after a slow loop the rest of the frame may already be buffered.
this->reader_.reset();
}
if (!this->queue_.empty() && now - this->last_send_ >= RESEND_INTERVAL_MS)
this->send_pending_();
// The target temperature only arrives in a full status, so it tells whether one has been received.
const uint32_t status_interval = std::isnan(this->target_temperature) ? STATUS_RETRY_MS : STATUS_REFRESH_MS;
if (now - this->last_status_ >= status_interval)
this->request_status_();
}
void PioneerWT::handle_frame_(const uint8_t *frame, size_t len) {
const uint8_t flags = frame[2];
const uint8_t type = frame[3];
const uint8_t seq = frame[4];
const uint8_t ack = frame[5];
const uint8_t *payload = frame + HEADER_SIZE;
const size_t payload_len = len - HEADER_SIZE;
ESP_LOGVV_HEX(TAG, frame, len, MAX_FRAME_SIZE, "RX %s");
if (type == TYPE_REPLY) {
if (!this->queue_.empty() && this->queue_.front().seq == ack) {
if (this->queue_.front().power != POWER_UNCHANGED)
this->acked_power_ = this->queue_.front().power;
// Pop first: the warning log can run automations that queue another command.
this->pop_command_();
this->status_clear_warning();
this->last_send_ = 0; // send the next one right away
}
return;
}
if (type != TYPE_DATA || payload_len < 2)
return;
const uint8_t msg_class = payload[0];
if (flags & FLAG_WANT_ACK)
this->write_frame_(FLAG_WANT_ACK, TYPE_REPLY, 0, seq, CLASS_REPLY, msg_class, nullptr, 0);
if (msg_class != CLASS_STATUS)
return;
if (payload_len == 2) {
if (!(flags & FLAG_WANT_ACK))
this->write_array_progmem(PRESENCE_REPLY_FRAME, sizeof(PRESENCE_REPLY_FRAME));
return;
}
this->handle_status_(payload + 2, payload_len - 2);
// Reports count only once a full status has arrived, so the boot request is repeated until one does.
if (!std::isnan(this->target_temperature))
this->last_status_ = App.get_loop_component_start_time();
}
void PioneerWT::handle_status_(const uint8_t *body, size_t len) {
AttributeReader attrs(body, len);
bool changed = false;
while (attrs.next()) {
const uint32_t v = attrs.value();
switch (attrs.id()) {
case ATTR_POWER:
this->power_ = v != 0;
this->acked_power_ = POWER_UNCHANGED;
break;
case ATTR_MODE:
if (v < std::size(CLIMATE_MODES)) {
this->ac_mode_ = v;
} else {
ESP_LOGD(TAG, "Unknown mode %" PRIu32, v);
}
break;
case ATTR_SETPOINT_F: {
const float target = fahrenheit_to_celsius(v);
changed |= target != this->target_temperature;
this->target_temperature = target;
break;
}
case ATTR_INDOOR_TEMP_C100: {
const float current = static_cast<float>(v) / 100.0f;
changed |= current != this->current_temperature;
this->current_temperature = current;
break;
}
case ATTR_FAN_SPEED:
if (v == 0) {
changed |= this->set_fan_mode_(climate::CLIMATE_FAN_AUTO);
} else if (v <= FAN_SPEED_COUNT) {
changed |= this->set_custom_fan_mode_(FAN_SPEED_NAMES[v - 1]);
} else {
ESP_LOGD(TAG, "Unknown fan speed %" PRIu32, v);
}
break;
case ATTR_SWING_VERTICAL: {
const auto swing = v == SWING_ON ? climate::CLIMATE_SWING_VERTICAL : climate::CLIMATE_SWING_OFF;
changed |= swing != this->swing_mode;
this->swing_mode = swing;
break;
}
case ATTR_ECO:
changed |= this->set_preset_(v ? climate::CLIMATE_PRESET_ECO : climate::CLIMATE_PRESET_NONE);
break;
#ifdef USE_SWITCH
case ATTR_DISPLAY:
PUBLISH_STATE(this->display_switch_, v != 0);
break;
case ATTR_BEEPER:
PUBLISH_STATE(this->beeper_switch_, v != 0);
break;
#endif
default:
break;
}
}
if (attrs.stopped_on_unknown()) {
ESP_LOGD(TAG, "Status attribute %04X has an unknown size; ignored the rest of the frame", attrs.id());
}
const auto mode = this->power_ ? static_cast<climate::ClimateMode>(progmem_read_byte(&CLIMATE_MODES[this->ac_mode_]))
: climate::CLIMATE_MODE_OFF;
changed |= mode != this->mode;
this->mode = mode;
if (changed)
this->publish_state();
}
void PioneerWT::control(const climate::ClimateCall &call) {
uint8_t body[MAX_BODY_SIZE];
uint8_t *p = body;
int8_t power = POWER_UNCHANGED;
if (call.get_mode().has_value()) {
const auto mode = *call.get_mode();
if (mode == climate::CLIMATE_MODE_OFF) {
power = 0;
p = put_attr(p, ATTR_POWER, 0);
} else {
uint8_t ac_mode = 0;
for (size_t i = 0; i < std::size(CLIMATE_MODES); i++) {
if (progmem_read_byte(&CLIMATE_MODES[i]) == mode) {
ac_mode = i;
break;
}
}
// Queued commands count: an "off" still waiting to be sent is followed by a power on.
if (!this->wanted_power_(this->queue_.size() == TX_QUEUE_SIZE)) {
power = 1;
p = put_attr(p, ATTR_POWER, 1);
}
p = put_attr(p, ATTR_MODE, ac_mode);
}
}
if (call.get_target_temperature().has_value()) {
// Automations can ask for any value; the visual range is not enforced for them.
const float celsius = clamp(*call.get_target_temperature(), MIN_TEMPERATURE_C, MAX_TEMPERATURE_C);
p = put_be32(put_be16(p, ATTR_SETPOINT_F), lroundf(celsius_to_fahrenheit(celsius)));
}
// The app always sends fan speed with these companions; match it exactly.
int fan_speed = -1;
if (call.get_fan_mode().has_value() && *call.get_fan_mode() == climate::CLIMATE_FAN_AUTO) {
fan_speed = 0;
} else if (call.has_custom_fan_mode()) {
// The call holds the pointer from FAN_SPEED_NAMES, so the pointers can be compared.
const char *name = call.get_custom_fan_mode().c_str();
for (uint8_t i = 0; i < FAN_SPEED_COUNT; i++) {
if (name == FAN_SPEED_NAMES[i]) {
fan_speed = i + 1;
break;
}
}
}
if (fan_speed >= 0) {
p = put_attr(p, ATTR_FAN_EXTRA_1, 0);
p = put_attr(p, ATTR_FAN_EXTRA_2, 0);
p = put_attr(p, ATTR_FAN_SPEED, fan_speed);
p = put_attr(p, ATTR_FAN_AUTO, fan_speed == 0);
}
if (call.get_swing_mode().has_value()) {
const bool swing = *call.get_swing_mode() == climate::CLIMATE_SWING_VERTICAL;
p = put_attr(p, ATTR_SWING_VERTICAL, swing ? SWING_ON : SWING_OFF);
}
if (call.get_preset().has_value())
p = put_attr(p, ATTR_ECO, *call.get_preset() == climate::CLIMATE_PRESET_ECO);
if (p != body)
this->queue_command_(CLASS_COMMAND, body, p - body, power);
// State is published when the AC reports the new values back.
}
void PioneerWT::send_setting_(uint16_t attr, bool on) {
uint8_t body[3];
put_attr(body, attr, on);
this->queue_command_(CLASS_COMMAND, body, sizeof(body));
}
void PioneerWT::request_status_() {
// Asks the AC to send every setting, as the stock module does at boot.
static constexpr uint8_t REQUEST_ALL[] = {0xFF, 0xFF};
this->queue_command_(CLASS_NETWORK, REQUEST_ALL, sizeof(REQUEST_ALL));
this->last_status_ = App.get_loop_component_start_time();
}
void PioneerWT::queue_command_(uint8_t msg_class, const uint8_t *body, size_t len, int8_t power) {
if (this->queue_.size() == TX_QUEUE_SIZE) {
ESP_LOGW(TAG, "Command queue full; dropping the oldest command");
this->pop_command_();
}
PendingCommand pending{msg_class, this->next_seq_++, static_cast<uint8_t>(len), power, {}};
std::memcpy(pending.body.data(), body, len);
this->queue_.push(pending);
if (this->next_seq_ == 0)
this->next_seq_ = 1;
}
void PioneerWT::pop_command_() {
this->queue_.pop();
this->attempts_ = 0;
}
bool PioneerWT::wanted_power_(bool skip_head) const {
// An acknowledged power change counts until the AC reports the power
bool power = this->acked_power_ == POWER_UNCHANGED ? this->power_ : this->acked_power_;
for (const PendingCommand &pending : this->queue_) {
if (skip_head) {
skip_head = false;
continue;
}
if (pending.power != POWER_UNCHANGED)
power = pending.power;
}
return power;
}
void PioneerWT::send_pending_() {
const PendingCommand &pending = this->queue_.front();
if (this->attempts_ >= MAX_ATTEMPTS) {
const uint8_t seq = pending.seq;
// Pop first: the warning log can run automations that queue another command.
this->pop_command_();
ESP_LOGD(TAG, "No acknowledgement for command seq %02X; giving up", seq);
this->status_set_warning(LOG_STR("No acknowledgement"));
return;
}
this->attempts_++;
this->write_frame_(FLAG_WANT_ACK, TYPE_DATA, pending.seq, 0, pending.msg_class, pending.msg_class,
pending.body.data(), pending.len);
this->last_send_ = App.get_loop_component_start_time();
}
void PioneerWT::write_frame_(uint8_t flags, uint8_t type, uint8_t seq, uint8_t ack, uint8_t class_1, uint8_t class_2,
const uint8_t *body, size_t len) {
uint8_t frame[HEADER_SIZE + 2 + MAX_BODY_SIZE];
const size_t total = build_frame(frame, flags, type, seq, ack, class_1, class_2, body, len);
ESP_LOGVV_HEX(TAG, frame, total, sizeof(frame), "TX %s");
this->write_array(frame, total);
}
void PioneerWT::dump_config() {
LOG_CLIMATE("", "Pioneer WT", this);
#ifdef USE_SWITCH
LOG_SWITCH(" ", "Display", this->display_switch_);
LOG_SWITCH(" ", "Beeper", this->beeper_switch_);
#endif
}
} // namespace esphome::pioneer_wt
@@ -0,0 +1,85 @@
#pragma once
#include <array>
#include <cstdint>
#include "esphome/components/climate/climate.h"
#include "esphome/components/uart/uart.h"
#include "esphome/core/component.h"
#include "esphome/core/defines.h"
#include "esphome/core/helpers.h"
#ifdef USE_SWITCH
#include "esphome/components/switch/switch.h"
#endif
#include "pioneer_wt_protocol.h"
namespace esphome::pioneer_wt {
// The largest body control() builds is 30 bytes.
static constexpr size_t MAX_BODY_SIZE = 32;
static constexpr size_t TX_QUEUE_SIZE = 4;
class PioneerWT final : public climate::Climate, public uart::UARTDevice, public Component {
public:
void setup() override;
void loop() override;
void dump_config() override;
/// Turns the indoor unit's front display on or off.
void set_display_on(bool on) { this->send_setting_(ATTR_DISPLAY, on); }
/// Turns the beep that confirms each command on or off.
void set_beeper_on(bool on) { this->send_setting_(ATTR_BEEPER, on); }
#ifdef USE_SWITCH
SUB_SWITCH(display)
SUB_SWITCH(beeper)
#endif
protected:
climate::ClimateTraits traits() override;
void control(const climate::ClimateCall &call) override;
void handle_frame_(const uint8_t *frame, size_t len);
void handle_status_(const uint8_t *body, size_t len);
void write_frame_(uint8_t flags, uint8_t type, uint8_t seq, uint8_t ack, uint8_t class_1, uint8_t class_2,
const uint8_t *body, size_t len);
/// Queues a data frame that the AC must acknowledge; it is resent until it is.
void queue_command_(uint8_t msg_class, const uint8_t *body, size_t len, int8_t power = POWER_UNCHANGED);
void send_pending_();
/// Removes the command at the head of the queue.
void pop_command_();
/// Power once the queued commands are applied; skip_head leaves out a head about to be dropped.
bool wanted_power_(bool skip_head) const;
/// Queues a command that sets one on/off attribute.
void send_setting_(uint16_t attr, bool on);
void request_status_();
static constexpr int8_t POWER_UNCHANGED = -1;
struct PendingCommand {
uint8_t msg_class;
uint8_t seq;
uint8_t len;
// Power the command sets: 0, 1 or POWER_UNCHANGED
int8_t power;
std::array<uint8_t, MAX_BODY_SIZE> body;
};
uint32_t last_send_{0};
// Time of the last status report (counted once a full one has arrived), or of the last request for one
uint32_t last_status_{0};
uint32_t last_rx_{0};
PacketReader reader_;
StaticRingBuffer<PendingCommand, TX_QUEUE_SIZE> queue_;
// Send attempts of the command at the head of the queue
uint8_t attempts_{0};
uint8_t next_seq_{1};
// Power the AC last reported
bool power_{false};
// Power set by an acknowledged command, until the next power report: 0, 1 or POWER_UNCHANGED
int8_t acked_power_{POWER_UNCHANGED};
// Value of ATTR_MODE: 0 auto, 1 cool, 2 dry, 3 fan, 4 heat
uint8_t ac_mode_{0};
};
} // namespace esphome::pioneer_wt
@@ -0,0 +1,147 @@
#include "pioneer_wt_protocol.h"
#include <cstring>
#include "esphome/core/hal.h"
namespace esphome::pioneer_wt {
uint16_t frame_crc(const uint8_t *frame, size_t len) {
const uint16_t head = crc16be(frame, 8);
return crc16be(frame + HEADER_SIZE, len - HEADER_SIZE, head);
}
size_t PacketReader::feed(uint8_t byte) {
if (this->pos_ == 0 && byte != 0xA5)
return 0;
if (this->pos_ == 1 && byte != 0x01) {
this->pos_ = byte == 0xA5 ? 1 : 0;
return 0;
}
this->buf_[this->pos_++] = byte;
if (this->pos_ < 8)
return 0;
const uint8_t len = this->buf_[7];
if (len < HEADER_SIZE) {
this->pos_ = 0;
return 0;
}
if (this->pos_ < len)
return 0;
this->pos_ = 0;
if (frame_crc(this->buf_.data(), len) != encode_uint16(this->buf_[8], this->buf_[9])) {
this->checksum_error_ = true;
return 0;
}
return len;
}
enum class AttrKind : uint8_t {
ATTR_KIND_UNKNOWN,
ATTR_KIND_ONE_BYTE,
ATTR_KIND_FOUR_BYTES,
// One count byte, then that many bytes
ATTR_KIND_COUNT_PREFIXED,
// Two length bytes, then that many bytes
ATTR_KIND_LENGTH_PREFIXED,
};
// The reader must know how every attribute is stored to step over the ones it does not use.
// The IDs are grouped by storage.
static constexpr uint16_t ONE_BYTE_IDS[] PROGMEM = {
0x0001, 0x0005, 0x000C, 0x000D, 0x000E, 0x0011, 0x0012, 0x0013, 0x0017, 0x001E, 0x0022, 0x0025, 0x0026, 0x0027,
0x002D, 0x0035, 0x005E, 0x0073, 0x0074, 0x00A4, 0x00C9, 0x00DF, 0x0148, 0x015E, 0x0173, 0x0224, 0x0225,
};
static constexpr uint16_t FOUR_BYTE_IDS[] PROGMEM = {
0x0002, 0x0003, 0x003D, 0x0041, 0x0042, 0x005C, 0x0060, 0x0064, 0x0065,
0x0072, 0x0095, 0x00BD, 0x00BE, 0x00BF, 0x00C0, 0x0221, 0x0222, 0x0227,
};
static constexpr uint16_t COUNT_PREFIXED_IDS[] PROGMEM = {0x0038, 0x0039};
static constexpr uint16_t LENGTH_PREFIXED_IDS[] PROGMEM = {0x00FA, 0x00FB, 0x0147, 0x0223};
template<size_t N> static bool contains(const uint16_t (&ids)[N], uint16_t id) {
for (const uint16_t &entry : ids) {
if (progmem_read_uint16(&entry) == id)
return true;
}
return false;
}
static AttrKind attr_kind(uint16_t id) {
if (contains(ONE_BYTE_IDS, id))
return AttrKind::ATTR_KIND_ONE_BYTE;
if (contains(FOUR_BYTE_IDS, id))
return AttrKind::ATTR_KIND_FOUR_BYTES;
if (contains(COUNT_PREFIXED_IDS, id))
return AttrKind::ATTR_KIND_COUNT_PREFIXED;
if (contains(LENGTH_PREFIXED_IDS, id))
return AttrKind::ATTR_KIND_LENGTH_PREFIXED;
return AttrKind::ATTR_KIND_UNKNOWN;
}
bool AttributeReader::next() {
if (this->pos_ + 2 > this->len_)
return false;
const uint8_t *data = this->data_;
const uint16_t id = encode_uint16(data[this->pos_], data[this->pos_ + 1]);
size_t start = this->pos_ + 2;
size_t value_len;
const AttrKind kind = attr_kind(id);
switch (kind) {
case AttrKind::ATTR_KIND_ONE_BYTE:
value_len = 1;
break;
case AttrKind::ATTR_KIND_FOUR_BYTES:
value_len = 4;
break;
case AttrKind::ATTR_KIND_COUNT_PREFIXED:
if (start + 1 > this->len_)
return false;
value_len = data[start++];
break;
case AttrKind::ATTR_KIND_LENGTH_PREFIXED:
if (start + 2 > this->len_)
return false;
value_len = encode_uint16(data[start], data[start + 1]);
start += 2;
break;
default:
this->id_ = id;
this->unknown_ = true;
return false;
}
if (start + value_len > this->len_)
return false;
this->id_ = id;
const uint8_t *v = data + start;
if (kind == AttrKind::ATTR_KIND_ONE_BYTE) {
this->value_ = v[0];
} else if (kind == AttrKind::ATTR_KIND_FOUR_BYTES) {
this->value_ = encode_uint32(v[0], v[1], v[2], v[3]);
} else {
this->value_ = 0;
}
this->pos_ = start + value_len;
return true;
}
size_t build_frame(uint8_t *out, uint8_t flags, uint8_t type, uint8_t seq, uint8_t ack, uint8_t class_1,
uint8_t class_2, const uint8_t *body, size_t len) {
const size_t total = HEADER_SIZE + 2 + len;
out[0] = 0xA5;
out[1] = 0x01;
out[2] = flags;
out[3] = type;
out[4] = seq;
out[5] = ack;
out[6] = 0x00;
out[7] = total;
out[HEADER_SIZE] = class_1;
out[HEADER_SIZE + 1] = class_2;
if (len)
std::memcpy(out + HEADER_SIZE + 2, body, len);
put_be16(out + 8, frame_crc(out, total));
return total;
}
} // namespace esphome::pioneer_wt
@@ -0,0 +1,102 @@
#pragma once
#include <array>
#include <cstddef>
#include <cstdint>
#include "esphome/core/helpers.h"
namespace esphome::pioneer_wt {
// Frame layout: A5 01 | flags | type | seq | ack | 00 | len | crc_hi crc_lo | class class | body
static constexpr size_t HEADER_SIZE = 10;
// The length byte counts the whole frame.
static constexpr size_t MAX_FRAME_SIZE = 255;
static constexpr uint8_t FLAG_NO_ACK = 0x00;
static constexpr uint8_t FLAG_WANT_ACK = 0x01;
static constexpr uint8_t TYPE_DATA = 0x21;
static constexpr uint8_t TYPE_REPLY = 0x23;
static constexpr uint8_t CLASS_COMMAND = 0x0A;
static constexpr uint8_t CLASS_NETWORK = 0x0B;
static constexpr uint8_t CLASS_STATUS = 0x0C;
// First class byte of a reply
static constexpr uint8_t CLASS_REPLY = 0x80;
// Attribute IDs
static constexpr uint16_t ATTR_POWER = 0x0001;
static constexpr uint16_t ATTR_SETPOINT_C100 = 0x0002;
static constexpr uint16_t ATTR_INDOOR_TEMP_C100 = 0x0003;
static constexpr uint16_t ATTR_FAN_SPEED = 0x0005;
static constexpr uint16_t ATTR_SWING_VERTICAL = 0x0011;
static constexpr uint16_t ATTR_MODE = 0x0012;
static constexpr uint16_t ATTR_ECO = 0x0013;
static constexpr uint16_t ATTR_DISPLAY = 0x001E;
static constexpr uint16_t ATTR_BEEPER = 0x0025;
static constexpr uint16_t ATTR_FAN_AUTO = 0x0073;
static constexpr uint16_t ATTR_FAN_EXTRA_1 = 0x0224;
static constexpr uint16_t ATTR_FAN_EXTRA_2 = 0x0225;
static constexpr uint16_t ATTR_SETPOINT_F = 0x0227;
static constexpr uint8_t SWING_ON = 0x01;
static constexpr uint8_t SWING_OFF = 0x08;
/// CRC-16/XMODEM over a whole frame, skipping the two checksum bytes at offset 8.
uint16_t frame_crc(const uint8_t *frame, size_t len);
/// Collects bytes from the serial line into complete frames with a valid checksum.
class PacketReader final {
public:
/// Feeds one byte. Returns the frame length once a complete, valid frame is in frame().
size_t feed(uint8_t byte);
const uint8_t *frame() const { return this->buf_.data(); }
/// True while part of a frame has been collected.
bool partial() const { return this->pos_ != 0; }
/// Drops a partly collected frame, so the next byte can start a new one.
void reset() { this->pos_ = 0; }
/// True once after a complete frame was dropped for a wrong checksum.
bool take_checksum_error() {
const bool error = this->checksum_error_;
this->checksum_error_ = false;
return error;
}
protected:
std::array<uint8_t, MAX_FRAME_SIZE> buf_{};
uint8_t pos_{0};
bool checksum_error_{false};
};
/// Walks the attribute list in a status body. Stops at the first ID whose size is unknown.
class AttributeReader final {
public:
AttributeReader(const uint8_t *data, size_t len) : data_(data), len_(len) {}
/// Moves to the next attribute. Returns false at the end of the body or at an unknown ID.
bool next();
uint16_t id() const { return this->id_; }
uint32_t value() const { return this->value_; }
/// True when the walk stopped early on an ID of unknown size.
bool stopped_on_unknown() const { return this->unknown_; }
protected:
const uint8_t *data_;
size_t len_;
size_t pos_{0};
uint32_t value_{0};
uint16_t id_{0};
bool unknown_{false};
};
/// Builds a frame into out, which must hold HEADER_SIZE + 2 + len bytes. Returns the frame length.
size_t build_frame(uint8_t *out, uint8_t flags, uint8_t type, uint8_t seq, uint8_t ack, uint8_t class_1,
uint8_t class_2, const uint8_t *body, size_t len);
/// Writes a one-byte attribute (2-byte ID, then the value) at p. Returns the new end.
inline uint8_t *put_attr(uint8_t *p, uint16_t id, uint8_t value) {
p = put_be16(p, id);
*p++ = value;
return p;
}
} // namespace esphome::pioneer_wt
+37
View File
@@ -0,0 +1,37 @@
import esphome.codegen as cg
from esphome.components import switch
import esphome.config_validation as cv
from esphome.const import CONF_BEEPER, CONF_DISPLAY, ENTITY_CATEGORY_CONFIG
from esphome.types import ConfigType
from . import CONF_PIONEER_WT_ID
from .climate import PioneerWT
ICON_LED_ON = "mdi:led-on"
ICON_VOLUME_HIGH = "mdi:volume-high"
def _switch_schema(icon: str) -> cv.Schema:
return switch.switch_schema(
switch.ApplySwitch,
icon=icon,
entity_category=ENTITY_CATEGORY_CONFIG,
default_restore_mode="DISABLED",
)
CONFIG_SCHEMA = cv.Schema(
{
cv.GenerateID(CONF_PIONEER_WT_ID): cv.use_id(PioneerWT),
cv.Optional(CONF_DISPLAY): _switch_schema(ICON_LED_ON),
cv.Optional(CONF_BEEPER): _switch_schema(ICON_VOLUME_HIGH),
}
)
async def to_code(config: ConfigType) -> None:
hub = await cg.get_variable(config[CONF_PIONEER_WT_ID])
switches = switch.sub_switches(config, parent=hub)
# No publish: the switch state follows what the AC reports back.
await switches(CONF_DISPLAY, hub.set_display_switch, apply="set_display_on(state)")
await switches(CONF_BEEPER, hub.set_beeper_switch, apply="set_beeper_on(state)")
+11 -13
View File
@@ -10,12 +10,10 @@ CODEOWNERS = ["@kahrendt"]
qwiic_pir_ns = cg.esphome_ns.namespace("qwiic_pir")
DebounceMode = qwiic_pir_ns.enum("DebounceMode")
DEBOUNCE_MODE_OPTIONS = {
"RAW": DebounceMode.RAW_DEBOUNCE_MODE,
"NATIVE": DebounceMode.NATIVE_DEBOUNCE_MODE,
"HYBRID": DebounceMode.HYBRID_DEBOUNCE_MODE,
}
DebounceMode = qwiic_pir_ns.enum("DebounceMode", is_class=True)
DEBOUNCE_MODE_OPTIONS = DebounceMode.options(
"RAW", "NATIVE", "HYBRID", prefix="DEBOUNCE_MODE_"
)
CONF_DEBOUNCE_MODE = "debounce_mode"
@@ -47,12 +45,12 @@ CONFIG_SCHEMA = cv.All(
async def to_code(config: ConfigType) -> None:
var = await binary_sensor.new_binary_sensor(config)
# Without a debounce time the device is set to 1 ms; NATIVE is the only mode that takes one
debounce = config.get(CONF_DEBOUNCE)
var = await binary_sensor.new_binary_sensor(
config,
config[CONF_DEBOUNCE_MODE],
1 if debounce is None else debounce.total_milliseconds,
)
await cg.register_component(var, config)
await i2c.register_i2c_device(var, config)
if debounce_time_setting := config.get(CONF_DEBOUNCE):
cg.add(var.set_debounce_time(debounce_time_setting.total_milliseconds))
else:
cg.add(var.set_debounce_time(1)) # default to 1 ms if not configured
cg.add(var.set_debounce_mode(config[CONF_DEBOUNCE_MODE]))
+51 -65
View File
@@ -1,99 +1,85 @@
#include "qwiic_pir.h"
#include "esphome/core/log.h"
#include "esphome/core/progmem.h"
namespace esphome::qwiic_pir {
ESPHOME_LOG_TAG(TAG, "qwiic_pir");
static constexpr uint8_t REG_CHIP_ID = 0x00;
static constexpr uint8_t REG_EVENT_STATUS = 0x03;
static constexpr uint8_t REG_DEBOUNCE_TIME = 0x05; // milliseconds, 16 bits little endian
static constexpr uint8_t DEVICE_ID = 0x72;
// REG_EVENT_STATUS bits
static constexpr uint8_t EVENT_RAW_READING = 0x01; // raw state of the PIR sensor
static constexpr uint8_t EVENT_AVAILABLE = 0x02; // a debounced object was detected or removed
static constexpr uint8_t EVENT_OBJECT_REMOVED = 0x04; // a debounced object is no longer detected
static constexpr uint8_t EVENT_OBJECT_DETECTED = 0x08; // a debounced object has been detected
// Indexed by DebounceMode
PROGMEM_STRING_TABLE(DebounceModeStrings, "RAW", "NATIVE", "HYBRID");
void QwiicPIRComponent::setup() {
if (!this->check_chip_id(this, QWIIC_PIR_CHIP_ID, QWIIC_PIR_DEVICE_ID))
if (!this->check_chip_id(this, REG_CHIP_ID, DEVICE_ID))
return;
if (!this->setup_check(this->write_byte_16(QWIIC_PIR_DEBOUNCE_TIME, this->debounce_time_),
if (!this->setup_check(this->write_byte_16_le(REG_DEBOUNCE_TIME, this->debounce_time_),
LOG_STR("Failed to configure debounce time")))
return;
if (this->debounce_mode_ == NATIVE_DEBOUNCE_MODE) {
// Publish the starting raw state of the PIR sensor
// If NATIVE mode, the binary_sensor state would be unknown until a motion event
if (!this->setup_check(this->read_byte(QWIIC_PIR_EVENT_STATUS, &this->event_register_.reg),
LOG_STR("Failed to read initial state")))
if (this->debounce_mode_ == DebounceMode::DEBOUNCE_MODE_NATIVE) {
// NATIVE only publishes on motion events, so start from the raw state
uint8_t event;
if (!this->setup_check(this->read_byte(REG_EVENT_STATUS, &event), LOG_STR("Failed to read initial state")))
return;
this->publish_state(this->event_register_.raw_reading);
this->publish_state((event & EVENT_RAW_READING) != 0);
}
}
void QwiicPIRComponent::loop() {
// Read Event Register
if (!this->read_byte(QWIIC_PIR_EVENT_STATUS, &this->event_register_.reg)) {
ESP_LOGW(TAG, ESP_LOG_MSG_COMM_FAIL);
uint8_t event;
if (!this->status_comm_check(this->read_byte(REG_EVENT_STATUS, &event)))
return;
switch (this->debounce_mode_) {
case DebounceMode::DEBOUNCE_MODE_HYBRID:
// The device debounces for 1 ms and ESPHome filters do the rest; any event means motion since the last loop
this->publish_state((event & (EVENT_RAW_READING | EVENT_AVAILABLE)) != 0);
break;
case DebounceMode::DEBOUNCE_MODE_NATIVE:
// The device's own debounce, as in SparkFun's Example2_PrintPIRStatus; it often misses objects being removed
if (event & EVENT_AVAILABLE) {
if (event & EVENT_OBJECT_DETECTED)
this->publish_state(true);
if (event & EVENT_OBJECT_REMOVED)
this->publish_state(false);
}
break;
case DebounceMode::DEBOUNCE_MODE_RAW:
// Can miss a very short detection when the loop is slow
this->publish_state((event & EVENT_RAW_READING) != 0);
break;
}
if (this->debounce_mode_ == HYBRID_DEBOUNCE_MODE) {
// Use a combination of the raw sensor reading and the device's event detection to determine state
// - The device is hardcoded to use a debounce time of 1 ms in this mode
// - Any event, even if it is object_removed, implies motion was active since the last loop, so publish true
// - Use ESPHome's built-in filters for debouncing
this->publish_state(this->event_register_.raw_reading || this->event_register_.event_available);
if (this->event_register_.event_available) {
this->clear_events_();
}
} else if (this->debounce_mode_ == NATIVE_DEBOUNCE_MODE) {
// Uses the device's firmware to debounce the signal
// - Follows the logic of SparkFun's example implementation:
// https://github.com/sparkfun/SparkFun_Qwiic_PIR_Arduino_Library/blob/master/examples/Example2_PrintPIRStatus/Example2_PrintPIRStatus.ino
// (accessed July 2023)
// - Is unreliable at detecting an object being removed, especially at debounce rates even slightly large
if (this->event_register_.event_available) {
// If an object is detected, publish true
if (this->event_register_.object_detected)
this->publish_state(true);
// If an object has been removed, publish false
if (this->event_register_.object_removed)
this->publish_state(false);
this->clear_events_();
}
} else if (this->debounce_mode_ == RAW_DEBOUNCE_MODE) {
// Publishes the raw PIR sensor reading with no further logic
// - May miss a very short motion detection if the ESP's loop time is slow
this->publish_state(this->event_register_.raw_reading);
}
// HYBRID and NATIVE clear a handled event; the last bus step of the poll decides the warning
bool ok = true;
if (this->debounce_mode_ != DebounceMode::DEBOUNCE_MODE_RAW && (event & EVENT_AVAILABLE))
ok = this->write_byte(REG_EVENT_STATUS, 0x00);
this->status_comm_result(ok);
}
void QwiicPIRComponent::dump_config() {
static const char *const RAW = "RAW";
static const char *const NATIVE = "NATIVE";
static const char *const HYBRID = "HYBRID";
const char *debounce_mode_str = RAW;
if (this->debounce_mode_ == NATIVE_DEBOUNCE_MODE) {
debounce_mode_str = NATIVE;
} else if (this->debounce_mode_ == HYBRID_DEBOUNCE_MODE) {
debounce_mode_str = HYBRID;
}
ESP_LOGCONFIG(TAG,
"Qwiic PIR:\n"
" Debounce Mode: %s",
debounce_mode_str);
if (this->debounce_mode_ == NATIVE_DEBOUNCE_MODE) {
LOG_STR_ARG(DebounceModeStrings::get_log_str(static_cast<uint8_t>(this->debounce_mode_), 0)));
if (this->debounce_mode_ == DebounceMode::DEBOUNCE_MODE_NATIVE) {
ESP_LOGCONFIG(TAG, " Debounce Time: %ums", this->debounce_time_);
}
LOG_I2C_DEVICE(this);
LOG_BINARY_SENSOR(" ", "Binary Sensor", this);
}
void QwiicPIRComponent::clear_events_() {
// Clear event status register
if (!this->write_byte(QWIIC_PIR_EVENT_STATUS, 0x00)) {
ESP_LOGW(TAG, "Failed to clear events");
}
}
} // namespace esphome::qwiic_pir
+11 -35
View File
@@ -2,8 +2,8 @@
* Adds support for Qwiic PIR motion sensors that communicate over an I2C bus.
* These sensors use Sharp PIR motion sensors to detect motion. A firmware running on an ATTiny84 translates the digital
* output to I2C communications.
* ATTiny84 firmware: https://github.com/sparkfun/Qwiic_PIR (accessed July 2023)
* SparkFun's Arduino library: https://github.com/sparkfun/SparkFun_Qwiic_PIR_Arduino_Library (accessed July 2023)
* ATTiny84 firmware: https://github.com/sparkfun/Qwiic_PIR
* SparkFun's Arduino library: https://github.com/sparkfun/SparkFun_Qwiic_PIR_Arduino_Library
*/
#pragma once
@@ -14,48 +14,24 @@
namespace esphome::qwiic_pir {
// Qwiic PIR I2C Register Addresses
enum {
QWIIC_PIR_CHIP_ID = 0x00,
QWIIC_PIR_EVENT_STATUS = 0x03,
QWIIC_PIR_DEBOUNCE_TIME = 0x05, // uint16_t debounce time in milliseconds
enum class DebounceMode : uint8_t {
DEBOUNCE_MODE_RAW,
DEBOUNCE_MODE_NATIVE,
DEBOUNCE_MODE_HYBRID,
};
enum DebounceMode {
RAW_DEBOUNCE_MODE,
NATIVE_DEBOUNCE_MODE,
HYBRID_DEBOUNCE_MODE,
};
static const uint8_t QWIIC_PIR_DEVICE_ID = 0x72;
class QwiicPIRComponent final : public Component, public i2c::I2CDevice, public binary_sensor::BinarySensor {
public:
QwiicPIRComponent(DebounceMode debounce_mode, uint16_t debounce_time)
: debounce_time_(debounce_time), debounce_mode_(debounce_mode) {}
void setup() override;
void loop() override;
void dump_config() override;
void set_debounce_time(uint16_t debounce_time) { this->debounce_time_ = debounce_time; }
void set_debounce_mode(DebounceMode mode) { this->debounce_mode_ = mode; }
protected:
uint16_t debounce_time_{};
DebounceMode debounce_mode_{};
union {
struct {
bool raw_reading : 1; // raw state of PIR sensor
bool event_available : 1; // a debounced object has been detected or removed
bool object_removed : 1; // a debounced object is no longer detected
bool object_detected : 1; // a debounced object has been detected
bool : 4;
};
uint8_t reg;
} event_register_ = {.reg = 0};
void clear_events_();
uint16_t debounce_time_;
DebounceMode debounce_mode_;
};
} // namespace esphome::qwiic_pir
-8
View File
@@ -2,10 +2,6 @@
#include "esphome/core/log.h"
#include "esphome/core/hal.h"
#ifdef USE_ESP8266
#include <Wire.h>
#endif
namespace esphome::scd30 {
ESPHOME_LOG_TAG(TAG, "scd30");
@@ -27,10 +23,6 @@ static const uint16_t SCD30_CMD_TEMPERATURE_OFFSET = 0x5403;
static const uint16_t SCD30_CMD_SOFT_RESET = 0xD304;
void SCD30Component::setup() {
#ifdef USE_ESP8266
Wire.setClockStretchLimit(150000);
#endif
/// Firmware version identification
uint16_t raw_firmware_version[3];
if (!this->setup_check(this->get_register(SCD30_CMD_GET_FIRMWARE_VERSION, raw_firmware_version, 3),
+96 -1
View File
@@ -3,7 +3,7 @@ from dataclasses import dataclass, field
from logging import getLogger
import math
import re
from typing import Any
from typing import TYPE_CHECKING, Any
from esphome import automation, pins
import esphome.codegen as cg
@@ -42,8 +42,12 @@ from esphome.const import (
CONF_FLOW_CONTROL_PIN,
CONF_ID,
CONF_LAMBDA,
CONF_MODE,
CONF_NUMBER,
CONF_OPEN_DRAIN,
CONF_PORT,
CONF_PULLDOWN,
CONF_PULLUP,
CONF_RX_BUFFER_SIZE,
CONF_RX_PIN,
CONF_SEQUENCE,
@@ -60,6 +64,9 @@ import esphome.final_validate as fv
from esphome.types import ConfigType
from esphome.yaml_util import make_data_base
if TYPE_CHECKING:
from esphome.components.libretiny import HardwareUart
_LOGGER = getLogger(__name__)
CODEOWNERS = ["@esphome/core"]
@@ -333,6 +340,89 @@ CONFIG_SCHEMA = cv.All(
)
def _libretiny_hardware_uart(config: ConfigType) -> "HardwareUart | None":
"""Hardware UART the board can route the configured pins to; None if none can or the board is unknown."""
from esphome.components.libretiny import get_hardware_uarts, has_software_serial
# Pin flags make setup() use SoftwareSerial where the family has it
if has_software_serial() and any(
pin[CONF_MODE].get(flag)
for pin in (config.get(CONF_TX_PIN), config.get(CONF_RX_PIN))
if pin is not None
for flag in (CONF_OPEN_DRAIN, CONF_PULLUP, CONF_PULLDOWN)
):
return None
tx = config[CONF_TX_PIN][CONF_NUMBER] if CONF_TX_PIN in config else None
rx = config[CONF_RX_PIN][CONF_NUMBER] if CONF_RX_PIN in config else None
return next(
(
uart
for uart in get_hardware_uarts()
if tx in (None, *uart.tx_pins) and rx in (None, *uart.rx_pins)
),
None,
)
def _final_validate(config: ConfigType) -> None:
if CORE.is_libretiny:
_validate_libretiny_pins(config)
def _validate_libretiny_pins(config: ConfigType) -> None:
from esphome.components.libretiny import (
can_choose_uart_pins,
get_hardware_uarts,
get_libretiny_board,
has_software_serial,
)
# A board without pin data is matched against its default pins at boot
if not (uarts := get_hardware_uarts()):
return
board = get_libretiny_board()
uart = _libretiny_hardware_uart(config)
if uart is None:
if has_software_serial():
return
choices = "; ".join(
f"UART{u.port}: TX={'/'.join(map(str, u.tx_pins)) or 'none'}, "
f"RX={'/'.join(map(str, u.rx_pins)) or 'none'}"
for u in uarts
)
raise cv.Invalid(
f"Board {board} has no hardware UART on these pins. Pin numbers per UART: {choices}"
)
# Two entries on one port would share the Serial object, and the second begin() would move its pins
for other in fv.full_config.get().get(DOMAIN, []):
if other is config or other[CONF_ID] == config[CONF_ID]:
continue
if (
other_uart := _libretiny_hardware_uart(other)
) and other_uart.port == uart.port:
raise cv.Invalid(
f"UART {other[CONF_ID]} already uses hardware UART{uart.port} of board {board}"
)
if not uart.pin_choices:
return
# A left-out direction with no default pin is opened on an invalid pin, which hangs at boot
for key, role, choices in (
(CONF_TX_PIN, "TX", uart.tx_pin_choices),
(CONF_RX_PIN, "RX", uart.rx_pin_choices),
):
if choices and key not in config:
raise cv.Invalid(
f"UART{uart.port} of board {board} has no default {role} pin, so it needs {key}"
)
if not can_choose_uart_pins():
raise cv.Invalid(
f"Choosing the pins of UART{uart.port} on board {board} needs LibreTiny 1.12.0 or later"
)
FINAL_VALIDATE_SCHEMA = _final_validate
async def debug_to_code(config, parent):
trigger = cg.new_Pvariable(config[CONF_TRIGGER_ID], parent)
await cg.register_component(trigger, config)
@@ -426,6 +516,11 @@ async def to_code(config):
enable_serial1()
cg.add_define("USE_ESP8266_UART_SERIAL1")
if CORE.is_libretiny and (uart := _libretiny_hardware_uart(config)) is not None:
cg.add(var.set_hardware_port(uart.port))
if uart.pin_choices:
cg.add_define("USE_UART_LIBRETINY_PIN_ROUTING")
CORE.add_job(final_step)
@@ -25,6 +25,42 @@ static const char *const UART_TYPE[] = {
"software",
};
// Port whose default pins match, for a board codegen has no pin data for; PIN_INVALID means not configured.
static int8_t default_port(pin_size_t tx, pin_size_t rx) {
#if LT_HW_UART0
if ((tx == PIN_INVALID || tx == PIN_SERIAL0_TX) && (rx == PIN_INVALID || rx == PIN_SERIAL0_RX))
return 0;
#endif
#if LT_HW_UART1
if ((tx == PIN_INVALID || tx == PIN_SERIAL1_TX) && (rx == PIN_INVALID || rx == PIN_SERIAL1_RX))
return 1;
#endif
#if LT_HW_UART2
if ((tx == PIN_INVALID || tx == PIN_SERIAL2_TX) && (rx == PIN_INVALID || rx == PIN_SERIAL2_RX))
return 2;
#endif
return -1;
}
static SerialClass *hardware_serial(int8_t port) {
switch (port) {
#if LT_HW_UART0
case 0:
return &Serial0;
#endif
#if LT_HW_UART1
case 1:
return &Serial1;
#endif
#if LT_HW_UART2
case 2:
return &Serial2;
#endif
default:
return nullptr;
}
}
uint16_t LibreTinyUARTComponent::get_config() {
uint16_t config = 0;
@@ -49,8 +85,8 @@ uint16_t LibreTinyUARTComponent::get_config() {
}
void LibreTinyUARTComponent::setup() {
int16_t tx_pin = tx_pin_ == nullptr ? -1 : tx_pin_->get_pin();
int16_t rx_pin = rx_pin_ == nullptr ? -1 : rx_pin_->get_pin();
const pin_size_t tx_pin = this->tx_pin_ == nullptr ? PIN_INVALID : this->tx_pin_->get_pin();
const pin_size_t rx_pin = this->rx_pin_ == nullptr ? PIN_INVALID : this->rx_pin_->get_pin();
auto should_fallback_to_software_serial = [&]() -> bool {
auto has_flags = [](InternalGPIOPin *pin, const gpio::Flags mask) -> bool {
@@ -70,61 +106,49 @@ void LibreTinyUARTComponent::setup() {
return false;
};
if (false) { // NOLINT(readability-simplify-boolean-expr)
return;
}
#if LT_HW_UART0
else if ((tx_pin == -1 || tx_pin == PIN_SERIAL0_TX) && (rx_pin == -1 || rx_pin == PIN_SERIAL0_RX) &&
!should_fallback_to_software_serial()) {
this->serial_ = &Serial0;
this->hardware_idx_ = 0;
}
#endif
#if LT_HW_UART1
else if ((tx_pin == -1 || tx_pin == PIN_SERIAL1_TX) && (rx_pin == -1 || rx_pin == PIN_SERIAL1_RX) &&
!should_fallback_to_software_serial()) {
this->serial_ = &Serial1;
this->hardware_idx_ = 1;
}
#endif
#if LT_HW_UART2
else if ((tx_pin == -1 || tx_pin == PIN_SERIAL2_TX) && (rx_pin == -1 || rx_pin == PIN_SERIAL2_RX) &&
!should_fallback_to_software_serial()) {
this->serial_ = &Serial2;
this->hardware_idx_ = 2;
}
#endif
else {
#if LT_ARD_HAS_SOFTSERIAL
if (this->rx_pin_) {
this->rx_pin_->setup();
}
if (this->tx_pin_ && this->rx_pin_ != this->tx_pin_) {
this->tx_pin_->setup();
}
bool tx_inverted = tx_pin_ != nullptr && tx_pin_->is_inverted();
bool rx_inverted = rx_pin_ != nullptr && rx_pin_->is_inverted();
this->serial_ = new SoftwareSerial(rx_pin, tx_pin, rx_inverted || tx_inverted);
#else
this->serial_ = &Serial;
ESP_LOGE(TAG, " SoftwareSerial is not implemented for this chip. Only hardware pins are supported:");
#if LT_HW_UART0
ESP_LOGE(TAG, " TX=%u, RX=%u", PIN_SERIAL0_TX, PIN_SERIAL0_RX);
#endif
#if LT_HW_UART1
ESP_LOGE(TAG, " TX=%u, RX=%u", PIN_SERIAL1_TX, PIN_SERIAL1_RX);
#endif
#if LT_HW_UART2
ESP_LOGE(TAG, " TX=%u, RX=%u", PIN_SERIAL2_TX, PIN_SERIAL2_RX);
#endif
this->mark_failed(LOG_STR("SoftwareSerial is not implemented for this chip."));
return;
#endif
}
if (this->hardware_idx_ >= 0)
// Codegen picks the port from the board's pin lists; a board it has no pin data for matches the defaults here.
if (this->hardware_idx_ < 0)
this->hardware_idx_ = default_port(tx_pin, rx_pin);
SerialClass *hardware = should_fallback_to_software_serial() ? nullptr : hardware_serial(this->hardware_idx_);
if (hardware != nullptr) {
this->serial_ = hardware;
libretiny::ensure_serial_handle(this->hardware_idx_);
this->serial_->begin(this->baud_rate_, get_config());
#ifdef USE_UART_LIBRETINY_PIN_ROUTING
// Routes a port with pin choices to the configured pins (LibreTiny 1.12+, checked in codegen). setPins()
// replaces a left-out pin (PIN_INVALID) with the port's default, so default-pin ports start as before.
hardware->begin(this->baud_rate_, this->get_config(), rx_pin, tx_pin);
#else
hardware->begin(this->baud_rate_, this->get_config());
#endif
return;
}
this->hardware_idx_ = -1;
#if LT_ARD_HAS_SOFTSERIAL
if (this->rx_pin_) {
this->rx_pin_->setup();
}
if (this->tx_pin_ && this->rx_pin_ != this->tx_pin_) {
this->tx_pin_->setup();
}
bool tx_inverted = tx_pin_ != nullptr && tx_pin_->is_inverted();
bool rx_inverted = rx_pin_ != nullptr && rx_pin_->is_inverted();
this->serial_ = new SoftwareSerial(rx_pin, tx_pin, rx_inverted || tx_inverted);
this->serial_->begin(this->baud_rate_, this->get_config());
#else
this->serial_ = &Serial;
ESP_LOGE(TAG, " SoftwareSerial is not implemented for this chip. Only hardware pins are supported:");
#if LT_HW_UART0
ESP_LOGE(TAG, " TX=%u, RX=%u", PIN_SERIAL0_TX, PIN_SERIAL0_RX);
#endif
#if LT_HW_UART1
ESP_LOGE(TAG, " TX=%u, RX=%u", PIN_SERIAL1_TX, PIN_SERIAL1_RX);
#endif
#if LT_HW_UART2
ESP_LOGE(TAG, " TX=%u, RX=%u", PIN_SERIAL2_TX, PIN_SERIAL2_RX);
#endif
this->mark_failed(LOG_STR("SoftwareSerial is not implemented for this chip."));
#endif
}
void LibreTinyUARTComponent::dump_config() {
@@ -25,6 +25,8 @@ class LibreTinyUARTComponent final : public UARTComponent, public Component {
UARTFlushResult flush() override;
uint16_t get_config();
/// Hardware port codegen picked from the board's pin lists.
void set_hardware_port(int8_t port) { this->hardware_idx_ = port; }
HardwareSerial *get_hw_serial() { return this->serial_; }
int8_t get_hw_serial_number() { return this->hardware_idx_; }
+6
View File
@@ -20,6 +20,7 @@ from esphome.const import (
CONF_WEB_SERVER,
CONF_WIFI,
KEY_CORE,
KEY_FRAMEWORK_VERSION,
KEY_TARGET_FRAMEWORK,
KEY_TARGET_PLATFORM,
NATIVE_TOOLCHAINS,
@@ -1035,6 +1036,11 @@ class EsphomeCore:
def target_framework(self):
return self.data[KEY_CORE][KEY_TARGET_FRAMEWORK]
@property
def framework_version(self) -> Version:
"""The version of the target platform's framework, set by the platform component."""
return self.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
@property
def using_arduino(self):
return self.target_framework == "arduino"
+1
View File
@@ -884,6 +884,7 @@
#define USE_BK72XX_BLE_TRACKER
#endif
#define USE_LIBRETINY_RTC_PREFERENCES
#define USE_UART_LIBRETINY_PIN_ROUTING
#define LT_GPIO_RECOVER 1
#define ESPHOME_BLE_DEVICE_BASE_LISTENER_COUNT 1
#define ESPHOME_SUSPEND_LOOP
@@ -0,0 +1,15 @@
esphome:
name: libretiny-pin-choices
rtl87xx:
board: bw15
uart:
- id: routed_uart
tx_pin: PA03
rx_pin: PA02
baud_rate: 9600
- id: default_uart
tx_pin: PA14
rx_pin: PA13
baud_rate: 9600
@@ -0,0 +1,139 @@
"""Tests for picking a LibreTiny hardware UART from the board's pin lists."""
from collections.abc import Callable
from pathlib import Path
import pytest
from esphome import config, yaml_util
from esphome.core import CORE
CONFIG = """
esphome:
name: libretiny-uart-pins
rtl87xx:
board: {board}
{framework}
uart:
{uart}
"""
def _write_config(path: Path, board: str, framework: str, pins: str) -> None:
"""One UART with these pins, or the pins text as is when it already lists entries."""
uart = pins if pins.startswith(" - ") else f" baud_rate: 9600\n{pins}"
path.write_text(
CONFIG.format(board=board, framework=framework, uart=uart), encoding="utf-8"
)
def test_port_with_pin_choices_is_routed(
generate_main: Callable[[str | Path], str],
component_config_path: Callable[[str], Path],
) -> None:
"""The port is picked in codegen, and only a port with pin choices gets its pins passed."""
main_cpp = generate_main(component_config_path("libretiny_pin_choices.yaml"))
assert "routed_uart->set_hardware_port(1);" in main_cpp
assert "default_uart->set_hardware_port(0);" in main_cpp
assert any(
define.name == "USE_UART_LIBRETINY_PIN_ROUTING" for define in CORE.defines
)
@pytest.mark.parametrize(
("board", "framework", "pins", "error"),
[
pytest.param(
"bw15", "", " tx_pin: PA03\n rx_pin: PA02", None, id="second_pair"
),
pytest.param(
"bw15", "", " tx_pin: PA01\n rx_pin: PA02", None, id="mixed_pair"
),
pytest.param("bw15", "", " tx_pin: PA14", None, id="default_pins_tx_only"),
pytest.param(
"bw15",
"",
" tx_pin: PA03",
"UART1 of board bw15 has no default RX pin, so it needs rx_pin",
id="pin_choices_tx_only",
),
pytest.param(
"bw15",
"",
" tx_pin: PA17\n rx_pin: PA18",
"UART1: TX=1/3, RX=0/2",
id="no_uart_on_pins",
),
pytest.param(
"bw15",
" framework:\n version: 1.11.0",
" tx_pin: PA03\n rx_pin: PA02",
"needs LibreTiny 1.12.0 or later",
id="old_libretiny",
),
pytest.param(
"bw15",
"",
" - id: uart_a\n baud_rate: 9600\n tx_pin: PA01\n rx_pin: PA00\n"
" - id: uart_b\n baud_rate: 9600\n tx_pin: PA03\n rx_pin: PA02",
"already uses hardware UART1 of board bw15",
id="two_entries_one_port",
),
# Pin flags force SoftwareSerial on RTL8710B, so these do not share hardware UART0
pytest.param(
"generic-rtl8710bn-2mb-788k",
"",
" - id: uart_a\n baud_rate: 9600\n tx_pin:\n number: PA23\n"
" mode:\n output: true\n open_drain: true\n"
" - id: uart_b\n baud_rate: 9600\n rx_pin:\n number: PA18\n"
" mode:\n input: true\n pullup: true",
None,
id="software_serial_flags",
),
# UART1 TX has a default pin on this board; only RX has choices
pytest.param("wbru", "", " rx_pin: PA02", None, id="default_tx_rx_only"),
pytest.param(
"wbru",
"",
" tx_pin: PA03",
"UART1 of board wbru has no default RX pin, so it needs rx_pin",
id="default_tx_tx_only",
),
# RTL8710B falls back to SoftwareSerial
pytest.param(
"generic-rtl8710bn-2mb-788k",
"",
" tx_pin: PA05\n rx_pin: PA12",
None,
id="software_serial",
),
],
)
def test_pins_are_checked_against_the_board(
board: str, framework: str, pins: str, error: str | None, tmp_path: Path
) -> None:
path = tmp_path / "uart.yaml"
_write_config(path, board, framework, pins)
CORE.config_path = path
result = config.validate_config(yaml_util.load_yaml(path), {})
errors = [str(err) for err in result.errors]
if error is None:
assert errors == []
else:
assert any(error in err for err in errors), errors
def test_hardware_uarts_of_a_board_with_pin_choices(tmp_path: Path) -> None:
"""The libretiny component reports each UART's pins and whether they are choices."""
from esphome.components.libretiny import HardwareUart, get_hardware_uarts
path = tmp_path / "uart.yaml"
_write_config(path, "bw15", "", " tx_pin: PA14")
CORE.config_path = path
config.validate_config(yaml_util.load_yaml(path), {})
assert get_hardware_uarts() == [
HardwareUart(0, (14,), (13,), False, False),
HardwareUart(1, (1, 3), (0, 2), True, True),
HardwareUart(2, (16,), (15,), False, False),
]
+6
View File
@@ -0,0 +1,6 @@
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"]
+4 -15
View File
@@ -36,7 +36,6 @@ sensor:
name: "BMI270 Accel Z"
accuracy_decimals: 4
# Gyroscope axes (unit: °/s)
- platform: motion
motion_id: bmi270_motion
type: gyroscope_x
@@ -76,21 +75,11 @@ motion:
- platform: bmi270
id: bmi270_motion
i2c_id: i2c_bus
# 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
accelerometer_range: 8G
accelerometer_odr: 200HZ
gyroscope_range: 1000DPS
gyroscope_odr: 400HZ
aux_device: BMM150
aux_address: 0x10
axis_map:
x: y
y: x
+48
View File
@@ -0,0 +1,48 @@
#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
@@ -0,0 +1,69 @@
#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
+11
View File
@@ -0,0 +1,11 @@
import esphome.config_validation as cv
from esphome.const import CONF_USE_ADDRESS
from tests.testing_helpers import ComponentManifestOverride
def override_manifest(manifest: ComponentManifestOverride) -> None:
# Only the reply parsers are tested; the build still needs the address a modem config provides.
manifest.dependencies = []
manifest.config_schema = cv.Schema(
{cv.Optional(CONF_USE_ADDRESS, default="test.local"): cv.string_strict}
)
+211
View File
@@ -0,0 +1,211 @@
#include <gtest/gtest.h>
#include <cstring>
#include <string>
#include "esphome/components/modem/at_reply.h"
namespace esphome::modem::testing {
// Runs a raw reply through flatten_reply() as at_reply_() does
static std::string flat(const char *raw) {
char buf[256];
const size_t len = strlen(raw);
memcpy(buf, raw, len + 1);
return std::string(buf, flatten_reply(buf, len));
}
static ReplyEnd end_of(const char *reply, bool skip_first = false) {
return reply_end(reply, strlen(reply), skip_first);
}
TEST(ModemReplyEnd, OnlyCompleteFinalLinesCount) {
EXPECT_EQ(end_of("\r\n+CSQ: 20,99\r\n\r\nOK\r\n"), ReplyEnd::REPLY_END_OK);
EXPECT_EQ(end_of("\r\nERROR\r\n"), ReplyEnd::REPLY_END_ERROR);
EXPECT_EQ(end_of("\r\n+CME ERROR: SIM not inserted\r\n"), ReplyEnd::REPLY_END_ERROR);
EXPECT_EQ(end_of("\r\n+CMS ERROR: 500\r\n"), ReplyEnd::REPLY_END_ERROR);
// ERROR inside a payload line is not a result
EXPECT_EQ(end_of("\r\n+CEER: PROTOCOL_ERROR\r\n"), ReplyEnd::REPLY_END_NONE);
EXPECT_EQ(end_of("\r\n+CEER: PROTOCOL_ERROR\r\n\r\nOK\r\n"), ReplyEnd::REPLY_END_OK);
// A line that has not ended yet
EXPECT_EQ(end_of("\r\nOK"), ReplyEnd::REPLY_END_NONE);
EXPECT_EQ(end_of("\r\n+CME ERROR: 10"), ReplyEnd::REPLY_END_NONE);
}
TEST(ModemReplyEnd, ErrorWithoutItsReason) {
// esp_modem drops the CMUX frame ": SIM not inserted" because it holds no line end
char buf[64];
size_t len = 0;
collect_reply(buf, sizeof(buf), len, "\r\n+CME ERROR", 12, false);
EXPECT_EQ(reply_end(buf, len, false), ReplyEnd::REPLY_END_NONE);
collect_reply(buf, sizeof(buf), len, "\r\n", 2, false);
EXPECT_EQ(reply_end(buf, len, false), ReplyEnd::REPLY_END_ERROR);
EXPECT_EQ(end_of("\r\n+CMS ERROR\r\n"), ReplyEnd::REPLY_END_ERROR);
}
TEST(ModemReplyEnd, CutFirstLineIsSkipped) {
// The tail of "...OK" from a longer line must not count as a result
EXPECT_EQ(end_of("OK\r\nmore text\r\n", true), ReplyEnd::REPLY_END_NONE);
EXPECT_EQ(end_of("OK\r\nmore text\r\n", false), ReplyEnd::REPLY_END_OK);
EXPECT_EQ(end_of("tail\r\nOK\r\n", true), ReplyEnd::REPLY_END_OK);
}
TEST(ModemCollectReply, UartReplyComesBackWhole) {
char buf[9];
size_t len = 0;
EXPECT_FALSE(collect_reply(buf, sizeof(buf), len, "abc", 3, true));
EXPECT_STREQ(buf, "abc");
EXPECT_FALSE(collect_reply(buf, sizeof(buf), len, "abcdef", 6, true));
EXPECT_STREQ(buf, "abcdef");
// Data longer than the buffer keeps its tail
EXPECT_TRUE(collect_reply(buf, sizeof(buf), len, "0123456789", 10, true));
EXPECT_STREQ(buf, "23456789");
}
TEST(ModemCollectReply, GatheredCmuxFramesAreNotRepeated) {
// With esp_modem's inflatable buffer, each CMUX frame comes with the ones before it
char buf[64];
size_t len = 0;
const char *first = "\r\n+CSQ: 20,99\r\n";
const char *both = "\r\n+CSQ: 20,99\r\n\r\nOK\r\n";
collect_reply(buf, sizeof(buf), len, first, strlen(first), true);
collect_reply(buf, sizeof(buf), len, both, strlen(both), true);
EXPECT_STREQ(buf, both);
EXPECT_EQ(reply_end(buf, len, false), ReplyEnd::REPLY_END_OK);
}
TEST(ModemCollectReply, ExactlyFullIsNotCut) {
char buf[9];
size_t len = 0;
EXPECT_FALSE(collect_reply(buf, sizeof(buf), len, "OK\r\nabcd", 8, true));
EXPECT_STREQ(buf, "OK\r\nabcd");
len = 0;
EXPECT_FALSE(collect_reply(buf, sizeof(buf), len, "OK\r\nabcd", 8, false));
EXPECT_EQ(reply_end(buf, len, false), ReplyEnd::REPLY_END_OK);
// Filling up by appending is not a cut either, one more byte is
len = 0;
EXPECT_FALSE(collect_reply(buf, sizeof(buf), len, "OK\r\n", 4, false));
EXPECT_FALSE(collect_reply(buf, sizeof(buf), len, "abcd", 4, false));
EXPECT_TRUE(collect_reply(buf, sizeof(buf), len, "e", 1, false));
EXPECT_STREQ(buf, "K\r\nabcde");
}
TEST(ModemCollectReply, CmuxFramesAreAppended) {
char buf[9];
size_t len = 0;
EXPECT_FALSE(collect_reply(buf, sizeof(buf), len, "abc", 3, false));
// A frame that starts like the text so far is still new data
EXPECT_FALSE(collect_reply(buf, sizeof(buf), len, "abcd", 4, false));
EXPECT_STREQ(buf, "abcabcd");
// The oldest bytes go once the buffer is full
EXPECT_TRUE(collect_reply(buf, sizeof(buf), len, "XY", 2, false));
EXPECT_STREQ(buf, "bcabcdXY");
EXPECT_EQ(len, 8u);
EXPECT_TRUE(collect_reply(buf, sizeof(buf), len, "0123456789", 10, false));
EXPECT_STREQ(buf, "23456789");
}
TEST(ModemFlattenReply, OneLineWithoutFinalOk) {
EXPECT_EQ(flat("\r\n+CSQ: 20,99\r\n\r\nOK\r\n"), "+CSQ: 20,99");
EXPECT_EQ(flat("\r\nOK\r\n"), "");
EXPECT_EQ(flat("\r\n+CME ERROR: SIM not inserted\r\n"), "+CME ERROR: SIM not inserted");
EXPECT_EQ(flat("\r\n+COPS: 0,0,\"NOK\"\r\n"), "+COPS: 0,0,\"NOK\"");
// A line ending in OK is not the final result
EXPECT_EQ(flat("\r\n+CSPN: NOK\r\n"), "+CSPN: NOK");
EXPECT_EQ(flat(""), "");
}
TEST(ModemRegistration, QueryAnswerNotNotification) {
// A one-field URC before the query answer is skipped
EXPECT_EQ(registration_from_reply("+CEREG: 2 +CEREG: 0,1", "+CEREG:"), 1);
EXPECT_EQ(registration_from_reply("+CEREG: 2,5,\"1A2B\",\"01A2B3C4\",7", "+CEREG:"), 5);
EXPECT_EQ(registration_from_reply("+CREG: 0,3", "+CREG:"), 3);
EXPECT_EQ(registration_from_reply("+CEREG: 1", "+CEREG:"), REGISTRATION_UNKNOWN);
EXPECT_EQ(registration_from_reply("+CREG: 0,1", "+CEREG:"), REGISTRATION_UNKNOWN);
EXPECT_EQ(registration_from_reply("", "+CEREG:"), REGISTRATION_UNKNOWN);
}
TEST(ModemRegistration, OtherRegisteredStates) {
EXPECT_TRUE(is_registered(REGISTRATION_HOME));
EXPECT_TRUE(is_registered(REGISTRATION_ROAMING));
EXPECT_TRUE(is_registered(REGISTRATION_SMS_ONLY_HOME));
EXPECT_TRUE(is_registered(REGISTRATION_SMS_ONLY_ROAMING));
EXPECT_TRUE(is_registered(REGISTRATION_CSFB_NOT_PREFERRED_HOME));
EXPECT_TRUE(is_registered(REGISTRATION_CSFB_NOT_PREFERRED_ROAMING));
EXPECT_FALSE(is_registered(REGISTRATION_NOT_SEARCHING));
EXPECT_FALSE(is_registered(REGISTRATION_SEARCHING));
EXPECT_FALSE(is_registered(REGISTRATION_DENIED));
EXPECT_FALSE(is_registered(REGISTRATION_REPORTED_UNKNOWN));
EXPECT_FALSE(is_registered(REGISTRATION_EMERGENCY_ONLY));
EXPECT_FALSE(is_registered(11));
EXPECT_FALSE(is_registered(REGISTRATION_UNKNOWN));
}
TEST(ModemMergeRegistration, RegisteredOnEitherSideWins) {
EXPECT_EQ(merge_registration(REGISTRATION_HOME, REGISTRATION_DENIED), REGISTRATION_HOME);
EXPECT_EQ(merge_registration(REGISTRATION_DENIED, REGISTRATION_ROAMING), REGISTRATION_ROAMING);
EXPECT_EQ(merge_registration(REGISTRATION_NO_ANSWER, REGISTRATION_HOME), REGISTRATION_HOME);
EXPECT_EQ(merge_registration(REGISTRATION_UNSUPPORTED, REGISTRATION_ROAMING), REGISTRATION_ROAMING);
EXPECT_EQ(merge_registration(REGISTRATION_UNSUPPORTED, REGISTRATION_CSFB_NOT_PREFERRED_ROAMING),
REGISTRATION_CSFB_NOT_PREFERRED_ROAMING);
EXPECT_EQ(merge_registration(REGISTRATION_SEARCHING, REGISTRATION_CSFB_NOT_PREFERRED_HOME),
REGISTRATION_CSFB_NOT_PREFERRED_HOME);
EXPECT_EQ(merge_registration(REGISTRATION_SMS_ONLY_HOME, REGISTRATION_DENIED), REGISTRATION_SMS_ONLY_HOME);
// Emergency only is no registration, so a searching query still decides
EXPECT_EQ(merge_registration(REGISTRATION_EMERGENCY_ONLY, REGISTRATION_SEARCHING), REGISTRATION_SEARCHING);
}
TEST(ModemMergeRegistration, SearchingBeatsDenied) {
EXPECT_EQ(merge_registration(REGISTRATION_SEARCHING, REGISTRATION_DENIED), REGISTRATION_SEARCHING);
EXPECT_EQ(merge_registration(REGISTRATION_DENIED, REGISTRATION_SEARCHING), REGISTRATION_SEARCHING);
}
TEST(ModemMergeRegistration, DefiniteAnswerBeatsTimeout) {
EXPECT_EQ(merge_registration(REGISTRATION_DENIED, REGISTRATION_NO_ANSWER), REGISTRATION_DENIED);
EXPECT_EQ(merge_registration(REGISTRATION_NO_ANSWER, REGISTRATION_SEARCHING), REGISTRATION_SEARCHING);
EXPECT_EQ(merge_registration(REGISTRATION_NO_ANSWER, REGISTRATION_NO_ANSWER), REGISTRATION_NO_ANSWER);
// Any reported <stat> outweighs a timeout, so the fallbacks still count it
EXPECT_EQ(merge_registration(REGISTRATION_NOT_SEARCHING, REGISTRATION_NO_ANSWER), REGISTRATION_NOT_SEARCHING);
EXPECT_EQ(merge_registration(REGISTRATION_NO_ANSWER, REGISTRATION_NOT_SEARCHING), REGISTRATION_NOT_SEARCHING);
EXPECT_EQ(merge_registration(REGISTRATION_REPORTED_UNKNOWN, REGISTRATION_NO_ANSWER), REGISTRATION_REPORTED_UNKNOWN);
EXPECT_EQ(merge_registration(REGISTRATION_NO_ANSWER, REGISTRATION_REPORTED_UNKNOWN), REGISTRATION_REPORTED_UNKNOWN);
// Only a timeout and no <stat> at all leave the state open
EXPECT_EQ(merge_registration(REGISTRATION_UNSUPPORTED, REGISTRATION_NO_ANSWER), REGISTRATION_NO_ANSWER);
EXPECT_EQ(merge_registration(REGISTRATION_NO_ANSWER, REGISTRATION_UNKNOWN), REGISTRATION_NO_ANSWER);
}
TEST(ModemMergeRegistration, UnsupportedOnlyWhenBothAre) {
EXPECT_EQ(merge_registration(REGISTRATION_UNSUPPORTED, REGISTRATION_UNSUPPORTED), REGISTRATION_UNSUPPORTED);
EXPECT_EQ(merge_registration(REGISTRATION_UNSUPPORTED, REGISTRATION_NOT_SEARCHING), REGISTRATION_NOT_SEARCHING);
EXPECT_EQ(merge_registration(REGISTRATION_UNKNOWN, REGISTRATION_UNSUPPORTED), REGISTRATION_UNKNOWN);
}
TEST(ModemMergeRegistration, UnknownFallback) {
// The LTE value goes first, then the 2G and 3G one, then unknown
EXPECT_EQ(merge_registration(REGISTRATION_NOT_SEARCHING, REGISTRATION_REPORTED_UNKNOWN), REGISTRATION_NOT_SEARCHING);
EXPECT_EQ(merge_registration(REGISTRATION_UNKNOWN, REGISTRATION_REPORTED_UNKNOWN), REGISTRATION_REPORTED_UNKNOWN);
EXPECT_EQ(merge_registration(REGISTRATION_UNKNOWN, REGISTRATION_UNKNOWN), REGISTRATION_UNKNOWN);
}
TEST(ModemUnsupported, OnlyWhenTheErrorSaysSo) {
EXPECT_TRUE(reply_names_unsupported("+CME ERROR: operation not supported"));
EXPECT_TRUE(reply_names_unsupported("+CME ERROR: Operation Not Supported"));
EXPECT_TRUE(reply_names_unsupported("+CME ERROR: 4"));
EXPECT_FALSE(reply_names_unsupported("+CME ERROR: 40"));
EXPECT_FALSE(reply_names_unsupported("+CME ERROR: SIM busy"));
EXPECT_FALSE(reply_names_unsupported("ERROR"));
EXPECT_FALSE(reply_names_unsupported(""));
}
TEST(ModemSimStatus, CutBeforeTheNextLine) {
char ready[] = "+CPIN: READY";
EXPECT_STREQ(sim_status(ready), "READY");
char with_urc[] = "+CPIN: SIM PIN +CGEV: ME PDN DEACT 1";
EXPECT_STREQ(sim_status(with_urc), "SIM PIN");
char echoed[] = "AT+CPIN?";
EXPECT_EQ(sim_status(echoed), nullptr);
char empty[] = "+CPIN:";
EXPECT_STREQ(sim_status(empty), "");
}
} // namespace esphome::modem::testing
@@ -0,0 +1,504 @@
#include <gtest/gtest.h>
#include "esphome/components/pioneer_wt/pioneer_wt.h"
#include "esphome/components/pioneer_wt/pioneer_wt_protocol.h"
#include "esphome/core/application.h"
#include "../common.h"
namespace esphome::pioneer_wt::testing {
namespace {
using Frame = std::vector<uint8_t>;
// Frames captured between a Pioneer WT indoor unit and its stock WiFi module.
// Full status the AC sent at boot: on, heat, 77 F, indoor 21.7 C, fan auto, swing stopped, eco off.
const char *const STATUS_DUMP = "a5010121a50000428a930c0c0001010002000009c400030000087a000500000c00000d00000e0800110800"
"120400df0000c902001700001e0102270000004d014801";
// The AC's once-a-minute "are you there?" check.
const char *const PRESENCE_CHECK = "a50100210000000cd37d0c0c";
const char *const PRESENCE_REPLY = "a5010023000000124709800c0264ffffffd0";
// payload starts with the two class bytes.
Frame build(uint8_t flags, uint8_t type, uint8_t seq, uint8_t ack, const Frame &payload) {
uint8_t frame[MAX_FRAME_SIZE];
const size_t len =
build_frame(frame, flags, type, seq, ack, payload[0], payload[1], payload.data() + 2, payload.size() - 2);
return Frame(frame, frame + len);
}
Frame status_request(uint8_t seq) {
return build(FLAG_WANT_ACK, TYPE_DATA, seq, 0, {CLASS_NETWORK, CLASS_NETWORK, 0xff, 0xff});
}
Frame command(uint8_t seq, const Frame &attrs) {
Frame payload{CLASS_COMMAND, CLASS_COMMAND};
payload.insert(payload.end(), attrs.begin(), attrs.end());
return build(FLAG_WANT_ACK, TYPE_DATA, seq, 0, payload);
}
size_t feed_all(PacketReader &reader, const Frame &bytes) {
size_t last = 0;
for (uint8_t b : bytes) {
if (size_t len = reader.feed(b))
last = len;
}
return last;
}
} // namespace
// Frames built here must match what the stock module sent, byte for byte.
TEST(PioneerWTProtocol, BuildsCapturedCommands) {
EXPECT_EQ(command(0x09, {0x00, 0x01, 0x00}), from_hex("a50101210900000f4f990a0a000100"));
EXPECT_EQ(command(0x0b, {0x00, 0x12, 0x03}), from_hex("a50101210b00000fefbd0a0a001203"));
EXPECT_EQ(command(0x29, {0x00, 0x1e, 0x00}), from_hex("a50101212900000ffb280a0a001e00"));
EXPECT_EQ(command(0x2b, {0x00, 0x25, 0x00}), from_hex("a50101212b00000fe4200a0a002500"));
EXPECT_EQ(command(0x10, {0x02, 0x27, 0x00, 0x00, 0x00, 0x3f}), from_hex("a50101211000001238620a0a02270000003f"));
EXPECT_EQ(status_request(0x01), from_hex("a50101210100000e4ae90b0bffff"));
}
TEST(PioneerWTProtocol, BuildsCapturedReplies) {
EXPECT_EQ(build(FLAG_WANT_ACK, TYPE_REPLY, 0, 0xb7, {0x80, CLASS_STATUS}), from_hex("a501012300b7000ce352800c"));
EXPECT_EQ(build(FLAG_NO_ACK, TYPE_REPLY, 0, 0, {0x80, CLASS_STATUS, 0x02, 0x64, 0xff, 0xff, 0xff, 0xd8}),
from_hex("a501002300000012c601800c0264ffffffd8"));
}
TEST(PioneerWTProtocol, ReaderAcceptsCapturedFrame) {
PacketReader reader;
const Frame frame = from_hex(STATUS_DUMP);
EXPECT_EQ(feed_all(reader, frame), frame.size());
}
TEST(PioneerWTProtocol, ReaderSkipsNoiseAndStrayHeaderBytes) {
PacketReader reader;
Frame bytes = from_hex("00ffa5a5a502");
const Frame frame = from_hex(PRESENCE_CHECK);
bytes.insert(bytes.end(), frame.begin(), frame.end());
EXPECT_EQ(feed_all(reader, bytes), frame.size());
}
TEST(PioneerWTProtocol, ReaderDropsBadChecksum) {
PacketReader reader;
Frame frame = from_hex(PRESENCE_CHECK);
frame[9] ^= 0x01;
EXPECT_EQ(feed_all(reader, frame), 0u);
EXPECT_TRUE(reader.take_checksum_error());
EXPECT_FALSE(reader.take_checksum_error());
// The next good frame is still accepted.
EXPECT_EQ(feed_all(reader, from_hex(PRESENCE_CHECK)), 12u);
}
TEST(PioneerWTProtocol, ReaderRejectsImpossibleLength) {
PacketReader reader;
EXPECT_EQ(feed_all(reader, from_hex("a501012100000005")), 0u);
EXPECT_EQ(feed_all(reader, from_hex(PRESENCE_CHECK)), 12u);
}
TEST(PioneerWTProtocol, AttributesOfStatusDump) {
const Frame frame = from_hex(STATUS_DUMP);
AttributeReader attrs(frame.data() + HEADER_SIZE + 2, frame.size() - HEADER_SIZE - 2);
std::vector<std::pair<uint16_t, uint32_t>> seen;
while (attrs.next())
seen.emplace_back(attrs.id(), attrs.value());
EXPECT_FALSE(attrs.stopped_on_unknown());
ASSERT_EQ(seen.size(), 15u);
EXPECT_EQ(seen[0], std::make_pair(ATTR_POWER, 1u));
EXPECT_EQ(seen[1], std::make_pair(ATTR_SETPOINT_C100, 2500u));
EXPECT_EQ(seen[2], std::make_pair(ATTR_INDOOR_TEMP_C100, 2170u));
EXPECT_EQ(seen[8], std::make_pair(ATTR_MODE, 4u));
EXPECT_EQ(seen[13], std::make_pair(ATTR_SETPOINT_F, 77u));
}
TEST(PioneerWTProtocol, AttributesWithCountPrefix) {
// 0038 carries a count byte: empty, then one byte of data, then the next attribute.
const Frame body = from_hex("00380000380122000101");
AttributeReader attrs(body.data(), body.size());
ASSERT_TRUE(attrs.next());
EXPECT_EQ(attrs.id(), 0x0038);
ASSERT_TRUE(attrs.next());
EXPECT_EQ(attrs.id(), 0x0038);
ASSERT_TRUE(attrs.next());
EXPECT_EQ(attrs.id(), ATTR_POWER);
EXPECT_EQ(attrs.value(), 1u);
EXPECT_FALSE(attrs.next());
EXPECT_FALSE(attrs.stopped_on_unknown());
}
TEST(PioneerWTProtocol, AttributesStopAtUnknownId) {
const Frame body = from_hex("000101abcd00001200");
AttributeReader attrs(body.data(), body.size());
ASSERT_TRUE(attrs.next());
EXPECT_EQ(attrs.id(), ATTR_POWER);
EXPECT_FALSE(attrs.next());
EXPECT_TRUE(attrs.stopped_on_unknown());
EXPECT_EQ(attrs.id(), 0xabcd);
}
// A cut-off frame, not an unknown ID: a four-byte value with three bytes, and 0147 with one of its two length bytes.
TEST(PioneerWTProtocol, AttributesStopAtTruncatedValue) {
for (const char *hex : {"0227000000", "014700"}) {
const Frame body = from_hex(hex);
AttributeReader attrs(body.data(), body.size());
EXPECT_FALSE(attrs.next()) << hex;
EXPECT_FALSE(attrs.stopped_on_unknown()) << hex;
}
}
class PioneerWTTest : public ::testing::Test {
protected:
void SetUp() override { this->sut_.set_uart_parent(&this->uart_); }
void loop_at_(uint32_t now) {
LoopBlockingGuard{nullptr, nullptr, now};
this->sut_.loop();
}
// Starts the component and acknowledges its boot request for the full status.
void start_() {
this->sut_.setup();
this->loop_at_(1000);
this->uart_.tx.clear();
this->uart_.push_rx(build(FLAG_WANT_ACK, TYPE_REPLY, 0, 0x01, {0x80, CLASS_NETWORK}));
this->loop_at_(1010);
}
// Starts the component, applies the captured full status and clears what was sent so far.
void start_with_status_() {
this->start_();
this->uart_.push_rx_hex(STATUS_DUMP);
this->loop_at_(1100);
this->uart_.tx.clear();
}
// Lets the boot request for the full status run out of attempts.
void exhaust_boot_request_() {
this->sut_.setup();
for (uint32_t t = 1000; t <= 4000; t += 500)
this->loop_at_(t);
}
MockUARTComponent uart_;
PioneerWT sut_;
};
TEST_F(PioneerWTTest, ResendsUntilAcknowledgedThenGivesUp) {
this->sut_.setup();
this->loop_at_(1000);
const Frame request = status_request(0x01);
EXPECT_EQ(this->uart_.tx, request);
this->loop_at_(1200); // too soon to resend
EXPECT_EQ(this->uart_.tx.size(), request.size());
for (uint32_t t = 1500; t <= 2500; t += 500)
this->loop_at_(t);
EXPECT_EQ(this->uart_.tx.size(), request.size() * 4);
this->loop_at_(3000); // fourth attempt was the last
this->loop_at_(3500);
EXPECT_EQ(this->uart_.tx.size(), request.size() * 4);
}
TEST_F(PioneerWTTest, AppliesStatusDumpAndAcknowledges) {
this->start_();
this->uart_.push_rx_hex(STATUS_DUMP);
this->loop_at_(1100);
EXPECT_EQ(this->uart_.tx, from_hex("a501012300a5000ca38b800c"));
EXPECT_EQ(this->sut_.mode, climate::CLIMATE_MODE_HEAT);
EXPECT_NEAR(this->sut_.target_temperature, 25.0f, 0.01f);
EXPECT_NEAR(this->sut_.current_temperature, 21.7f, 0.01f);
ASSERT_TRUE(this->sut_.fan_mode.has_value());
EXPECT_EQ(*this->sut_.fan_mode, climate::CLIMATE_FAN_AUTO);
EXPECT_EQ(this->sut_.swing_mode, climate::CLIMATE_SWING_OFF);
}
TEST_F(PioneerWTTest, AnswersPresenceCheck) {
this->start_();
this->uart_.push_rx_hex(PRESENCE_CHECK);
this->loop_at_(1100);
EXPECT_EQ(this->uart_.tx, from_hex(PRESENCE_REPLY));
}
TEST_F(PioneerWTTest, PublishesOnlyWhenTheReportChangesSomething) {
this->start_with_status_();
int published = 0;
this->sut_.add_on_state_callback([&published](climate::Climate & /*climate*/) { published++; });
this->uart_.push_rx_hex(STATUS_DUMP);
this->loop_at_(1200);
EXPECT_EQ(published, 0);
this->uart_.push_rx(build(FLAG_WANT_ACK, TYPE_DATA, 0xb0, 0, {CLASS_STATUS, CLASS_STATUS, 0x00, 0x05, 0x03}));
this->loop_at_(1300);
EXPECT_EQ(published, 1);
}
TEST_F(PioneerWTTest, ReportsFanSpeedAndPowerOff) {
this->start_();
this->uart_.push_rx_hex(STATUS_DUMP);
this->loop_at_(1100);
// Fan speed 3, then power off.
this->uart_.push_rx(build(FLAG_WANT_ACK, TYPE_DATA, 0xb0, 0, {CLASS_STATUS, CLASS_STATUS, 0x00, 0x05, 0x03}));
this->uart_.push_rx(build(FLAG_WANT_ACK, TYPE_DATA, 0xb1, 0, {CLASS_STATUS, CLASS_STATUS, 0x00, 0x01, 0x00}));
this->loop_at_(1200);
EXPECT_EQ(this->sut_.get_custom_fan_mode(), "Speed 3");
EXPECT_EQ(this->sut_.mode, climate::CLIMATE_MODE_OFF);
}
TEST_F(PioneerWTTest, IgnoresUnknownModeAndFanSpeed) {
this->start_with_status_();
// Mode 5 and fan speed 8 are past the ends of the tables.
this->uart_.push_rx(
build(FLAG_WANT_ACK, TYPE_DATA, 0xb0, 0, {CLASS_STATUS, CLASS_STATUS, 0x00, 0x12, 0x05, 0x00, 0x05, 0x08}));
this->loop_at_(1200);
EXPECT_EQ(this->sut_.mode, climate::CLIMATE_MODE_HEAT);
ASSERT_TRUE(this->sut_.fan_mode.has_value());
EXPECT_EQ(*this->sut_.fan_mode, climate::CLIMATE_FAN_AUTO);
}
TEST_F(PioneerWTTest, ModeChangeWhileOnSendsModeOnly) {
this->start_with_status_();
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_COOL).perform();
this->loop_at_(1200);
EXPECT_EQ(this->uart_.tx, from_hex("a50101210200000f0d230a0a001201"));
// State follows the AC's report, not the request.
EXPECT_EQ(this->sut_.mode, climate::CLIMATE_MODE_HEAT);
}
TEST_F(PioneerWTTest, TurnOnSendsPowerModeAndSetpoint) {
this->start_();
this->uart_.tx.clear();
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_HEAT).set_target_temperature(20.0f).perform();
this->loop_at_(1200);
EXPECT_EQ(this->uart_.tx, from_hex("a50101210200001869400a0a000101001204022700000044"));
}
TEST_F(PioneerWTTest, OffSendsPowerOnly) {
this->start_with_status_();
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_OFF).perform();
this->loop_at_(1200);
EXPECT_EQ(this->uart_.tx, from_hex("a50101210200000f4b220a0a000100"));
}
TEST_F(PioneerWTTest, FanSpeedSentLikeTheApp) {
this->start_();
this->uart_.tx.clear();
this->sut_.make_call().set_fan_mode("Speed 3").perform();
this->loop_at_(1200);
EXPECT_EQ(this->uart_.tx, from_hex("a501012102000018ac1f0a0a022400022500000503007300"));
}
TEST_F(PioneerWTTest, DisplayAndBeeperCommands) {
this->start_();
this->uart_.tx.clear();
this->sut_.set_display_on(false);
this->loop_at_(1200);
EXPECT_EQ(this->uart_.tx, command(0x02, {0x00, 0x1e, 0x00}));
this->uart_.tx.clear();
this->uart_.push_rx(build(FLAG_WANT_ACK, TYPE_REPLY, 0, 0x02, {0x80, CLASS_COMMAND}));
this->sut_.set_beeper_on(true);
this->loop_at_(1300);
EXPECT_EQ(this->uart_.tx, command(0x03, {0x00, 0x25, 0x01}));
}
// The request for the full status at boot can be lost when the AC powers up at the same time.
TEST_F(PioneerWTTest, AsksAgainUntilFullStatusArrives) {
this->exhaust_boot_request_();
// The AC is alive: it sends its presence check and a small report, but never the full status.
this->uart_.push_rx_hex(PRESENCE_CHECK);
this->uart_.push_rx(build(FLAG_NO_ACK, TYPE_DATA, 0xb0, 0, {CLASS_STATUS, CLASS_STATUS, 0x00, 0x05, 0x03}));
this->loop_at_(20000);
this->uart_.tx.clear();
this->loop_at_(29000);
EXPECT_TRUE(this->uart_.tx.empty());
this->loop_at_(30000);
this->loop_at_(30010);
EXPECT_EQ(this->uart_.tx, status_request(0x02));
}
TEST_F(PioneerWTTest, PresenceCheckDoesNotCountAsStatus) {
this->start_();
this->uart_.push_rx_hex(STATUS_DUMP);
this->loop_at_(1100);
// Presence checks keep arriving, but no status for five minutes.
for (uint32_t t = 60000; t <= 300000; t += 60000) {
this->uart_.push_rx_hex(PRESENCE_CHECK);
this->loop_at_(t);
}
this->uart_.tx.clear();
this->loop_at_(301100);
this->loop_at_(301110);
EXPECT_EQ(this->uart_.tx, status_request(0x02));
}
TEST_F(PioneerWTTest, WarningStaysUntilAcknowledgement) {
this->exhaust_boot_request_();
EXPECT_TRUE(this->sut_.status_has_warning());
// Sending the next command does not prove the link works.
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_COOL).perform();
this->loop_at_(5000);
EXPECT_TRUE(this->sut_.status_has_warning());
this->uart_.push_rx(build(FLAG_WANT_ACK, TYPE_REPLY, 0, 0x02, {0x80, CLASS_COMMAND}));
this->loop_at_(5100);
EXPECT_FALSE(this->sut_.status_has_warning());
}
TEST_F(PioneerWTTest, DropsPartialFrameAfterPause) {
this->start_();
// A cut-off header that claims 255 bytes would otherwise swallow the frames that follow.
this->uart_.push_rx_hex("a5010121000000ff");
this->loop_at_(1100);
this->loop_at_(1300); // idle pass after the gap
this->uart_.push_rx_hex(PRESENCE_CHECK);
this->loop_at_(2000);
EXPECT_EQ(this->uart_.tx, from_hex(PRESENCE_REPLY));
}
TEST_F(PioneerWTTest, KeepsPartialFrameAfterSlowLoop) {
this->start_();
const std::string check = PRESENCE_CHECK;
this->uart_.push_rx_hex(check.substr(0, 10));
this->loop_at_(1100);
// The loop was busy; the rest of the frame is already waiting when it runs again.
this->uart_.push_rx_hex(check.substr(10));
this->loop_at_(1500);
EXPECT_EQ(this->uart_.tx, from_hex(PRESENCE_REPLY));
}
TEST_F(PioneerWTTest, FailedPowerOnIsSentAgainWithTheNextMode) {
this->start_(); // no status yet: the AC is off
this->uart_.tx.clear();
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_HEAT).perform();
for (uint32_t t = 1100; t <= 2600; t += 500)
this->loop_at_(t); // four attempts, no acknowledgement
this->loop_at_(3100); // given up
this->uart_.tx.clear();
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_COOL).perform();
this->loop_at_(3200);
EXPECT_EQ(this->uart_.tx, command(0x03, {0x00, 0x01, 0x01, 0x00, 0x12, 0x01}));
}
TEST_F(PioneerWTTest, ModeAfterQueuedOffTurnsBackOn) {
this->start_with_status_();
// Both calls are made before the AC reports that it is off.
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_OFF).perform();
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_COOL).perform();
this->loop_at_(1200);
EXPECT_EQ(this->uart_.tx, command(0x02, {0x00, 0x01, 0x00}));
this->uart_.tx.clear();
this->uart_.push_rx(build(FLAG_WANT_ACK, TYPE_REPLY, 0, 0x02, {0x80, CLASS_COMMAND}));
this->loop_at_(1300);
EXPECT_EQ(this->uart_.tx, command(0x03, {0x00, 0x01, 0x01, 0x00, 0x12, 0x01}));
}
TEST_F(PioneerWTTest, ReportOnDuringQueuedOffKeepsTheOff) {
this->start_with_status_();
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_OFF).perform();
// A report sent before the AC got the off must not make the next mode change skip the power on.
this->uart_.push_rx(build(FLAG_NO_ACK, TYPE_DATA, 0xb0, 0, {CLASS_STATUS, CLASS_STATUS, 0x00, 0x01, 0x01}));
this->loop_at_(1200);
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_COOL).perform();
this->uart_.tx.clear();
this->uart_.push_rx(build(FLAG_WANT_ACK, TYPE_REPLY, 0, 0x02, {0x80, CLASS_COMMAND}));
this->loop_at_(1300);
EXPECT_EQ(this->uart_.tx, command(0x03, {0x00, 0x01, 0x01, 0x00, 0x12, 0x01}));
}
TEST_F(PioneerWTTest, EcoAndAutoFanCommand) {
this->start_();
this->uart_.tx.clear();
this->sut_.make_call().set_fan_mode(climate::CLIMATE_FAN_AUTO).set_preset(climate::CLIMATE_PRESET_ECO).perform();
this->loop_at_(1200);
EXPECT_EQ(this->uart_.tx,
command(0x02, {0x02, 0x24, 0x00, 0x02, 0x25, 0x00, 0x00, 0x05, 0x00, 0x00, 0x73, 0x01, 0x00, 0x13, 0x01}));
}
TEST_F(PioneerWTTest, ReportsEcoAndSwing) {
this->start_with_status_();
this->uart_.push_rx(
build(FLAG_NO_ACK, TYPE_DATA, 0xb0, 0, {CLASS_STATUS, CLASS_STATUS, 0x00, 0x13, 0x01, 0x00, 0x11, SWING_ON}));
this->loop_at_(1200);
ASSERT_TRUE(this->sut_.preset.has_value());
EXPECT_EQ(*this->sut_.preset, climate::CLIMATE_PRESET_ECO);
EXPECT_EQ(this->sut_.swing_mode, climate::CLIMATE_SWING_VERTICAL);
}
TEST_F(PioneerWTTest, RemoteOffWhileASettingIsQueuedIsFollowed) {
this->start_with_status_();
this->sut_.set_display_on(false);
// The handheld remote turns the AC off while the display command waits for its acknowledgement.
this->uart_.push_rx(build(FLAG_NO_ACK, TYPE_DATA, 0xb0, 0, {CLASS_STATUS, CLASS_STATUS, 0x00, 0x01, 0x00}));
this->uart_.push_rx(build(FLAG_WANT_ACK, TYPE_REPLY, 0, 0x02, {0x80, CLASS_COMMAND}));
this->loop_at_(1200);
this->uart_.tx.clear();
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_COOL).perform();
this->loop_at_(1300);
EXPECT_EQ(this->uart_.tx, command(0x03, {0x00, 0x01, 0x01, 0x00, 0x12, 0x01}));
}
TEST_F(PioneerWTTest, DroppingAnotherCommandKeepsAQueuedOff) {
this->start_with_status_();
this->sut_.set_display_on(false);
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_OFF).perform();
// The display command gets no acknowledgement and is dropped; the off is still queued.
for (uint32_t t = 1200; t <= 2700; t += 500)
this->loop_at_(t);
this->loop_at_(3200);
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_COOL).perform();
this->uart_.tx.clear();
this->uart_.push_rx(build(FLAG_WANT_ACK, TYPE_REPLY, 0, 0x03, {0x80, CLASS_COMMAND}));
this->loop_at_(3300);
EXPECT_EQ(this->uart_.tx, command(0x04, {0x00, 0x01, 0x01, 0x00, 0x12, 0x01}));
}
TEST_F(PioneerWTTest, PowerOnDroppedForRoomIsSentAgain) {
this->start_(); // no status yet: the AC is off
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_HEAT).perform();
for (uint8_t i = 0; i < 3; i++)
this->sut_.set_display_on(i % 2);
this->uart_.tx.clear();
// The queue is full; the power on at its head makes room for this call.
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_COOL).perform();
this->loop_at_(1100);
EXPECT_EQ(this->uart_.tx, command(0x03, {0x00, 0x1e, 0x00}));
for (uint8_t seq = 0x03; seq <= 0x05; seq++) {
this->uart_.push_rx(build(FLAG_WANT_ACK, TYPE_REPLY, 0, seq, {0x80, CLASS_COMMAND}));
this->loop_at_(1100 + seq * 100);
}
EXPECT_EQ(Frame(this->uart_.tx.end() - 18, this->uart_.tx.end()),
command(0x06, {0x00, 0x01, 0x01, 0x00, 0x12, 0x01}));
}
TEST_F(PioneerWTTest, AcknowledgedOffCountsBeforeItsReport) {
this->start_with_status_();
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_OFF).perform();
this->loop_at_(1200);
// The off is acknowledged, but the AC has not reported the power yet.
this->uart_.push_rx(build(FLAG_WANT_ACK, TYPE_REPLY, 0, 0x02, {0x80, CLASS_COMMAND}));
this->loop_at_(1300);
this->uart_.tx.clear();
this->sut_.make_call().set_mode(climate::CLIMATE_MODE_COOL).perform();
this->loop_at_(1400);
EXPECT_EQ(this->uart_.tx, command(0x03, {0x00, 0x01, 0x01, 0x00, 0x12, 0x01}));
}
TEST_F(PioneerWTTest, ClampsTargetTemperature) {
this->start_();
this->uart_.tx.clear();
this->sut_.make_call().set_target_temperature(-20.0f).perform();
this->loop_at_(1200);
// 16 C is 60.8 F, sent as 61 F.
EXPECT_EQ(this->uart_.tx, command(0x02, {0x02, 0x27, 0x00, 0x00, 0x00, 0x3d}));
}
TEST_F(PioneerWTTest, FullQueueDropsOldestCommand) {
this->start_();
this->uart_.tx.clear();
// Five commands with no acknowledgement; the queue holds four.
for (uint8_t i = 1; i <= 5; i++) {
this->sut_.make_call()
.set_swing_mode(i % 2 ? climate::CLIMATE_SWING_VERTICAL : climate::CLIMATE_SWING_OFF)
.perform();
}
this->loop_at_(1200);
// The first command (seq 2) was dropped, so the second (seq 3, swing off) goes out first.
EXPECT_EQ(this->uart_.tx, command(0x03, {0x00, 0x11, SWING_OFF}));
}
} // namespace esphome::pioneer_wt::testing
+48
View File
@@ -0,0 +1,48 @@
#pragma once
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <algorithm>
#include <cstdint>
#include <string>
#include <vector>
#include "esphome/components/uart/uart_component.h"
namespace esphome::pioneer_wt::testing {
inline std::vector<uint8_t> from_hex(const std::string &hex) {
std::vector<uint8_t> out;
for (size_t i = 0; i + 1 < hex.size(); i += 2)
out.push_back(static_cast<uint8_t>(std::stoul(hex.substr(i, 2), nullptr, 16)));
return out;
}
class MockUARTComponent : public uart::UARTComponent {
public:
std::vector<uint8_t> tx;
std::vector<uint8_t> rx;
void push_rx(const std::vector<uint8_t> &data) { this->rx.insert(this->rx.end(), data.begin(), data.end()); }
void push_rx_hex(const std::string &hex) { this->push_rx(from_hex(hex)); }
void write_array(const uint8_t *data, size_t len) override { this->tx.insert(this->tx.end(), data, data + len); }
bool read_array(uint8_t *data, size_t len) override {
if (this->rx.size() < len)
return false;
std::copy(this->rx.begin(), this->rx.begin() + len, data);
this->rx.erase(this->rx.begin(), this->rx.begin() + len);
return true;
}
size_t available() override { return this->rx.size(); }
MOCK_METHOD(bool, peek_byte, (uint8_t *data), (override));
MOCK_METHOD(uart::UARTFlushResult, flush, (), (override));
MOCK_METHOD(void, check_logger_conflict, (), (override));
#if defined(USE_ESP8266) || defined(USE_ESP32)
void load_settings(bool dump_config) override {}
#endif
};
} // namespace esphome::pioneer_wt::testing
+11
View File
@@ -0,0 +1,11 @@
climate:
- platform: pioneer_wt
uart_id: uart_bus
name: Pioneer WT
switch:
- platform: pioneer_wt
display:
name: Pioneer WT Display
beeper:
name: Pioneer WT Beeper
@@ -0,0 +1,45 @@
#include <gtest/gtest.h>
#include "esphome/components/pioneer_wt/pioneer_wt.h"
#include "esphome/components/switch/switch.h"
#include "esphome/core/application.h"
#include "../common.h"
namespace esphome::pioneer_wt::testing {
namespace {
class TestSwitch : public switch_::Switch {
protected:
void write_state(bool state) override {}
};
} // namespace
// Reports captured from the AC after the app changed the display and the beep.
TEST(PioneerWTSwitch, StateFollowsReports) {
MockUARTComponent uart;
PioneerWT sut;
TestSwitch display;
TestSwitch beeper;
sut.set_uart_parent(&uart);
sut.set_display_switch(&display);
sut.set_beeper_switch(&beeper);
EXPECT_FALSE(display.has_state());
uart.push_rx_hex("a50101217400000f53010c0c001e01");
uart.push_rx_hex("a50101217700000fb70b0c0c002500");
sut.loop();
EXPECT_TRUE(display.has_state());
EXPECT_TRUE(display.state);
EXPECT_TRUE(beeper.has_state());
EXPECT_FALSE(beeper.state);
uart.push_rx_hex("a50101217300000ff28b0c0c001e00");
uart.push_rx_hex("a50101217800000f3f7e0c0c002501");
sut.loop();
EXPECT_FALSE(display.state);
EXPECT_TRUE(beeper.state);
}
} // namespace esphome::pioneer_wt::testing
@@ -0,0 +1,3 @@
packages:
uart_115200: !include ../../test_build_components/common/uart_115200/esp32-idf.yaml
pioneer_wt: !include common.yaml
@@ -0,0 +1,3 @@
packages:
uart_115200: !include ../../test_build_components/common/uart_115200/esp8266-ard.yaml
pioneer_wt: !include common.yaml
+11
View File
@@ -2,3 +2,14 @@ binary_sensor:
- platform: qwiic_pir
i2c_id: i2c_bus
name: Qwiic PIR Motion Sensor
- platform: qwiic_pir
i2c_id: i2c_bus
address: 0x13
name: Qwiic PIR Native
debounce_mode: NATIVE
debounce: 10ms
- platform: qwiic_pir
i2c_id: i2c_bus
address: 0x14
name: Qwiic PIR Raw
debounce_mode: RAW
@@ -1,4 +1,3 @@
packages:
i2c: !include ../../test_build_components/common/i2c/esp32-idf.yaml
<<: !include common.yaml
qwiic_pir: !include common.yaml
@@ -1,4 +1,3 @@
packages:
i2c: !include ../../test_build_components/common/i2c/esp8266-ard.yaml
<<: !include common.yaml
qwiic_pir: !include common.yaml
@@ -1,4 +1,3 @@
packages:
i2c: !include ../../test_build_components/common/i2c/rp2040-ard.yaml
<<: !include common.yaml
qwiic_pir: !include common.yaml
@@ -0,0 +1,12 @@
# UART1 on its second pair of pins (the board allows PA01/PA00 or PA03/PA02)
uart:
- id: uart_id
tx_pin: PA03
rx_pin: PA02
baud_rate: 9600
switch:
- platform: uart
name: "UART Switch"
uart_id: uart_id
data: [0x01, 0x02, 0x03]
+5
View File
@@ -582,6 +582,11 @@ class TestEsphomeCore:
assert t == other
def test_framework_version(self, target: core.EsphomeCore) -> None:
version = core.Version(1, 12, 0)
target.data[const.KEY_CORE] = {const.KEY_FRAMEWORK_VERSION: version}
assert target.framework_version is version
def test_address__none(self, target):
target.config = {}
assert target.address is None