mirror/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2026-01-09 19:50:49 -07:00
Code Issues Packages Projects Releases Wiki Activity

[micronova] Set update_interval on entities instead on hub (#12226)

Browse Source 
Co-authored-by: pre-commit-ci-lite[bot] <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com>
This commit is contained in:
Robert Resch
2025-12-08 00:55:36 +01:00
committed by GitHub
parent 68a7634228
commit 1134251c32
18 changed files with 185 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CODEOWNERS
View File

@@ -307,7 +307,7 @@ esphome/components/md5/* @esphome/core
esphome/components/mdns/* @esphome/core
esphome/components/media_player/* @jesserockz
esphome/components/micro_wake_word/* @jesserockz @kahrendt
esphome/components/micronova/* @jorre05
esphome/components/micronova/* @edenhaus @jorre05
esphome/components/microphone/* @jesserockz @kahrendt
esphome/components/mics_4514/* @jesserockz
esphome/components/midea/* @dudanov

42
esphome/components/micronova/__init__.py
View File

@@ -4,7 +4,7 @@ from esphome.components import uart
import esphome.config_validation as cv
from esphome.const import CONF_ID
CODEOWNERS = ["@jorre05"]
CODEOWNERS = ["@jorre05", "@edenhaus"]
DEPENDENCIES = ["uart"]
@@ -12,6 +12,7 @@ CONF_MICRONOVA_ID = "micronova_id"
CONF_ENABLE_RX_PIN = "enable_rx_pin"
CONF_MEMORY_LOCATION = "memory_location"
CONF_MEMORY_ADDRESS = "memory_address"
DEFAULT_POLLING_INTERVAL = "60s"
micronova_ns = cg.esphome_ns.namespace("micronova")
@@ -31,22 +32,24 @@ MICRONOVA_FUNCTIONS_ENUM = {
"STOVE_FUNCTION_CUSTOM": MicroNovaFunctions.STOVE_FUNCTION_CUSTOM,
}
MicroNova = micronova_ns.class_("MicroNova", cg.PollingComponent, uart.UARTDevice)
MicroNova = micronova_ns.class_("MicroNova", cg.Component, uart.UARTDevice)
MicroNovaListener = micronova_ns.class_("MicroNovaListener", cg.PollingComponent)
CONFIG_SCHEMA = (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(MicroNova),
cv.Required(CONF_ENABLE_RX_PIN): pins.gpio_output_pin_schema,
}
)
.extend(uart.UART_DEVICE_SCHEMA)
.extend(cv.polling_component_schema("60s"))
)
CONFIG_SCHEMA = cv.Schema(
{
cv.GenerateID(): cv.declare_id(MicroNova),
cv.Required(CONF_ENABLE_RX_PIN): pins.gpio_output_pin_schema,
}
).extend(uart.UART_DEVICE_SCHEMA)
def MICRONOVA_LISTENER_SCHEMA(default_memory_location, default_memory_address):
return cv.Schema(
def MICRONOVA_ADDRESS_SCHEMA(
*,
default_memory_location: int,
default_memory_address: int,
is_polling_component: bool,
):
schema = cv.Schema(
{
cv.GenerateID(CONF_MICRONOVA_ID): cv.use_id(MicroNova),
cv.Optional(
@@ -57,6 +60,17 @@ def MICRONOVA_LISTENER_SCHEMA(default_memory_location, default_memory_address):
): cv.hex_int_range(),
}
)
if is_polling_component:
schema = schema.extend(cv.polling_component_schema(DEFAULT_POLLING_INTERVAL))
return schema
async def to_code_micronova_listener(mv, var, config, micronova_function):
await cg.register_component(var, config)
cg.add(mv.register_micronova_listener(var))
cg.add(var.set_memory_location(config[CONF_MEMORY_LOCATION]))
cg.add(var.set_memory_address(config[CONF_MEMORY_ADDRESS]))
cg.add(var.set_function(micronova_function))
async def to_code(config):

8
esphome/components/micronova/button/__init__.py
View File

@@ -6,7 +6,7 @@ from .. import (
CONF_MEMORY_ADDRESS,
CONF_MEMORY_LOCATION,
CONF_MICRONOVA_ID,
MICRONOVA_LISTENER_SCHEMA,
MICRONOVA_ADDRESS_SCHEMA,
MicroNova,
MicroNovaFunctions,
micronova_ns,
@@ -24,8 +24,10 @@ CONFIG_SCHEMA = cv.Schema(
MicroNovaButton,
)
.extend(
MICRONOVA_LISTENER_SCHEMA(
default_memory_location=0xA0, default_memory_address=0x7D
MICRONOVA_ADDRESS_SCHEMA(
default_memory_location=0xA0,
default_memory_address=0x7D,
is_polling_component=False,
)
)
.extend({cv.Required(CONF_MEMORY_DATA): cv.hex_int_range()}),

2
esphome/components/micronova/button/micronova_button.cpp
View File

@@ -10,7 +10,7 @@ void MicroNovaButton::press_action() {
default:
break;
}
this->micronova_->update();
this->micronova_->request_update_listeners();
}
} // namespace esphome::micronova

5
esphome/components/micronova/button/micronova_button.h
View File

@@ -9,7 +9,10 @@ namespace esphome::micronova {
class MicroNovaButton : public Component, public button::Button, public MicroNovaButtonListener {
public:
MicroNovaButton(MicroNova *m) : MicroNovaButtonListener(m) {}
void dump_config() override { LOG_BUTTON("", "Micronova button", this); }
void dump_config() override {
LOG_BUTTON("", "Micronova button", this);
this->dump_base_config();
}
void set_memory_data(uint8_t f) { this->memory_data_ = f; }
uint8_t get_memory_data() { return this->memory_data_; }

24
esphome/components/micronova/micronova.cpp
View File

@@ -3,6 +3,18 @@
namespace esphome::micronova {
void MicroNovaBaseListener::dump_base_config() {
ESP_LOGCONFIG(TAG,
" Memory Location: %02X\n"
" Memory Address: %02X",
this->memory_location_, this->memory_address_);
}
void MicroNovaListener::dump_base_config() {
MicroNovaBaseListener::dump_base_config();
LOG_UPDATE_INTERVAL(this);
}
void MicroNova::setup() {
if (this->enable_rx_pin_ != nullptr) {
this->enable_rx_pin_->setup();
@@ -21,16 +33,10 @@ void MicroNova::dump_config() {
if (this->enable_rx_pin_ != nullptr) {
LOG_PIN(" Enable RX Pin: ", this->enable_rx_pin_);
}
for (auto &mv_sensor : this->micronova_listeners_) {
mv_sensor->dump_config();
ESP_LOGCONFIG(TAG, " sensor location:%02X, address:%02X", mv_sensor->get_memory_location(),
mv_sensor->get_memory_address());
}
}
void MicroNova::update() {
ESP_LOGD(TAG, "Schedule sensor update");
void MicroNova::request_update_listeners() {
ESP_LOGD(TAG, "Schedule listener update");
for (auto &mv_listener : this->micronova_listeners_) {
mv_listener->set_needs_update(true);
}
@@ -61,7 +67,7 @@ void MicroNova::loop() {
}
}
void MicroNova::request_address(uint8_t location, uint8_t address, MicroNovaSensorListener *listener) {
void MicroNova::request_address(uint8_t location, uint8_t address, MicroNovaListener *listener) {
uint8_t write_data[2] = {0, 0};
uint8_t trash_rx;

34
esphome/components/micronova/micronova.h
View File

@@ -49,7 +49,6 @@ class MicroNovaBaseListener {
public:
MicroNovaBaseListener() {}
MicroNovaBaseListener(MicroNova *m) { this->micronova_ = m; }
virtual void dump_config();
void set_micronova_object(MicroNova *m) { this->micronova_ = m; }
@@ -62,6 +61,8 @@ class MicroNovaBaseListener {
void set_memory_address(uint8_t a) { this->memory_address_ = a; }
uint8_t get_memory_address() { return this->memory_address_; }
void dump_base_config();
protected:
MicroNova *micronova_{nullptr};
MicroNovaFunctions function_ = MicroNovaFunctions::STOVE_FUNCTION_VOID;
@@ -69,28 +70,19 @@ class MicroNovaBaseListener {
uint8_t memory_address_ = 0;
};
class MicroNovaSensorListener : public MicroNovaBaseListener {
class MicroNovaListener : public MicroNovaBaseListener, public PollingComponent {
public:
MicroNovaSensorListener() {}
MicroNovaSensorListener(MicroNova *m) : MicroNovaBaseListener(m) {}
MicroNovaListener() {}
MicroNovaListener(MicroNova *m) : MicroNovaBaseListener(m) {}
virtual void request_value_from_stove() = 0;
virtual void process_value_from_stove(int value_from_stove) = 0;
void set_needs_update(bool u) { this->needs_update_ = u; }
bool get_needs_update() { return this->needs_update_; }
protected:
bool needs_update_ = false;
};
void update() override { this->set_needs_update(true); }
class MicroNovaNumberListener : public MicroNovaBaseListener {
public:
MicroNovaNumberListener(MicroNova *m) : MicroNovaBaseListener(m) {}
virtual void request_value_from_stove() = 0;
virtual void process_value_from_stove(int value_from_stove) = 0;
void set_needs_update(bool u) { this->needs_update_ = u; }
bool get_needs_update() { return this->needs_update_; }
void dump_base_config();
protected:
bool needs_update_ = false;
@@ -117,17 +109,17 @@ class MicroNovaButtonListener : public MicroNovaBaseListener {
/////////////////////////////////////////////////////////////////////
// Main component class
class MicroNova : public PollingComponent, public uart::UARTDevice {
class MicroNova : public Component, public uart::UARTDevice {
public:
MicroNova() {}
void setup() override;
void loop() override;
void update() override;
void dump_config() override;
void register_micronova_listener(MicroNovaSensorListener *l) { this->micronova_listeners_.push_back(l); }
void register_micronova_listener(MicroNovaListener *l) { this->micronova_listeners_.push_back(l); }
void request_update_listeners();
void request_address(uint8_t location, uint8_t address, MicroNovaSensorListener *listener);
void request_address(uint8_t location, uint8_t address, MicroNovaListener *listener);
void write_address(uint8_t location, uint8_t address, uint8_t data);
int read_stove_reply();
@@ -149,13 +141,13 @@ class MicroNova : public PollingComponent, public uart::UARTDevice {
uint8_t memory_location;
uint8_t memory_address;
bool reply_pending;
MicroNovaSensorListener *initiating_listener;
MicroNovaListener *initiating_listener;
};
Mutex reply_pending_mutex_;
MicroNovaSerialTransmission current_transmission_;
std::vector<MicroNovaSensorListener *> micronova_listeners_{};
std::vector<MicroNovaListener *> micronova_listeners_{};
MicroNovaSwitchListener *stove_switch_{nullptr};
};

47
esphome/components/micronova/number/__init__.py
View File

@@ -4,13 +4,13 @@ import esphome.config_validation as cv
from esphome.const import CONF_STEP, DEVICE_CLASS_TEMPERATURE, UNIT_CELSIUS
from .. import (
CONF_MEMORY_ADDRESS,
CONF_MEMORY_LOCATION,
CONF_MICRONOVA_ID,
MICRONOVA_LISTENER_SCHEMA,
MICRONOVA_ADDRESS_SCHEMA,
MicroNova,
MicroNovaFunctions,
MicroNovaListener,
micronova_ns,
to_code_micronova_listener,
)
ICON_FLASH = "mdi:flash"
@@ -19,7 +19,9 @@ CONF_THERMOSTAT_TEMPERATURE = "thermostat_temperature"
CONF_POWER_LEVEL = "power_level"
CONF_MEMORY_WRITE_LOCATION = "memory_write_location"
MicroNovaNumber = micronova_ns.class_("MicroNovaNumber", number.Number, cg.Component)
MicroNovaNumber = micronova_ns.class_(
"MicroNovaNumber", number.Number, MicroNovaListener
)
CONFIG_SCHEMA = cv.Schema(
{
@@ -30,8 +32,10 @@ CONFIG_SCHEMA = cv.Schema(
device_class=DEVICE_CLASS_TEMPERATURE,
)
.extend(
MICRONOVA_LISTENER_SCHEMA(
default_memory_location=0x20, default_memory_address=0x7D
MICRONOVA_ADDRESS_SCHEMA(
default_memory_location=0x20,
default_memory_address=0x7D,
is_polling_component=True,
)
)
.extend(
@@ -47,8 +51,10 @@ CONFIG_SCHEMA = cv.Schema(
icon=ICON_FLASH,
)
.extend(
MICRONOVA_LISTENER_SCHEMA(
default_memory_location=0x20, default_memory_address=0x7F
MICRONOVA_ADDRESS_SCHEMA(
default_memory_location=0x20,
default_memory_address=0x7F,
is_polling_component=True,
)
)
.extend(
@@ -68,24 +74,18 @@ async def to_code(config):
max_value=40,
step=thermostat_temperature_config.get(CONF_STEP),
)
await to_code_micronova_listener(
mv,
numb,
thermostat_temperature_config,
MicroNovaFunctions.STOVE_FUNCTION_THERMOSTAT_TEMPERATURE,
)
cg.add(numb.set_micronova_object(mv))
cg.add(mv.register_micronova_listener(numb))
cg.add(
numb.set_memory_location(
thermostat_temperature_config[CONF_MEMORY_LOCATION]
)
)
cg.add(
numb.set_memory_address(thermostat_temperature_config[CONF_MEMORY_ADDRESS])
)
cg.add(
numb.set_memory_write_location(
thermostat_temperature_config.get(CONF_MEMORY_WRITE_LOCATION)
)
)
cg.add(
numb.set_function(MicroNovaFunctions.STOVE_FUNCTION_THERMOSTAT_TEMPERATURE)
)
if power_level_config := config.get(CONF_POWER_LEVEL):
numb = await number.new_number(
@@ -94,13 +94,12 @@ async def to_code(config):
max_value=5,
step=1,
)
await to_code_micronova_listener(
mv, numb, power_level_config, MicroNovaFunctions.STOVE_FUNCTION_POWER_LEVEL
)
cg.add(numb.set_micronova_object(mv))
cg.add(mv.register_micronova_listener(numb))
cg.add(numb.set_memory_location(power_level_config[CONF_MEMORY_LOCATION]))
cg.add(numb.set_memory_address(power_level_config[CONF_MEMORY_ADDRESS]))
cg.add(
numb.set_memory_write_location(
power_level_config.get(CONF_MEMORY_WRITE_LOCATION)
)
)
cg.add(numb.set_function(MicroNovaFunctions.STOVE_FUNCTION_POWER_LEVEL))

2
esphome/components/micronova/number/micronova_number.cpp
View File

@@ -37,7 +37,7 @@ void MicroNovaNumber::control(float value) {
break;
}
this->micronova_->write_address(this->memory_write_location_, this->memory_address_, new_number);
this->micronova_->update();
this->micronova_->request_update_listeners();
}
} // namespace esphome::micronova

9
esphome/components/micronova/number/micronova_number.h
View File

@@ -5,11 +5,14 @@
namespace esphome::micronova {
class MicroNovaNumber : public number::Number, public MicroNovaSensorListener {
class MicroNovaNumber : public number::Number, public MicroNovaListener {
public:
MicroNovaNumber() {}
MicroNovaNumber(MicroNova *m) : MicroNovaSensorListener(m) {}
void dump_config() override { LOG_NUMBER("", "Micronova number", this); }
MicroNovaNumber(MicroNova *m) : MicroNovaListener(m) {}
void dump_config() override {
LOG_NUMBER("", "Micronova number", this);
this->dump_base_config();
}
void control(float value) override;
void request_value_from_stove() override {
this->micronova_->request_address(this->memory_location_, this->memory_address_, this);

117
esphome/components/micronova/sensor/__init__.py
View File

@@ -10,18 +10,20 @@ from esphome.const import (
)
from .. import (
CONF_MEMORY_ADDRESS,
CONF_MEMORY_LOCATION,
CONF_MICRONOVA_ID,
MICRONOVA_LISTENER_SCHEMA,
MICRONOVA_ADDRESS_SCHEMA,
MicroNova,
MicroNovaFunctions,
MicroNovaListener,
micronova_ns,
to_code_micronova_listener,
)
UNIT_BAR = "bar"
MicroNovaSensor = micronova_ns.class_("MicroNovaSensor", sensor.Sensor, cg.Component)
MicroNovaSensor = micronova_ns.class_(
"MicroNovaSensor", sensor.Sensor, MicroNovaListener
)
CONF_ROOM_TEMPERATURE = "room_temperature"
CONF_FUMES_TEMPERATURE = "fumes_temperature"
@@ -42,8 +44,10 @@ CONFIG_SCHEMA = cv.Schema(
state_class=STATE_CLASS_MEASUREMENT,
accuracy_decimals=1,
).extend(
MICRONOVA_LISTENER_SCHEMA(
default_memory_location=0x00, default_memory_address=0x01
MICRONOVA_ADDRESS_SCHEMA(
default_memory_location=0x00,
default_memory_address=0x01,
is_polling_component=True,
)
),
cv.Optional(CONF_FUMES_TEMPERATURE): sensor.sensor_schema(
@@ -53,8 +57,10 @@ CONFIG_SCHEMA = cv.Schema(
state_class=STATE_CLASS_MEASUREMENT,
accuracy_decimals=1,
).extend(
MICRONOVA_LISTENER_SCHEMA(
default_memory_location=0x00, default_memory_address=0x5A
MICRONOVA_ADDRESS_SCHEMA(
default_memory_location=0x00,
default_memory_address=0x5A,
is_polling_component=True,
)
),
cv.Optional(CONF_STOVE_POWER): sensor.sensor_schema(
@@ -62,8 +68,10 @@ CONFIG_SCHEMA = cv.Schema(
state_class=STATE_CLASS_MEASUREMENT,
accuracy_decimals=0,
).extend(
MICRONOVA_LISTENER_SCHEMA(
default_memory_location=0x00, default_memory_address=0x34
MICRONOVA_ADDRESS_SCHEMA(
default_memory_location=0x00,
default_memory_address=0x34,
is_polling_component=True,
)
),
cv.Optional(CONF_FAN_SPEED): sensor.sensor_schema(
@@ -72,8 +80,10 @@ CONFIG_SCHEMA = cv.Schema(
unit_of_measurement=UNIT_REVOLUTIONS_PER_MINUTE,
)
.extend(
MICRONOVA_LISTENER_SCHEMA(
default_memory_location=0x00, default_memory_address=0x37
MICRONOVA_ADDRESS_SCHEMA(
default_memory_location=0x00,
default_memory_address=0x37,
is_polling_component=True,
)
)
.extend(
@@ -86,8 +96,10 @@ CONFIG_SCHEMA = cv.Schema(
state_class=STATE_CLASS_MEASUREMENT,
accuracy_decimals=1,
).extend(
MICRONOVA_LISTENER_SCHEMA(
default_memory_location=0x00, default_memory_address=0x3B
MICRONOVA_ADDRESS_SCHEMA(
default_memory_location=0x00,
default_memory_address=0x3B,
is_polling_component=True,
)
),
cv.Optional(CONF_WATER_PRESSURE): sensor.sensor_schema(
@@ -97,15 +109,19 @@ CONFIG_SCHEMA = cv.Schema(
state_class=STATE_CLASS_MEASUREMENT,
accuracy_decimals=1,
).extend(
MICRONOVA_LISTENER_SCHEMA(
default_memory_location=0x00, default_memory_address=0x3C
MICRONOVA_ADDRESS_SCHEMA(
default_memory_location=0x00,
default_memory_address=0x3C,
is_polling_component=True,
)
),
cv.Optional(CONF_MEMORY_ADDRESS_SENSOR): sensor.sensor_schema(
MicroNovaSensor,
).extend(
MICRONOVA_LISTENER_SCHEMA(
default_memory_location=0x00, default_memory_address=0x00
MICRONOVA_ADDRESS_SCHEMA(
default_memory_location=0x00,
default_memory_address=0x00,
is_polling_component=True,
)
),
}
@@ -115,58 +131,21 @@ CONFIG_SCHEMA = cv.Schema(
async def to_code(config):
mv = await cg.get_variable(config[CONF_MICRONOVA_ID])
if room_temperature_config := config.get(CONF_ROOM_TEMPERATURE):
sens = await sensor.new_sensor(room_temperature_config, mv)
cg.add(mv.register_micronova_listener(sens))
cg.add(sens.set_memory_location(room_temperature_config[CONF_MEMORY_LOCATION]))
cg.add(sens.set_memory_address(room_temperature_config[CONF_MEMORY_ADDRESS]))
cg.add(sens.set_function(MicroNovaFunctions.STOVE_FUNCTION_ROOM_TEMPERATURE))
if fumes_temperature_config := config.get(CONF_FUMES_TEMPERATURE):
sens = await sensor.new_sensor(fumes_temperature_config, mv)
cg.add(mv.register_micronova_listener(sens))
cg.add(sens.set_memory_location(fumes_temperature_config[CONF_MEMORY_LOCATION]))
cg.add(sens.set_memory_address(fumes_temperature_config[CONF_MEMORY_ADDRESS]))
cg.add(sens.set_function(MicroNovaFunctions.STOVE_FUNCTION_FUMES_TEMPERATURE))
if stove_power_config := config.get(CONF_STOVE_POWER):
sens = await sensor.new_sensor(stove_power_config, mv)
cg.add(mv.register_micronova_listener(sens))
cg.add(sens.set_memory_location(stove_power_config[CONF_MEMORY_LOCATION]))
cg.add(sens.set_memory_address(stove_power_config[CONF_MEMORY_ADDRESS]))
cg.add(sens.set_function(MicroNovaFunctions.STOVE_FUNCTION_STOVE_POWER))
for key, fn in {
CONF_ROOM_TEMPERATURE: MicroNovaFunctions.STOVE_FUNCTION_ROOM_TEMPERATURE,
CONF_FUMES_TEMPERATURE: MicroNovaFunctions.STOVE_FUNCTION_FUMES_TEMPERATURE,
CONF_STOVE_POWER: MicroNovaFunctions.STOVE_FUNCTION_STOVE_POWER,
CONF_MEMORY_ADDRESS_SENSOR: MicroNovaFunctions.STOVE_FUNCTION_MEMORY_ADDRESS_SENSOR,
CONF_WATER_TEMPERATURE: MicroNovaFunctions.STOVE_FUNCTION_WATER_TEMPERATURE,
CONF_WATER_PRESSURE: MicroNovaFunctions.STOVE_FUNCTION_WATER_PRESSURE,
}.items():
if sensor_config := config.get(key):
sens = await sensor.new_sensor(sensor_config, mv)
await to_code_micronova_listener(mv, sens, sensor_config, fn)
if fan_speed_config := config.get(CONF_FAN_SPEED):
sens = await sensor.new_sensor(fan_speed_config, mv)
cg.add(mv.register_micronova_listener(sens))
cg.add(sens.set_memory_location(fan_speed_config[CONF_MEMORY_LOCATION]))
cg.add(sens.set_memory_address(fan_speed_config[CONF_MEMORY_ADDRESS]))
cg.add(sens.set_function(MicroNovaFunctions.STOVE_FUNCTION_FAN_SPEED))
await to_code_micronova_listener(
mv, sens, fan_speed_config, MicroNovaFunctions.STOVE_FUNCTION_FAN_SPEED
)
cg.add(sens.set_fan_speed_offset(fan_speed_config[CONF_FAN_RPM_OFFSET]))
if memory_address_sensor_config := config.get(CONF_MEMORY_ADDRESS_SENSOR):
sens = await sensor.new_sensor(memory_address_sensor_config, mv)
cg.add(mv.register_micronova_listener(sens))
cg.add(
sens.set_memory_location(memory_address_sensor_config[CONF_MEMORY_LOCATION])
)
cg.add(
sens.set_memory_address(memory_address_sensor_config[CONF_MEMORY_ADDRESS])
)
cg.add(
sens.set_function(MicroNovaFunctions.STOVE_FUNCTION_MEMORY_ADDRESS_SENSOR)
)
if water_temperature_config := config.get(CONF_WATER_TEMPERATURE):
sens = await sensor.new_sensor(water_temperature_config, mv)
cg.add(mv.register_micronova_listener(sens))
cg.add(sens.set_memory_location(water_temperature_config[CONF_MEMORY_LOCATION]))
cg.add(sens.set_memory_address(water_temperature_config[CONF_MEMORY_ADDRESS]))
cg.add(sens.set_function(MicroNovaFunctions.STOVE_FUNCTION_WATER_TEMPERATURE))
if water_pressure_config := config.get(CONF_WATER_PRESSURE):
sens = await sensor.new_sensor(water_pressure_config, mv)
cg.add(mv.register_micronova_listener(sens))
cg.add(sens.set_memory_location(water_pressure_config[CONF_MEMORY_LOCATION]))
cg.add(sens.set_memory_address(water_pressure_config[CONF_MEMORY_ADDRESS]))
cg.add(sens.set_function(MicroNovaFunctions.STOVE_FUNCTION_WATER_PRESSURE))

9
esphome/components/micronova/sensor/micronova_sensor.h
View File

@@ -5,10 +5,13 @@
namespace esphome::micronova {
class MicroNovaSensor : public sensor::Sensor, public MicroNovaSensorListener {
class MicroNovaSensor : public sensor::Sensor, public MicroNovaListener {
public:
MicroNovaSensor(MicroNova *m) : MicroNovaSensorListener(m) {}
void dump_config() override { LOG_SENSOR("", "Micronova sensor", this); }
MicroNovaSensor(MicroNova *m) : MicroNovaListener(m) {}
void dump_config() override {
LOG_SENSOR("", "Micronova sensor", this);
this->dump_base_config();
}
void request_value_from_stove() override {
this->micronova_->request_address(this->memory_location_, this->memory_address_, this);

8
esphome/components/micronova/switch/__init__.py
View File

@@ -7,7 +7,7 @@ from .. import (
CONF_MEMORY_ADDRESS,
CONF_MEMORY_LOCATION,
CONF_MICRONOVA_ID,
MICRONOVA_LISTENER_SCHEMA,
MICRONOVA_ADDRESS_SCHEMA,
MicroNova,
MicroNovaFunctions,
micronova_ns,
@@ -27,8 +27,10 @@ CONFIG_SCHEMA = cv.Schema(
icon=ICON_POWER,
)
.extend(
MICRONOVA_LISTENER_SCHEMA(
default_memory_location=0x80, default_memory_address=0x21
MICRONOVA_ADDRESS_SCHEMA(
default_memory_location=0x80,
default_memory_address=0x21,
is_polling_component=False,
)
)
.extend(

2
esphome/components/micronova/switch/micronova_switch.cpp
View File

@@ -22,7 +22,7 @@ void MicroNovaSwitch::write_state(bool state) {
ESP_LOGW(TAG, "Unable to turn stove off, invalid state: %d", micronova_->get_current_stove_state());
}
}
this->micronova_->update();
this->micronova_->request_update_listeners();
break;
default:

5
esphome/components/micronova/switch/micronova_switch.h
View File

@@ -9,7 +9,10 @@ namespace esphome::micronova {
class MicroNovaSwitch : public Component, public switch_::Switch, public MicroNovaSwitchListener {
public:
MicroNovaSwitch(MicroNova *m) : MicroNovaSwitchListener(m) {}
void dump_config() override { LOG_SWITCH("", "Micronova switch", this); }
void dump_config() override {
LOG_SWITCH("", "Micronova switch", this);
this->dump_base_config();
}
void set_stove_state(bool v) override { this->publish_state(v); }
bool get_stove_state() override { return this->state; }

21
esphome/components/micronova/text_sensor/__init__.py
View File

@@ -3,19 +3,19 @@ from esphome.components import text_sensor
import esphome.config_validation as cv
from .. import (
CONF_MEMORY_ADDRESS,
CONF_MEMORY_LOCATION,
CONF_MICRONOVA_ID,
MICRONOVA_LISTENER_SCHEMA,
MICRONOVA_ADDRESS_SCHEMA,
MicroNova,
MicroNovaFunctions,
MicroNovaListener,
micronova_ns,
to_code_micronova_listener,
)
CONF_STOVE_STATE = "stove_state"
MicroNovaTextSensor = micronova_ns.class_(
"MicroNovaTextSensor", text_sensor.TextSensor, cg.Component
"MicroNovaTextSensor", text_sensor.TextSensor, MicroNovaListener
)
CONFIG_SCHEMA = cv.Schema(
@@ -24,8 +24,10 @@ CONFIG_SCHEMA = cv.Schema(
cv.Optional(CONF_STOVE_STATE): text_sensor.text_sensor_schema(
MicroNovaTextSensor
).extend(
MICRONOVA_LISTENER_SCHEMA(
default_memory_location=0x00, default_memory_address=0x21
MICRONOVA_ADDRESS_SCHEMA(
default_memory_location=0x00,
default_memory_address=0x21,
is_polling_component=True,
)
),
}
@@ -37,7 +39,6 @@ async def to_code(config):
if stove_state_config := config.get(CONF_STOVE_STATE):
sens = await text_sensor.new_text_sensor(stove_state_config, mv)
cg.add(mv.register_micronova_listener(sens))
cg.add(sens.set_memory_location(stove_state_config[CONF_MEMORY_LOCATION]))
cg.add(sens.set_memory_address(stove_state_config[CONF_MEMORY_ADDRESS]))
cg.add(sens.set_function(MicroNovaFunctions.STOVE_FUNCTION_STOVE_STATE))
await to_code_micronova_listener(
mv, sens, stove_state_config, MicroNovaFunctions.STOVE_FUNCTION_STOVE_STATE
)

9
esphome/components/micronova/text_sensor/micronova_text_sensor.h
View File

@@ -5,10 +5,13 @@
namespace esphome::micronova {
class MicroNovaTextSensor : public text_sensor::TextSensor, public MicroNovaSensorListener {
class MicroNovaTextSensor : public text_sensor::TextSensor, public MicroNovaListener {
public:
MicroNovaTextSensor(MicroNova *m) : MicroNovaSensorListener(m) {}
void dump_config() override { LOG_TEXT_SENSOR("", "Micronova text sensor", this); }
MicroNovaTextSensor(MicroNova *m) : MicroNovaListener(m) {}
void dump_config() override {
LOG_TEXT_SENSOR("", "Micronova text sensor", this);
this->dump_base_config();
}
void request_value_from_stove() override {
this->micronova_->request_address(this->memory_location_, this->memory_address_, this);
}

7
tests/components/micronova/common.yaml
View File

@@ -16,6 +16,7 @@ number:
step: 1
power_level:
name: Micronova Power level
update_interval: 10s
sensor:
- platform: micronova
@@ -41,3 +42,9 @@ switch:
- platform: micronova
stove:
name: Stove on/off
text_sensor:
- platform: micronova
stove_state:
name: Stove status
update_interval: 5s