Compare commits

...
3 Commits
6 changed files with 60 additions and 183 deletions

No files matched your search

+6 -13
View File
@@ -1,6 +1,7 @@
#include "ds3231.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
#include "esphome/core/progmem.h"
// Datasheet:
// - https://www.analog.com/media/en/technical-documentation/data-sheets/DS3231.pdf
@@ -27,19 +28,11 @@ static const LogString *alarm_state_to_string(uint8_t control, uint8_t alarm) {
return (control & (alarm == 1 ? 0x01 : 0x02)) != 0 ? LOG_STR("enabled") : LOG_STR("disabled");
}
static const LogString *square_wave_to_string(SquareWaveFrequency frequency) {
switch (frequency) {
case SQUARE_WAVE_1HZ:
return LOG_STR("1 Hz");
case SQUARE_WAVE_1024HZ:
return LOG_STR("1.024 kHz");
case SQUARE_WAVE_4096HZ:
return LOG_STR("4.096 kHz");
case SQUARE_WAVE_8192HZ:
return LOG_STR("8.192 kHz");
default:
return LOG_STR("unknown");
}
// Indexed by SquareWaveFrequency
PROGMEM_STRING_TABLE(SquareWaveStrings, "1 Hz", "1.024 kHz", "4.096 kHz", "8.192 kHz", "unknown");
static __attribute__((noinline)) const LogString *square_wave_to_string(SquareWaveFrequency frequency) {
return SquareWaveStrings::get_log_str(static_cast<uint8_t>(frequency), SquareWaveStrings::LAST_INDEX);
}
void IRAM_ATTR DS3231Component::interrupt_handler(DS3231Component *arg) { arg->enable_loop_soon_any_context(); }
@@ -2,6 +2,7 @@
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
#include "esphome/core/progmem.h"
#include <cmath>
@@ -34,37 +35,12 @@ constexpr uint8_t KATANA_VOLUME_FULL_ATTENUATION = 255;
// The control logic ignores writes for this long after a reset.
constexpr uint32_t RESET_SETTLE_DELAY_MS = 10;
const LogString *filter_shape_to_str(FilterShape shape) {
switch (shape) {
case FILTER_SHAPE_LINEAR_PHASE_FAST:
return LOG_STR("linear_phase_fast");
case FILTER_SHAPE_LINEAR_PHASE_SLOW:
return LOG_STR("linear_phase_slow");
case FILTER_SHAPE_MIN_PHASE_FAST:
return LOG_STR("minimum_phase_fast");
case FILTER_SHAPE_MIN_PHASE_SLOW:
return LOG_STR("minimum_phase_slow");
case FILTER_SHAPE_APODIZING:
return LOG_STR("apodizing");
case FILTER_SHAPE_HYBRID:
return LOG_STR("hybrid");
default:
return LOG_STR("brick_wall");
}
}
// Indexed by FilterShape
PROGMEM_STRING_TABLE(FilterShapeStrings, "linear_phase_fast", "linear_phase_slow", "minimum_phase_fast",
"minimum_phase_slow", "apodizing", "brick_wall", "hybrid", "brick_wall");
const LogString *deemphasis_to_str(DeemphasisMode mode) {
switch (mode) {
case DEEMPHASIS_32KHZ:
return LOG_STR("32khz");
case DEEMPHASIS_44_1KHZ:
return LOG_STR("44_1khz");
case DEEMPHASIS_48KHZ:
return LOG_STR("48khz");
default:
return LOG_STR("bypass");
}
}
// Indexed by DeemphasisMode
PROGMEM_STRING_TABLE(DeemphasisStrings, "bypass", "32khz", "44_1khz", "48khz");
} // namespace
@@ -93,8 +69,10 @@ void ES9038Q2MKatana::dump_config() {
" De-emphasis: %s\n"
" Format register: 0x%02X\n"
" DoP: %s",
LOG_STR_ARG(filter_shape_to_str(this->filter_shape_)),
LOG_STR_ARG(deemphasis_to_str(this->deemphasis_mode_)), this->format_, ONOFF(this->dop_enabled_));
LOG_STR_ARG(FilterShapeStrings::get_log_str(static_cast<uint8_t>(this->filter_shape_),
FilterShapeStrings::LAST_INDEX)),
LOG_STR_ARG(DeemphasisStrings::get_log_str(this->deemphasis_mode_, DEEMPHASIS_BYPASS)), this->format_,
ONOFF(this->dop_enabled_));
LOG_I2C_DEVICE(this);
if (this->is_failed())
return;
+27 -77
View File
@@ -2,6 +2,7 @@
#include "esphome/core/application.h"
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
#include "esphome/core/progmem.h"
namespace esphome::lis2dw12 {
@@ -13,73 +14,19 @@ static constexpr uint32_t EVENT_COOLDOWN_MS = 500;
static constexpr uint32_t POLL_INTERVAL_MS = 50;
static constexpr uint8_t SIXD_POSITION_MASK = 0x3F; // XL..ZH, leaving out D6D_IA
static const LogString *power_mode_to_string(PowerMode mode) {
switch (mode) {
case PowerMode::HIGH_PERF:
return LOG_STR("High Performance");
case PowerMode::LOW_POWER_1:
return LOG_STR("Low Power 1 (12-bit)");
case PowerMode::LOW_POWER_2:
return LOG_STR("Low Power 2");
case PowerMode::LOW_POWER_3:
return LOG_STR("Low Power 3");
case PowerMode::LOW_POWER_4:
return LOG_STR("Low Power 4");
}
return LOG_STR("Unknown");
}
// Indexed by PowerMode
PROGMEM_STRING_TABLE(PowerModeStrings, "High Performance", "Low Power 1 (12-bit)", "Low Power 2", "Low Power 3",
"Low Power 4", "Unknown");
static const LogString *range_to_string(Range range) {
switch (range) {
case Range::RANGE_2G:
return LOG_STR("±2g");
case Range::RANGE_4G:
return LOG_STR("±4g");
case Range::RANGE_8G:
return LOG_STR("±8g");
case Range::RANGE_16G:
return LOG_STR("±16g");
}
return LOG_STR("Unknown");
}
// Indexed by Range
PROGMEM_STRING_TABLE(RangeStrings, "±2g", "±4g", "±8g", "±16g", "Unknown");
static const LogString *data_rate_to_string(DataRate rate) {
switch (rate) {
case DataRate::RATE_1_6HZ:
return LOG_STR("1.6 Hz");
case DataRate::RATE_12_5HZ:
return LOG_STR("12.5 Hz");
case DataRate::RATE_25HZ:
return LOG_STR("25 Hz");
case DataRate::RATE_50HZ:
return LOG_STR("50 Hz");
case DataRate::RATE_100HZ:
return LOG_STR("100 Hz");
case DataRate::RATE_200HZ:
return LOG_STR("200 Hz");
case DataRate::RATE_400HZ:
return LOG_STR("400 Hz");
case DataRate::RATE_800HZ:
return LOG_STR("800 Hz");
case DataRate::RATE_1600HZ:
return LOG_STR("1600 Hz");
}
return LOG_STR("Unknown");
}
// Indexed by DataRate
PROGMEM_STRING_TABLE(DataRateStrings, "Unknown", "1.6 Hz", "12.5 Hz", "25 Hz", "50 Hz", "100 Hz", "200 Hz", "400 Hz",
"800 Hz", "1600 Hz");
static const LogString *filter_bandwidth_to_string(FilterBandwidth bw) {
switch (bw) {
case FilterBandwidth::BW_ODR_DIV_2:
return LOG_STR("ODR/2");
case FilterBandwidth::BW_ODR_DIV_4:
return LOG_STR("ODR/4");
case FilterBandwidth::BW_ODR_DIV_10:
return LOG_STR("ODR/10");
case FilterBandwidth::BW_ODR_DIV_20:
return LOG_STR("ODR/20");
}
return LOG_STR("Unknown");
}
// Indexed by FilterBandwidth
PROGMEM_STRING_TABLE(FilterBandwidthStrings, "ODR/2", "ODR/4", "ODR/10", "ODR/20", "Unknown");
void LIS2DW12Component::setup() {
uint8_t who_am_i{0};
@@ -169,19 +116,22 @@ bool LIS2DW12Component::configure_registers_() {
void LIS2DW12Component::dump_config() {
ESP_LOGCONFIG(TAG, "LIS2DW12:");
ESP_LOGCONFIG(TAG,
" Power Mode: %s\n"
" Data Rate: %s\n"
" Range: %s\n"
" Filter Bandwidth: %s\n"
" Low Noise: %s\n"
" Offsets: {%.3f m/s², %.3f m/s², %.3f m/s²}\n"
" Transform: {mirror_x=%s, mirror_y=%s, mirror_z=%s, swap_xy=%s}",
LOG_STR_ARG(power_mode_to_string(this->power_mode_)),
LOG_STR_ARG(data_rate_to_string(this->data_rate_)), LOG_STR_ARG(range_to_string(this->range_)),
LOG_STR_ARG(filter_bandwidth_to_string(this->filter_bandwidth_)), YESNO(this->low_noise_),
this->offset_x_, this->offset_y_, this->offset_z_, YESNO(this->mirror_x_), YESNO(this->mirror_y_),
YESNO(this->mirror_z_), YESNO(this->swap_xy_));
ESP_LOGCONFIG(
TAG,
" Power Mode: %s\n"
" Data Rate: %s\n"
" Range: %s\n"
" Filter Bandwidth: %s\n"
" Low Noise: %s\n"
" Offsets: {%.3f m/s², %.3f m/s², %.3f m/s²}\n"
" Transform: {mirror_x=%s, mirror_y=%s, mirror_z=%s, swap_xy=%s}",
LOG_STR_ARG(PowerModeStrings::get_log_str(static_cast<uint8_t>(this->power_mode_), PowerModeStrings::LAST_INDEX)),
LOG_STR_ARG(DataRateStrings::get_log_str(static_cast<uint8_t>(this->data_rate_), 0)),
LOG_STR_ARG(RangeStrings::get_log_str(static_cast<uint8_t>(this->range_), RangeStrings::LAST_INDEX)),
LOG_STR_ARG(FilterBandwidthStrings::get_log_str(static_cast<uint8_t>(this->filter_bandwidth_),
FilterBandwidthStrings::LAST_INDEX)),
YESNO(this->low_noise_), this->offset_x_, this->offset_y_, this->offset_z_, YESNO(this->mirror_x_),
YESNO(this->mirror_y_), YESNO(this->mirror_z_), YESNO(this->swap_xy_));
LOG_UPDATE_INTERVAL(this);
#ifdef USE_BINARY_SENSOR
+3 -15
View File
@@ -4,9 +4,7 @@
#include <cmath>
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
#ifdef USE_TEXT_SENSOR
#include "esphome/core/progmem.h"
#endif
namespace esphome::npm1300 {
@@ -421,18 +419,8 @@ void NPM1300Component::read_measurements_() {
// BCHGVTERM: 3.50 V to 3.65 V, then 4.00 V to 4.45 V, both in 50 mV steps
static uint16_t termination_voltage_mv(uint8_t code) { return code < 4 ? 3500 + 50 * code : 4000 + 50 * (code - 4); }
static const LogString *output_name(uint8_t index) {
switch (static_cast<NPM1300Output>(index)) {
case NPM1300Output::NPM1300_OUTPUT_BUCK1:
return LOG_STR("BUCK1");
case NPM1300Output::NPM1300_OUTPUT_BUCK2:
return LOG_STR("BUCK2");
case NPM1300Output::NPM1300_OUTPUT_LDO1:
return LOG_STR("LDO1");
default:
return LOG_STR("LDO2");
}
}
// Indexed by NPM1300Output
PROGMEM_STRING_TABLE(OutputNameStrings, "BUCK1", "BUCK2", "LDO1", "LDO2");
void NPM1300Component::dump_config() {
ESP_LOGCONFIG(TAG, "nPM1300:");
@@ -464,7 +452,7 @@ void NPM1300Component::dump_config() {
const NPM1300OutputConfig &output = config.outputs[i];
if (output.voltage == NPM1300_UNSET && output.ldo_mode == NPM1300_UNSET && output.enabled == NPM1300_UNSET)
continue;
ESP_LOGCONFIG(TAG, " %s:", LOG_STR_ARG(output_name(i)));
ESP_LOGCONFIG(TAG, " %s:", LOG_STR_ARG(OutputNameStrings::get_log_str(i, OutputNameStrings::LAST_INDEX)));
if (output.voltage != NPM1300_UNSET) {
ESP_LOGCONFIG(TAG, " Voltage: %u mV", 1000u + output.voltage * 100u);
}
+5 -12
View File
@@ -1,24 +1,17 @@
#include "sy6970.h"
#include "esphome/core/hal.h"
#include "esphome/core/log.h"
#include "esphome/core/progmem.h"
namespace esphome::sy6970 {
ESPHOME_LOG_TAG(TAG, "sy6970");
// Indexed by I2CWatchdogTimeout
PROGMEM_STRING_TABLE(I2CWatchdogTimeoutStrings, "Disabled", "40s", "80s", "160s", "Unknown");
static const LogString *i2c_watchdog_timeout_to_string(I2CWatchdogTimeout timeout) {
switch (timeout) {
case I2C_WATCHDOG_DISABLED:
return LOG_STR("Disabled");
case I2C_WATCHDOG_40S:
return LOG_STR("40s");
case I2C_WATCHDOG_80S:
return LOG_STR("80s");
case I2C_WATCHDOG_160S:
return LOG_STR("160s");
default:
return LOG_STR("Unknown");
}
return I2CWatchdogTimeoutStrings::get_log_str(static_cast<uint8_t>(timeout), I2CWatchdogTimeoutStrings::LAST_INDEX);
}
static constexpr uint32_t I2C_WATCHDOG_KICK_INTERVAL_ID = 0;
+9 -34
View File
@@ -1,6 +1,7 @@
#include "tmc22xx.h"
#include "esphome/core/application.h"
#include "esphome/core/log.h"
#include "esphome/core/progmem.h"
#include <cmath>
#include <cstring>
@@ -30,41 +31,15 @@ static constexpr uint8_t UNREACHABLE_POLL_SKIP = 9;
static constexpr uint32_t GSTAT_FLAGS = 0x07; // reset, drv_err, uv_cp
static constexpr uint32_t DRV_STATUS_FLAGS = 0x0FFF;
// Indexed by DriverEvent
PROGMEM_STRING_TABLE(DriverEventStrings, "Driver reset", "Driver error", "Charge pump undervoltage",
"Overtemperature prewarning", "Overtemperature shutdown", "Short to ground on phase A",
"Short to ground on phase B", "Low side short on phase A", "Low side short on phase B",
"Open load on phase A", "Open load on phase B", "Temperature above 120C", "Temperature above 143C",
"Temperature above 150C", "Temperature above 157C", "Unknown");
static const LogString *driver_event_to_string(DriverEvent event) {
switch (event) {
case DRIVER_EVENT_RESET:
return LOG_STR("Driver reset");
case DRIVER_EVENT_DRIVER_ERROR:
return LOG_STR("Driver error");
case DRIVER_EVENT_CHARGE_PUMP_UNDERVOLTAGE:
return LOG_STR("Charge pump undervoltage");
case DRIVER_EVENT_OVERTEMPERATURE_PREWARNING:
return LOG_STR("Overtemperature prewarning");
case DRIVER_EVENT_OVERTEMPERATURE:
return LOG_STR("Overtemperature shutdown");
case DRIVER_EVENT_SHORT_TO_GROUND_A:
return LOG_STR("Short to ground on phase A");
case DRIVER_EVENT_SHORT_TO_GROUND_B:
return LOG_STR("Short to ground on phase B");
case DRIVER_EVENT_LOW_SIDE_SHORT_A:
return LOG_STR("Low side short on phase A");
case DRIVER_EVENT_LOW_SIDE_SHORT_B:
return LOG_STR("Low side short on phase B");
case DRIVER_EVENT_OPEN_LOAD_A:
return LOG_STR("Open load on phase A");
case DRIVER_EVENT_OPEN_LOAD_B:
return LOG_STR("Open load on phase B");
case DRIVER_EVENT_TEMPERATURE_120C:
return LOG_STR("Temperature above 120C");
case DRIVER_EVENT_TEMPERATURE_143C:
return LOG_STR("Temperature above 143C");
case DRIVER_EVENT_TEMPERATURE_150C:
return LOG_STR("Temperature above 150C");
case DRIVER_EVENT_TEMPERATURE_157C:
return LOG_STR("Temperature above 157C");
default:
return LOG_STR("Unknown");
}
return DriverEventStrings::get_log_str(static_cast<uint8_t>(event), DriverEventStrings::LAST_INDEX);
}
// CRC-8 with polynomial 0x07 over the datagram bits in the order they go out on the wire, LSB first