Home-IoT/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2024-11-23 23:48:11 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

reworked to_code in all __init__.py

Browse source
This commit is contained in:
Gábor Poczkodi 2024-10-19 08:35:22 +02:00
parent 6d5fe9b3c3
commit c25bc13708
37 changed files with 548 additions and 501 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

223
esphome/components/si4713_i2c/__init__.py
View file

@ -55,7 +55,7 @@ CONF_TUNER = "tuner"
CONF_DIGITAL = "digital"
CONF_PILOT = "pilot"
CONF_REFCLK = "refclk"
CONF_COMPRESSOR = "compressor"
CONF_ACOMP = "acomp"
CONF_LIMITER = "limiter"
CONF_ASQ = "asq"
CONF_RDS = "rds"
@ -87,7 +87,7 @@ CONF_DEVIATION = "deviation"
# CONF_FREQUENCY = "frequency"
# CONF_SOURCE = "source"
CONF_PRESCALER = "prescaler"
# compressor
# acomp
CONF_ENABLE = "enable"
# CONF_THRESHOLD = "threshold"
CONF_ATTACK = "attack"
@ -262,7 +262,7 @@ REFCLK_SCHEMA = cv.Schema(
}
)
COMPRESSOR_SCHEMA = cv.Schema(
ACOMP_SCHEMA = cv.Schema(
{
cv.Optional(CONF_ENABLE, default="False"): cv.boolean,
cv.Optional(CONF_THRESHOLD, default=-40): cv.int_range(-40, 0),
@ -367,7 +367,7 @@ CONFIG_SCHEMA = (
cv.Optional(CONF_DIGITAL): DIGITAL_SCHEMA,
cv.Optional(CONF_PILOT): PILOT_SCHEMA,
cv.Optional(CONF_REFCLK): REFCLK_SCHEMA,
cv.Optional(CONF_COMPRESSOR): COMPRESSOR_SCHEMA,
cv.Optional(CONF_ACOMP): ACOMP_SCHEMA,
cv.Optional(CONF_LIMITER): LIMITER_SCHEMA,
cv.Optional(CONF_ASQ): ASQ_SCHEMA,
cv.Optional(CONF_RDS): RDS_SCHEMA,
@ -378,6 +378,122 @@ CONFIG_SCHEMA = (
.extend(i2c.i2c_device_schema(0x63))
)
VARIABLES = {
None: [
[CONF_OP_MODE],
[CONF_MUTE],
[CONF_MONO],
[CONF_PRE_EMPHASIS],
],
CONF_TUNER: [
[CONF_ENABLE],
[CONF_FREQUENCY],
[CONF_DEVIATION],
[CONF_POWER],
[CONF_ANTCAP],
],
CONF_ANALOG: [
[CONF_LEVEL],
[CONF_ATTENUATION],
],
CONF_DIGITAL: [
[CONF_SAMPLE_RATE],
[CONF_SAMPLE_BITS],
[CONF_CHANNELS],
[CONF_MODE],
[CONF_CLOCK_EDGE],
],
CONF_PILOT: [
[CONF_ENABLE],
[CONF_FREQUENCY],
[CONF_DEVIATION],
],
CONF_REFCLK: [
[CONF_FREQUENCY],
[CONF_SOURCE],
[CONF_PRESCALER],
],
CONF_ACOMP: [
[CONF_ENABLE],
[CONF_THRESHOLD],
[CONF_ATTACK],
[CONF_RELEASE],
[CONF_GAIN],
[CONF_PRESET],
],
CONF_LIMITER: [
[CONF_ENABLE],
[CONF_RELEASE_TIME],
],
CONF_ASQ: [
[CONF_IALL],
[CONF_IALH],
[CONF_OVERMOD],
[CONF_LEVEL_LOW],
[CONF_DURATION_LOW],
[CONF_LEVEL_HIGH],
[CONF_DURATION_HIGH],
],
CONF_RDS: [
[CONF_ENABLE],
[CONF_DEVIATION],
[CONF_STATION],
[CONF_TEXT],
],
}
SENSORS = {
CONF_SENSOR: [
[CONF_CHIP_ID, "text_sensor"],
[CONF_READ_FREQUENCY, "sensor"],
[CONF_READ_POWER, "sensor"],
[CONF_READ_ANTCAP, "sensor"],
[CONF_READ_NOISE_LEVEL, "sensor"],
[CONF_IALL, "binary_sensor"],
[CONF_IALH, "binary_sensor"],
[CONF_OVERMOD, "binary_sensor"],
[CONF_INLEVEL, "sensor"],
]
}
async def for_each_conf(config, vars, callback):
for section in vars:
c = config[section] if section in config else config
for args in vars[section]:
setter = "set_"
if section is not None and section != CONF_SENSOR:
setter += section + "_"
setter += args[0]
if cc := c.get(args[0]):
await callback(cc, args, setter)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await i2c.register_i2c_device(var, config)
reset_pin = await cg.gpio_pin_expression(config[CONF_RESET_PIN])
cg.add(var.set_reset_pin(reset_pin))
async def set_var(c, a, s):
cg.add(getattr(var, s)(c))
await for_each_conf(config, VARIABLES, set_var)
async def new_sensor(c, args, setter):
s = None
match args[1]:
case "sensor":
s = await sensor.new_sensor(c)
case "binary_sensor":
s = await binary_sensor.new_binary_sensor(c)
case "text_sensor":
s = await text_sensor.new_text_sensor(c)
cg.add(getattr(var, setter + "_" + args[1])(s))
await for_each_conf(config, SENSORS, new_sensor)
FREQUENCY_SCHEMA = automation.maybe_simple_id(
{
@ -388,7 +504,7 @@ FREQUENCY_SCHEMA = automation.maybe_simple_id(
@automation.register_action(
"si4713.set_frequency", SetFrequencyAction, FREQUENCY_SCHEMA
"si4713.set_tuner_frequency", SetFrequencyAction, FREQUENCY_SCHEMA
)
@automation.register_action(
"si4713.measure_frequency", MeasureFrequencyAction, FREQUENCY_SCHEMA
@ -400,100 +516,3 @@ async def tune_frequency_action_to_code(config, action_id, template_arg, args):
template_ = await cg.templatable(frequency, args, cg.float_)
cg.add(var.set_frequency(template_))
return var
async def set_var(config, id, setter):
if c := config.get(id):
cg.add(setter(c))
async def new_sensor(config, id, setter):
if c := config.get(id):
s = await sensor.new_sensor(c)
cg.add(setter(s))
async def new_binary_sensor(config, id, setter):
if c := config.get(id):
s = await binary_sensor.new_binary_sensor(c)
cg.add(setter(s))
async def new_text_sensor(config, id, setter):
if c := config.get(id):
s = await text_sensor.new_text_sensor(c)
cg.add(setter(s))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await i2c.register_i2c_device(var, config)
reset_pin = await cg.gpio_pin_expression(config[CONF_RESET_PIN])
cg.add(var.set_reset_pin(reset_pin))
await set_var(config, CONF_OP_MODE, var.set_op_mode)
await set_var(config, CONF_MUTE, var.set_mute)
await set_var(config, CONF_MONO, var.set_mono)
await set_var(config, CONF_PRE_EMPHASIS, var.set_pre_emphasis)
if tuner_config := config.get(CONF_TUNER):
await set_var(tuner_config, CONF_ENABLE, var.set_power_enable)
await set_var(tuner_config, CONF_FREQUENCY, var.set_frequency)
await set_var(tuner_config, CONF_DEVIATION, var.set_audio_deviation)
await set_var(tuner_config, CONF_POWER, var.set_power)
await set_var(tuner_config, CONF_ANTCAP, var.set_antcap)
if analog_config := config.get(CONF_ANALOG):
await set_var(analog_config, CONF_LEVEL, var.set_analog_level)
await set_var(analog_config, CONF_ATTENUATION, var.set_analog_attenuation)
if digital_config := config.get(CONF_DIGITAL):
await set_var(digital_config, CONF_SAMPLE_RATE, var.set_digital_sample_rate)
await set_var(digital_config, CONF_SAMPLE_BITS, var.set_digital_sample_bits)
await set_var(digital_config, CONF_CHANNELS, var.set_digital_channels)
await set_var(digital_config, CONF_MODE, var.set_digital_mode)
await set_var(digital_config, CONF_CLOCK_EDGE, var.set_digital_clock_edge)
if pilot_config := config.get(CONF_PILOT):
await set_var(pilot_config, CONF_ENABLE, var.set_pilot_enable)
await set_var(pilot_config, CONF_FREQUENCY, var.set_pilot_frequency)
await set_var(pilot_config, CONF_DEVIATION, var.set_pilot_deviation)
if refclk_config := config.get(CONF_REFCLK):
await set_var(refclk_config, CONF_FREQUENCY, var.set_refclk_frequency)
await set_var(refclk_config, CONF_SOURCE, var.set_refclk_source)
await set_var(refclk_config, CONF_PRESCALER, var.set_refclk_prescaler)
if compressor_config := config.get(CONF_COMPRESSOR):
await set_var(compressor_config, CONF_ENABLE, var.set_acomp_enable)
await set_var(compressor_config, CONF_THRESHOLD, var.set_acomp_threshold)
await set_var(compressor_config, CONF_ATTACK, var.set_acomp_attack)
await set_var(compressor_config, CONF_RELEASE, var.set_acomp_release)
await set_var(compressor_config, CONF_GAIN, var.set_acomp_gain)
await set_var(compressor_config, CONF_PRESET, var.set_acomp_preset)
if limiter_config := config.get(CONF_LIMITER):
await set_var(limiter_config, CONF_ENABLE, var.set_limiter_enable)
await set_var(limiter_config, CONF_RELEASE_TIME, var.set_limiter_release_time)
if asq_config := config.get(CONF_ASQ):
await set_var(asq_config, CONF_IALL, var.set_asq_iall_enable)
await set_var(asq_config, CONF_IALH, var.set_asq_ialh_enable)
await set_var(asq_config, CONF_OVERMOD, var.set_asq_overmod_enable)
await set_var(asq_config, CONF_LEVEL_LOW, var.set_asq_level_low)
await set_var(asq_config, CONF_DURATION_LOW, var.set_asq_duration_low)
await set_var(asq_config, CONF_LEVEL_HIGH, var.set_asq_level_high)
await set_var(asq_config, CONF_DURATION_HIGH, var.set_asq_duration_high)
if rds_config := config.get(CONF_RDS):
await set_var(rds_config, CONF_ENABLE, var.set_rds_enable)
await set_var(rds_config, CONF_DEVIATION, var.set_rds_deviation)
await set_var(rds_config, CONF_STATION, var.set_rds_station)
await set_var(rds_config, CONF_TEXT, var.set_rds_text)
if sensor_config := config.get(CONF_SENSOR):
await new_text_sensor(sensor_config, CONF_CHIP_ID, var.set_chip_id_text_sensor)
await new_sensor(
sensor_config, CONF_READ_FREQUENCY, var.set_read_frequency_sensor
)
await new_sensor(sensor_config, CONF_READ_POWER, var.set_read_power_sensor)
await new_sensor(sensor_config, CONF_READ_ANTCAP, var.set_read_antcap_sensor)
await new_sensor(
sensor_config, CONF_READ_NOISE_LEVEL, var.set_read_noise_level_sensor
)
await new_binary_sensor(sensor_config, CONF_IALL, var.set_iall_binary_sensor)
await new_binary_sensor(sensor_config, CONF_IALH, var.set_ialh_binary_sensor)
await new_binary_sensor(
sensor_config, CONF_OVERMOD, var.set_overmod_binary_sensor
)
await new_sensor(sensor_config, CONF_INLEVEL, var.set_inlevel_sensor)

113
esphome/components/si4713_i2c/number/__init__.py
View file

@ -1,5 +1,6 @@
import esphome.codegen as cg
from esphome.components import number
from esphome.components.number import NumberMode
import esphome.config_validation as cv
from esphome.const import (
CONF_FREQUENCY,
@ -28,7 +29,7 @@ from .. import (
CONF_DIGITAL,
CONF_PILOT,
CONF_REFCLK,
CONF_COMPRESSOR,
CONF_ACOMP,
CONF_LIMITER,
CONF_ASQ,
CONF_RDS,
@ -46,12 +47,13 @@ from .. import (
UNIT_MILLI_VOLT,
UNIT_DECIBEL_MICRO_VOLT,
UNIT_PICO_FARAD,
for_each_conf,
)
FrequencyNumber = si4713_ns.class_("FrequencyNumber", number.Number)
AudioDeviationNumber = si4713_ns.class_("AudioDeviationNumber", number.Number)
PowerNumber = si4713_ns.class_("PowerNumber", number.Number)
AntcapNumber = si4713_ns.class_("AntcapNumber", number.Number)
TunerFrequencyNumber = si4713_ns.class_("TunerFrequencyNumber", number.Number)
TunerDeviationNumber = si4713_ns.class_("TunerDeviationNumber", number.Number)
TunerPowerNumber = si4713_ns.class_("TunerPowerNumber", number.Number)
TunerAntcapNumber = si4713_ns.class_("TunerAntcapNumber", number.Number)
AnalogLevelNumber = si4713_ns.class_("AnalogLevelNumber", number.Number)
DigitalSampleRateNumber = si4713_ns.class_("DigitalSampleRateNumber", number.Number)
PilotFrequencyNumber = si4713_ns.class_("PilotFrequencyNumber", number.Number)
@ -73,25 +75,25 @@ CONFIG_SCHEMA = cv.Schema(
cv.Optional(CONF_TUNER): cv.Schema(
{
cv.Optional(CONF_FREQUENCY): number.number_schema(
FrequencyNumber,
TunerFrequencyNumber,
unit_of_measurement=UNIT_MEGA_HERTZ,
device_class=DEVICE_CLASS_FREQUENCY,
entity_category=ENTITY_CATEGORY_CONFIG,
),
cv.Optional(CONF_DEVIATION): number.number_schema(
AudioDeviationNumber,
TunerDeviationNumber,
unit_of_measurement=UNIT_KILO_HERTZ,
device_class=DEVICE_CLASS_FREQUENCY,
entity_category=ENTITY_CATEGORY_CONFIG,
),
cv.Optional(CONF_POWER): number.number_schema(
PowerNumber,
TunerPowerNumber,
unit_of_measurement=UNIT_DECIBEL_MICRO_VOLT,
device_class=DEVICE_CLASS_SIGNAL_STRENGTH,
entity_category=ENTITY_CATEGORY_CONFIG,
),
cv.Optional(CONF_ANTCAP): number.number_schema(
AntcapNumber,
TunerAntcapNumber,
unit_of_measurement=UNIT_PICO_FARAD,
device_class=DEVICE_CLASS_EMPTY,
entity_category=ENTITY_CATEGORY_CONFIG,
@ -150,7 +152,7 @@ CONFIG_SCHEMA = cv.Schema(
),
},
),
cv.Optional(CONF_COMPRESSOR): cv.Schema(
cv.Optional(CONF_ACOMP): cv.Schema(
{
cv.Optional(CONF_THRESHOLD): number.number_schema(
AcompThresholdNumber,
@ -218,45 +220,58 @@ CONFIG_SCHEMA = cv.Schema(
)
async def new_number(p, config, id, setter, min_value, max_value, step, *args, **kwargs):
if c := config.get(id):
if CONF_MODE in kwargs:
if CONF_MODE not in c or c[CONF_MODE] == number.NumberMode.NUMBER_MODE_AUTO:
c[CONF_MODE] = kwargs.get(CONF_MODE)
n = await number.new_number(
c, *args, min_value=min_value, max_value=max_value, step=step
)
await cg.register_parented(n, p)
cg.add(setter(n))
return n
VARIABLES = {
CONF_TUNER: [
[CONF_FREQUENCY, 76, 108, 0.05, None],
[CONF_DEVIATION, 0, 90, 0.01, None],
[CONF_POWER, 88, 120, 1, NumberMode.NUMBER_MODE_SLIDER],
[CONF_ANTCAP, 0, 47.75, 0.25, None],
],
CONF_ANALOG: [
[CONF_LEVEL, 0, 1023, 1, NumberMode.NUMBER_MODE_SLIDER],
],
CONF_DIGITAL: [
[CONF_SAMPLE_RATE, 32000, 48000, 1, None],
],
CONF_PILOT: [
[CONF_FREQUENCY, 0, 19, 0.001, None],
[CONF_DEVIATION, 0, 90, 0.001, None],
],
CONF_REFCLK: [
[CONF_FREQUENCY, 31130, 34406, 1, None],
[CONF_PRESCALER, 0, 4095, 1, None],
],
CONF_ACOMP: [
[CONF_THRESHOLD, -40, 0, 1, None],
[CONF_GAIN, 0, 20, 1, None],
],
CONF_LIMITER: [
[CONF_RELEASE_TIME, 0.25, 102.4, 0.01, NumberMode.NUMBER_MODE_SLIDER],
],
CONF_ASQ: [
[CONF_LEVEL_LOW, -70, 0, 1, None],
[CONF_DURATION_LOW, 0, 65535, 1, None],
[CONF_LEVEL_HIGH, -70, 0, 1, None],
[CONF_DURATION_HIGH, 0, 65535, 1, None],
],
CONF_RDS: [
[CONF_DEVIATION, 0, 7.5, 0.01, None],
],
}
async def to_code(config):
p = await cg.get_variable(config[CONF_SI4713_ID])
if tuner_config := config.get(CONF_TUNER):
await new_number(p, tuner_config, CONF_FREQUENCY, p.set_frequency_number, 76, 108, 0.05)
await new_number(p, tuner_config, CONF_DEVIATION, p.set_audio_deviation_number, 0, 90, 0.01)
await new_number(p, tuner_config, CONF_POWER, p.set_power_number, 88, 120, 1, mode=number.NumberMode.NUMBER_MODE_SLIDER)
await new_number(p, tuner_config, CONF_ANTCAP, p.set_antcap_number, 0, 47.75, 0.25)
if analog_config := config.get(CONF_ANALOG):
await new_number(p, analog_config, CONF_LEVEL, p.set_analog_level_number, 0, 1023, 1, mode=number.NumberMode.NUMBER_MODE_SLIDER)
if digital_config := config.get(CONF_DIGITAL):
await new_number(p, digital_config, CONF_SAMPLE_RATE, p.set_digital_sample_rate_number, 32000, 48000, 1)
if pilot_config := config.get(CONF_PILOT):
await new_number(p, pilot_config, CONF_FREQUENCY, p.set_pilot_frequency_number, 0, 19, 0.001)
await new_number(p, pilot_config, CONF_DEVIATION, p.set_pilot_deviation_number, 0, 90, 0.001)
if refclk_config := config.get(CONF_REFCLK):
await new_number(p, refclk_config, CONF_FREQUENCY, p.set_refclk_frequency_number, 31130, 34406, 1)
await new_number(p, refclk_config, CONF_PRESCALER, p.set_refclk_prescaler_number, 0, 4095, 1)
if compressor_config := config.get(CONF_COMPRESSOR):
await new_number(p, compressor_config, CONF_THRESHOLD, p.set_acomp_threshold_number, -40, 0, 1)
await new_number(p, compressor_config, CONF_GAIN, p.set_acomp_gain_number, 0, 20, 1)
if limiter_config := config.get(CONF_LIMITER):
await new_number(p, limiter_config, CONF_RELEASE_TIME, p.set_limiter_release_time_number, 0.25, 102.4, 0.01, mode=number.NumberMode.NUMBER_MODE_SLIDER)
if asq_config := config.get(CONF_ASQ):
await new_number(p, asq_config, CONF_LEVEL_LOW, p.set_asq_level_low_number, -70, 0, 1)
await new_number(p, asq_config, CONF_DURATION_LOW, p.set_asq_duration_low_number, 0, 65535, 1)
await new_number(p, asq_config, CONF_LEVEL_HIGH, p.set_asq_level_high_number, -70, 0, 1)
await new_number(p, asq_config, CONF_DURATION_HIGH, p.set_asq_duration_high_number, 0, 65535, 1)
if rds_config := config.get(CONF_RDS):
await new_number(p, rds_config, CONF_DEVIATION, p.set_rds_deviation_number, 0, 7.5, 0.01)
parent = await cg.get_variable(config[CONF_SI4713_ID])
async def new_number(c, args, setter):
# only override mode when it's set to auto in user config
if CONF_MODE not in c or c[CONF_MODE] == number.NumberMode.NUMBER_MODE_AUTO:
if args[4] is not None:
c[CONF_MODE] = args[4]
n = await number.new_number(
c, min_value=args[1], max_value=args[2], step=args[3]
)
await cg.register_parented(n, parent)
cg.add(getattr(parent, setter + "_number")(n))
await for_each_conf(config, VARIABLES, new_number)

12
esphome/components/si4713_i2c/number/antcap_number.cpp
View file

@ -1,12 +0,0 @@
#include "antcap_number.h"
namespace esphome {
namespace si4713 {
void AntcapNumber::control(float value) {
this->publish_state(value);
this->parent_->set_antcap(value);
}
} // namespace si4713
} // namespace esphome

12
esphome/components/si4713_i2c/number/audio_deviation_number.cpp
View file

@ -1,12 +0,0 @@
#include "audio_deviation_number.h"
namespace esphome {
namespace si4713 {
void AudioDeviationNumber::control(float value) {
this->publish_state(value);
this->parent_->set_audio_deviation(value);
}
} // namespace si4713
} // namespace esphome

12
esphome/components/si4713_i2c/number/frequency_number.cpp
View file

@ -1,12 +0,0 @@
#include "frequency_number.h"
namespace esphome {
namespace si4713 {
void FrequencyNumber::control(float value) {
this->publish_state(value);
this->parent_->set_frequency(value);
}
} // namespace si4713
} // namespace esphome

12
esphome/components/si4713_i2c/number/power_number.cpp
View file

@ -1,12 +0,0 @@
#include "power_number.h"
namespace esphome {
namespace si4713 {
void PowerNumber::control(float value) {
this->publish_state(value);
this->parent_->set_power(value);
}
} // namespace si4713
} // namespace esphome

12
esphome/components/si4713_i2c/number/tuner_antcap_number.cpp Normal file
View file

@ -0,0 +1,12 @@
#include "tuner_antcap_number.h"
namespace esphome {
namespace si4713 {
void TunerAntcapNumber::control(float value) {
this->publish_state(value);
this->parent_->set_tuner_antcap(value);
}
} // namespace si4713
} // namespace esphome

4
esphome/components/si4713_i2c/number/power_number.h → esphome/components/si4713_i2c/number/tuner_antcap_number.h
View file

@ -6,9 +6,9 @@
namespace esphome {
namespace si4713 {
class PowerNumber : public number::Number, public Parented<Si4713Component> {
class TunerAntcapNumber : public number::Number, public Parented<Si4713Component> {
public:
PowerNumber() = default;
TunerAntcapNumber() = default;
protected:
void control(float value) override;

12
esphome/components/si4713_i2c/number/tuner_deviation_number.cpp Normal file
View file

@ -0,0 +1,12 @@
#include "tuner_deviation_number.h"
namespace esphome {
namespace si4713 {
void TunerDeviationNumber::control(float value) {
this->publish_state(value);
this->parent_->set_tuner_deviation(value);
}
} // namespace si4713
} // namespace esphome

4
esphome/components/si4713_i2c/number/audio_deviation_number.h → esphome/components/si4713_i2c/number/tuner_deviation_number.h
View file

@ -6,9 +6,9 @@
namespace esphome {
namespace si4713 {
class AudioDeviationNumber : public number::Number, public Parented<Si4713Component> {
class TunerDeviationNumber : public number::Number, public Parented<Si4713Component> {
public:
AudioDeviationNumber() = default;
TunerDeviationNumber() = default;
protected:
void control(float value) override;

12
esphome/components/si4713_i2c/number/tuner_frequency_number.cpp Normal file
View file

@ -0,0 +1,12 @@
#include "tuner_frequency_number.h"
namespace esphome {
namespace si4713 {
void TunerFrequencyNumber::control(float value) {
this->publish_state(value);
this->parent_->set_tuner_frequency(value);
}
} // namespace si4713
} // namespace esphome

4
esphome/components/si4713_i2c/number/frequency_number.h → esphome/components/si4713_i2c/number/tuner_frequency_number.h
View file

@ -6,9 +6,9 @@
namespace esphome {
namespace si4713 {
class FrequencyNumber : public number::Number, public Parented<Si4713Component> {
class TunerFrequencyNumber : public number::Number, public Parented<Si4713Component> {
public:
FrequencyNumber() = default;
TunerFrequencyNumber() = default;
protected:
void control(float value) override;

12
esphome/components/si4713_i2c/number/tuner_power_number.cpp Normal file
View file

@ -0,0 +1,12 @@
#include "tuner_power_number.h"
namespace esphome {
namespace si4713 {
void TunerPowerNumber::control(float value) {
this->publish_state(value);
this->parent_->set_tuner_power(value);
}
} // namespace si4713
} // namespace esphome

4
esphome/components/si4713_i2c/number/antcap_number.h → esphome/components/si4713_i2c/number/tuner_power_number.h
View file

@ -6,9 +6,9 @@
namespace esphome {
namespace si4713 {
class AntcapNumber : public number::Number, public Parented<Si4713Component> {
class TunerPowerNumber : public number::Number, public Parented<Si4713Component> {
public:
AntcapNumber() = default;
TunerPowerNumber() = default;
protected:
void control(float value) override;

2
esphome/components/si4713_i2c/output/binary_output.cpp
View file

@ -13,7 +13,7 @@ void BinaryOutput::dump_config() {
}
void BinaryOutput::write_state(bool state) {
this->parent_->set_gpio(this->pin_, state);
this->parent_->set_output_gpio(this->pin_, state);
}
} // namespace si4713

57
esphome/components/si4713_i2c/select/__init__.py
View file

@ -17,7 +17,7 @@ from .. import (
si4713_ns,
CONF_DIGITAL,
CONF_REFCLK,
CONF_COMPRESSOR,
CONF_ACOMP,
CONF_PRE_EMPHASIS,
CONF_SAMPLE_BITS,
CONF_CLOCK_EDGE,
@ -36,6 +36,7 @@ from .. import (
ACOMP_ATTACK,
ACOMP_RELEASE,
ACOMP_PRESET,
for_each_conf,
)
PreEmphasisSelect = si4713_ns.class_("PreEmphasisSelect", select.Select)
@ -99,7 +100,7 @@ CONFIG_SCHEMA = cv.Schema(
),
}
),
cv.Optional(CONF_COMPRESSOR): cv.Schema(
cv.Optional(CONF_ACOMP): cv.Schema(
{
cv.Optional(CONF_ATTACK): select.select_schema(
AcompAttackSelect,
@ -121,28 +122,36 @@ CONFIG_SCHEMA = cv.Schema(
}
)
async def new_select(p, config, id, setter, options):
if c := config.get(id):
s = await select.new_select(c, options=list(options.keys()))
await cg.register_parented(s, p)
cg.add(setter(s))
return s
VARIABLES = {
None: [
[CONF_PRE_EMPHASIS, PRE_EMPHASIS],
],
CONF_ANALOG: [
[CONF_ATTENUATION, LINE_ATTENUATION],
],
CONF_DIGITAL: [
[CONF_SAMPLE_BITS, SAMPLE_BITS],
[CONF_CHANNELS, SAMPLE_CHANNELS],
[CONF_MODE, DIGITAL_MODE],
[CONF_CLOCK_EDGE, DIGITAL_CLOCK_EDGE],
],
CONF_REFCLK: [
[CONF_SOURCE, REFCLK_SOURCE],
],
CONF_ACOMP: [
[CONF_ATTACK, ACOMP_ATTACK],
[CONF_RELEASE, ACOMP_RELEASE],
[CONF_PRESET, ACOMP_PRESET],
],
}
async def to_code(config):
p = await cg.get_variable(config[CONF_SI4713_ID])
await new_select(p, config, CONF_PRE_EMPHASIS, p.set_pre_emphasis_select, PRE_EMPHASIS)
if analog_config := config.get(CONF_ANALOG):
await new_select(p, analog_config, CONF_ATTENUATION, p.set_analog_attenuation_select, LINE_ATTENUATION)
if digital_config := config.get(CONF_DIGITAL):
await new_select(p, digital_config, CONF_SAMPLE_BITS, p.set_digital_sample_bits_select, SAMPLE_BITS)
await new_select(p, digital_config, CONF_CHANNELS, p.set_digital_channels_select, SAMPLE_CHANNELS)
await new_select(p, digital_config, CONF_MODE, p.set_digital_mode_select, DIGITAL_MODE)
await new_select(p, digital_config, CONF_CLOCK_EDGE, p.set_digital_clock_edge_select, DIGITAL_CLOCK_EDGE)
if refclk_config := config.get(CONF_REFCLK):
await new_select(p, refclk_config, CONF_SOURCE, p.set_refclk_source_select, REFCLK_SOURCE)
if compressor_config := config.get(CONF_COMPRESSOR):
await new_select(p, compressor_config, CONF_ATTACK, p.set_acomp_attack_select, ACOMP_ATTACK)
await new_select(p, compressor_config, CONF_RELEASE, p.set_acomp_release_select, ACOMP_RELEASE)
await new_select(p, compressor_config, CONF_PRESET, p.set_acomp_preset_select, ACOMP_PRESET)
parent = await cg.get_variable(config[CONF_SI4713_ID])
async def new_select(c, args, setter):
s = await select.new_select(c, options=list(args[1].keys()))
await cg.register_parented(s, parent)
cg.add(getattr(parent, setter + "_select")(s))
await for_each_conf(config, VARIABLES, new_select)

160
esphome/components/si4713_i2c/si4713.cpp
View file

@ -219,11 +219,11 @@ void Si4713Component::setup() {
this->publish_mute();
this->publish_mono();
this->publish_pre_emphasis();
this->publish_power_enable();
this->publish_frequency();
this->publish_audio_deviation();
this->publish_power();
this->publish_antcap();
this->publish_tuner_enable();
this->publish_tuner_frequency();
this->publish_tuner_deviation();
this->publish_tuner_power();
this->publish_tuner_antcap();
this->publish_analog_level();
this->publish_analog_attenuation();
this->publish_digital_sample_rate();
@ -245,9 +245,9 @@ void Si4713Component::setup() {
this->publish_acomp_preset();
this->publish_limiter_enable();
this->publish_limiter_release_time();
this->publish_asq_iall_enable();
this->publish_asq_ialh_enable();
this->publish_asq_overmod_enable();
this->publish_asq_iall();
this->publish_asq_ialh();
this->publish_asq_overmod();
this->publish_asq_level_low();
this->publish_asq_duration_low();
this->publish_asq_level_high();
@ -256,18 +256,18 @@ void Si4713Component::setup() {
this->publish_rds_deviation();
this->publish_rds_station();
this->publish_rds_text();
this->publish_gpio1();
this->publish_gpio2();
this->publish_gpio3();
this->publish_chip_id();
this->publish_read_frequency();
this->publish_read_power();
this->publish_read_antcap();
this->publish_read_noise_level();
this->publish_iall();
this->publish_ialh();
this->publish_overmod();
this->publish_inlevel();
this->publish_output_gpio1();
this->publish_output_gpio2();
this->publish_output_gpio3();
this->publish_chip_id_text_sensor();
this->publish_frequency_sensor();
this->publish_power_sensor();
this->publish_antcap_sensor();
this->publish_noise_level_sensor();
this->publish_iall_binary_sensor();
this->publish_ialh_binary_sensor();
this->publish_overmod_binary_sensor();
this->publish_inlevel_sensor();
this->set_interval(1000, [this]() { this->rds_update_(); });
}
@ -279,7 +279,7 @@ void Si4713Component::dump_config() {
ESP_LOGE(TAG, "failed!");
}
ESP_LOGCONFIG(TAG, " Chip: %s", this->chip_id_.c_str());
ESP_LOGCONFIG(TAG, " Frequency: %.2f MHz", this->get_frequency());
ESP_LOGCONFIG(TAG, " Frequency: %.2f MHz", this->get_tuner_frequency());
ESP_LOGCONFIG(TAG, " RDS station: %s", this->rds_station_.c_str());
ESP_LOGCONFIG(TAG, " RDS text: %s", this->rds_text_.c_str());
// TODO: ...and everything else...
@ -288,8 +288,8 @@ void Si4713Component::dump_config() {
void Si4713Component::update() {
// these might be changing too fast for loop()
this->publish_read_noise_level();
this->publish_inlevel();
this->publish_noise_level_sensor();
this->publish_inlevel_sensor();
}
void Si4713Component::loop() {
@ -301,10 +301,10 @@ void Si4713Component::loop() {
float f = (float) ((this->tune_status_.READFREQH << 8) | this->tune_status_.READFREQL) / 100;
ESP_LOGD(TAG, "ResTxTuneStatus FREQ %.2f RFdBuV %d ANTCAP %d NL %d", f, this->tune_status_.READRFdBuV,
this->tune_status_.READANTCAP, this->tune_status_.RNL);
this->publish_read_frequency();
this->publish_read_power();
this->publish_read_antcap();
// this->publish_read_noise_level();
this->publish_frequency_sensor();
this->publish_power_sensor();
this->publish_antcap_sensor();
// this->publish_noise_level_sensor();
}
}
if (res.ASQINT == 1) {
@ -312,10 +312,10 @@ void Si4713Component::loop() {
// ESP_LOGD(TAG, "ResTxAsqStatus IALL %d IALH %d OVERMOD %d INLEVEL %d",
// this->asq_status_.IALL, this->asq_status_.IALH, this->asq_status_.OVERMOD,
// this->asq_status_.INLEVEL);
this->publish_iall();
this->publish_ialh();
this->publish_overmod();
// this->publish_inlevel();
this->publish_iall_binary_sensor();
this->publish_ialh_binary_sensor();
this->publish_overmod_binary_sensor();
// this->publish_inlevel_sensor();
}
}
// TODO: if (res.RDSINT == 1) {}
@ -386,50 +386,50 @@ void Si4713Component::set_pre_emphasis(PreEmphasis value) {
PreEmphasis Si4713Component::get_pre_emphasis() { return (PreEmphasis) tx_pre_emphasis_.FMPE; }
void Si4713Component::set_power_enable(bool value) {
void Si4713Component::set_tuner_enable(bool value) {
this->power_enable_ = value;
this->tune_power(this->power_, this->antcap_);
// this->set_prop(this->tx_component_enable_);
this->publish_power_enable();
this->publish_tuner_enable();
}
bool Si4713Component::get_power_enable() { return this->power_enable_; }
bool Si4713Component::get_tuner_enable() { return this->power_enable_; }
void Si4713Component::set_frequency(float value) {
void Si4713Component::set_tuner_frequency(float value) {
CHECK_FLOAT_RANGE(value, FREQ_MIN, FREQ_MAX)
this->frequency_ = (uint16_t) clamp((int) std::lround(value * 20) * 5, FREQ_RAW_MIN, FREQ_RAW_MAX);
this->tune_freq(this->frequency_);
this->publish_frequency();
this->publish_tuner_frequency();
}
float Si4713Component::get_frequency() { return (float) this->frequency_ / 100; }
float Si4713Component::get_tuner_frequency() { return (float) this->frequency_ / 100; }
void Si4713Component::set_audio_deviation(float value) {
void Si4713Component::set_tuner_deviation(float value) {
CHECK_FLOAT_RANGE(value, TXADEV_MIN, TXADEV_MAX)
this->tx_audio_deviation_.TXADEV = (uint16_t) clamp((int) std::lround(value * 100), TXADEV_RAW_MIN, TXADEV_RAW_MAX);
this->set_prop(this->tx_audio_deviation_);
this->publish_audio_deviation();
this->publish_tuner_deviation();
}
float Si4713Component::get_audio_deviation() { return (float) this->tx_audio_deviation_.TXADEV / 100; }
float Si4713Component::get_tuner_deviation() { return (float) this->tx_audio_deviation_.TXADEV / 100; }
void Si4713Component::set_power(int value) {
void Si4713Component::set_tuner_power(int value) {
CHECK_INT_RANGE(value, POWER_MIN, POWER_MAX)
this->power_ = (uint8_t) value;
this->tune_power(this->power_, this->antcap_);
this->publish_power();
this->publish_tuner_power();
}
int Si4713Component::get_power() { return (int) this->power_; }
int Si4713Component::get_tuner_power() { return (int) this->power_; }
void Si4713Component::set_antcap(float value) {
void Si4713Component::set_tuner_antcap(float value) {
CHECK_FLOAT_RANGE(value, ANTCAP_MIN, ANTCAP_MAX)
this->antcap_ = (uint8_t) lround(value * 4);
this->tune_power(this->power_, this->antcap_);
this->publish_antcap();
this->publish_tuner_antcap();
}
float Si4713Component::get_antcap() { return (float) this->antcap_ * 0.25f; }
float Si4713Component::get_tuner_antcap() { return (float) this->antcap_ * 0.25f; }
void Si4713Component::set_analog_level(int value) {
CHECK_INT_RANGE(value, LILEVEL_MIN, LILEVEL_MAX)
@ -634,29 +634,29 @@ void Si4713Component::set_limiter_release_time(float value) {
float Si4713Component::get_limiter_release_time() { return (float) 512.0f / this->tx_limiter_releasee_time_.LMITERTC; }
void Si4713Component::set_asq_iall_enable(bool value) {
void Si4713Component::set_asq_iall(bool value) {
this->tx_asq_interrupt_source_.IALLIEN = value ? 1 : 0;
this->set_prop(this->tx_asq_interrupt_source_);
this->publish_asq_iall_enable();
this->publish_asq_iall();
}
bool Si4713Component::get_asq_iall_enable() { return this->tx_asq_interrupt_source_.IALLIEN != 0; }
bool Si4713Component::get_asq_iall() { return this->tx_asq_interrupt_source_.IALLIEN != 0; }
void Si4713Component::set_asq_ialh_enable(bool value) {
void Si4713Component::set_asq_ialh(bool value) {
this->tx_asq_interrupt_source_.IALHIEN = value ? 1 : 0;
this->set_prop(this->tx_asq_interrupt_source_);
this->publish_asq_ialh_enable();
this->publish_asq_ialh();
}
bool Si4713Component::get_asq_ialh_enable() { return this->tx_asq_interrupt_source_.IALHIEN != 0; }
bool Si4713Component::get_asq_ialh() { return this->tx_asq_interrupt_source_.IALHIEN != 0; }
void Si4713Component::set_asq_overmod_enable(bool value) {
void Si4713Component::set_asq_overmod(bool value) {
this->tx_asq_interrupt_source_.OVERMODIEN = value ? 1 : 0;
this->set_prop(this->tx_asq_interrupt_source_);
this->publish_asq_overmod_enable();
this->publish_asq_overmod();
}
bool Si4713Component::get_asq_overmod_enable() { return this->tx_asq_interrupt_source_.OVERMODIEN != 0; }
bool Si4713Component::get_asq_overmod() { return this->tx_asq_interrupt_source_.OVERMODIEN != 0; }
void Si4713Component::set_asq_level_low(int value) {
CHECK_INT_RANGE(value, IALTH_MIN, IALTH_MAX)
@ -728,17 +728,17 @@ void Si4713Component::set_rds_text(const std::string &value) {
std::string Si4713Component::get_rds_text() { return this->rds_text_; }
void Si4713Component::set_gpio(uint8_t pin, bool value) {
void Si4713Component::set_output_gpio(uint8_t pin, bool value) {
if (pin > 2) {
ESP_LOGE(TAG, "%s(%d, %d) invalid pin number (0 to 2)", __func__, pin, value);
return;
}
this->gpio_[pin] = value ? 1 : 0;
this->send_cmd(CmdGpioSet(this->gpio_[0], this->gpio_[1], this->gpio_[2]));
this->publish_gpio(pin);
this->publish_output_gpio(pin);
}
bool Si4713Component::get_gpio(uint8_t pin) {
bool Si4713Component::get_output_gpio(uint8_t pin) {
if (pin > 2) {
ESP_LOGE(TAG, "%s(%d) invalid pin number (0 to 2)", __func__, pin);
return false;
@ -746,62 +746,62 @@ bool Si4713Component::get_gpio(uint8_t pin) {
return this->gpio_[pin] != 0;
}
void Si4713Component::set_gpio1(bool value) {
void Si4713Component::set_output_gpio1(bool value) {
this->gpio_[0] = value ? 1 : 0;
this->send_cmd(CmdGpioSet(this->gpio_[0], this->gpio_[1], this->gpio_[2]));
this->publish_gpio1();
this->publish_output_gpio1();
}
bool Si4713Component::get_gpio1() { return this->gpio_[0] != 0; }
bool Si4713Component::get_output_gpio1() { return this->gpio_[0] != 0; }
void Si4713Component::set_gpio2(bool value) {
void Si4713Component::set_output_gpio2(bool value) {
this->gpio_[1] = value ? 1 : 0;
this->send_cmd(CmdGpioSet(this->gpio_[0], this->gpio_[1], this->gpio_[2]));
this->publish_gpio2();
this->publish_output_gpio2();
}
bool Si4713Component::get_gpio2() { return this->gpio_[1] != 0; }
bool Si4713Component::get_output_gpio2() { return this->gpio_[1] != 0; }
void Si4713Component::set_gpio3(bool value) {
void Si4713Component::set_output_gpio3(bool value) {
this->gpio_[2] = value ? 1 : 0;
this->send_cmd(CmdGpioSet(this->gpio_[0], this->gpio_[1], this->gpio_[2]));
this->publish_gpio2();
this->publish_output_gpio2();
}
bool Si4713Component::get_gpio3() { return this->gpio_[2] != 0; }
bool Si4713Component::get_output_gpio3() { return this->gpio_[2] != 0; }
std::string Si4713Component::get_chip_id() { return this->chip_id_; }
std::string Si4713Component::get_chip_id_text_sensor() { return this->chip_id_; }
float Si4713Component::get_read_frequency() {
float Si4713Component::get_frequency_sensor() {
return (float) ((this->tune_status_.READFREQH << 8) | this->tune_status_.READFREQL) / 100;
}
float Si4713Component::get_read_power() { return (float) this->tune_status_.READRFdBuV; }
float Si4713Component::get_power_sensor() { return (float) this->tune_status_.READRFdBuV; }
float Si4713Component::get_read_antcap() { return (float) this->tune_status_.READANTCAP; }
float Si4713Component::get_antcap_sensor() { return (float) this->tune_status_.READANTCAP; }
float Si4713Component::get_read_noise_level() { return (float) this->tune_status_.RNL; }
float Si4713Component::get_noise_level_sensor() { return (float) this->tune_status_.RNL; }
bool Si4713Component::get_iall() { return this->asq_status_.IALL != 0; }
bool Si4713Component::get_iall_binary_sensor() { return this->asq_status_.IALL != 0; }
bool Si4713Component::get_ialh() { return this->asq_status_.IALH != 0; }
bool Si4713Component::get_ialh_binary_sensor() { return this->asq_status_.IALH != 0; }
bool Si4713Component::get_overmod() { return this->asq_status_.OVERMOD != 0; }
bool Si4713Component::get_overmod_binary_sensor() { return this->asq_status_.OVERMOD != 0; }
float Si4713Component::get_inlevel() { return (float) this->asq_status_.INLEVEL; }
float Si4713Component::get_inlevel_sensor() { return (float) this->asq_status_.INLEVEL; }
// publish
void Si4713Component::publish_gpio(uint8_t pin) {
void Si4713Component::publish_output_gpio(uint8_t pin) {
switch (pin) {
case 0:
this->publish_switch(this->gpio1_switch_, this->gpio_[pin] != 0);
this->publish_switch(this->output_gpio1_switch_, this->gpio_[pin] != 0);
break;
case 1:
this->publish_switch(this->gpio2_switch_, this->gpio_[pin] != 0);
this->publish_switch(this->output_gpio2_switch_, this->gpio_[pin] != 0);
break;
case 2:
this->publish_switch(this->gpio3_switch_, this->gpio_[pin] != 0);
this->publish_switch(this->output_gpio3_switch_, this->gpio_[pin] != 0);
break;
default:
return;

52
esphome/components/si4713_i2c/si4713.h
View file

@ -52,18 +52,20 @@ namespace si4713 {
#define SUB_SENSOR_EX(name) \
SUB_SENSOR(name) \
void publish_##name() { this->publish(this->name##_sensor_, (float) this->get_##name()); } \
float get_##name();
void publish_##name##_sensor() { this->publish(this->name##_sensor_, (float) this->get_##name##_sensor()); } \
float get_##name##_sensor();
#define SUB_BINARY_SENSOR_EX(name) \
SUB_BINARY_SENSOR(name) \
void publish_##name() { this->publish(this->name##_binary_sensor_, this->get_##name()); } \
bool get_##name();
void publish_##name##_binary_sensor() { \
this->publish(this->name##_binary_sensor_, this->get_##name##_binary_sensor()); \
} \
bool get_##name##_binary_sensor();
#define SUB_TEXT_SENSOR_EX(name) \
SUB_TEXT_SENSOR(name) \
void publish_##name() { this->publish(this->name##_text_sensor_, this->get_##name()); } \
std::string get_##name();
void publish_##name##_text_sensor() { this->publish(this->name##_text_sensor_, this->get_##name##_text_sensor()); } \
std::string get_##name##_text_sensor();
class Si4713Component : public PollingComponent, public i2c::I2CDevice {
std::string chip_id_;
@ -161,11 +163,11 @@ class Si4713Component : public PollingComponent, public i2c::I2CDevice {
SUB_SWITCH_EX(mute)
SUB_SWITCH_EX(mono)
SUB_SELECT_EX(pre_emphasis, PreEmphasis)
SUB_SWITCH_EX(power_enable)
SUB_NUMBER_EX(frequency, float)
SUB_NUMBER_EX(audio_deviation, float)
SUB_NUMBER_EX(power, int)
SUB_NUMBER_EX(antcap, float)
SUB_SWITCH_EX(tuner_enable)
SUB_NUMBER_EX(tuner_frequency, float)
SUB_NUMBER_EX(tuner_deviation, float)
SUB_NUMBER_EX(tuner_power, int)
SUB_NUMBER_EX(tuner_antcap, float)
SUB_NUMBER_EX(analog_level, int)
SUB_SELECT_EX(analog_attenuation, LineAttenuation)
SUB_NUMBER_EX(digital_sample_rate, int)
@ -187,9 +189,9 @@ class Si4713Component : public PollingComponent, public i2c::I2CDevice {
SUB_SELECT_EX(acomp_preset, AcompPreset)
SUB_SWITCH_EX(limiter_enable)
SUB_NUMBER_EX(limiter_release_time, float)
SUB_SWITCH_EX(asq_iall_enable)
SUB_SWITCH_EX(asq_ialh_enable)
SUB_SWITCH_EX(asq_overmod_enable)
SUB_SWITCH_EX(asq_iall)
SUB_SWITCH_EX(asq_ialh)
SUB_SWITCH_EX(asq_overmod)
SUB_NUMBER_EX(asq_level_low, int)
SUB_NUMBER_EX(asq_duration_low, int)
SUB_NUMBER_EX(asq_level_high, int)
@ -198,23 +200,23 @@ class Si4713Component : public PollingComponent, public i2c::I2CDevice {
SUB_NUMBER_EX(rds_deviation, float)
SUB_TEXT_EX(rds_station)
SUB_TEXT_EX(rds_text)
SUB_SWITCH_EX(gpio1)
SUB_SWITCH_EX(gpio2)
SUB_SWITCH_EX(gpio3)
SUB_SWITCH_EX(output_gpio1)
SUB_SWITCH_EX(output_gpio2)
SUB_SWITCH_EX(output_gpio3)
SUB_TEXT_SENSOR_EX(chip_id)
SUB_SENSOR_EX(read_frequency)
SUB_SENSOR_EX(read_power)
SUB_SENSOR_EX(read_antcap)
SUB_SENSOR_EX(read_noise_level)
SUB_SENSOR_EX(frequency)
SUB_SENSOR_EX(power)
SUB_SENSOR_EX(antcap)
SUB_SENSOR_EX(noise_level)
SUB_BINARY_SENSOR_EX(iall)
SUB_BINARY_SENSOR_EX(ialh)
SUB_BINARY_SENSOR_EX(overmod)
SUB_SENSOR_EX(inlevel)
// helper
void publish_gpio(uint8_t pin);
void set_gpio(uint8_t pin, bool value);
bool get_gpio(uint8_t pin);
void publish_output_gpio(uint8_t pin);
void set_output_gpio(uint8_t pin, bool value);
bool get_output_gpio(uint8_t pin);
// used by automation
void measure_freq(float value);
@ -222,7 +224,7 @@ class Si4713Component : public PollingComponent, public i2c::I2CDevice {
template<typename... Ts> class SetFrequencyAction : public Action<Ts...>, public Parented<Si4713Component> {
TEMPLATABLE_VALUE(float, frequency)
void play(Ts... x) override { this->parent_->set_frequency(this->frequency_.value(x...)); }
void play(Ts... x) override { this->parent_->set_tuner_frequency(this->frequency_.value(x...)); }
};
template<typename... Ts> class MeasureFrequencyAction : public Action<Ts...>, public Parented<Si4713Component> {

113
esphome/components/si4713_i2c/switch/__init__.py
View file

@ -12,7 +12,7 @@ from .. import (
si4713_ns,
CONF_TUNER,
CONF_PILOT,
CONF_COMPRESSOR,
CONF_ACOMP,
CONF_LIMITER,
CONF_ASQ,
CONF_RDS,
@ -30,25 +30,26 @@ from .. import (
ICON_VOLUME_MUTE,
ICON_EAR_HEARING,
ICON_FORMAT_TEXT,
for_each_conf,
)
MuteSwitch = si4713_ns.class_("MuteSwitch", switch.Switch)
MonoSwitch = si4713_ns.class_("MonoSwitch", switch.Switch)
PowerEnableSwitch = si4713_ns.class_("PowerEnableSwitch", switch.Switch)
TunerEnableSwitch = si4713_ns.class_("TunerEnableSwitch", switch.Switch)
PilotEnableSwitch = si4713_ns.class_("PilotEnableSwitch", switch.Switch)
AcompEnableSwitch = si4713_ns.class_("AcompEnableSwitch", switch.Switch)
LimiterEnableSwitch = si4713_ns.class_("LimiterEnableSwitch", switch.Switch)
AsqOvermodEnableSwitch = si4713_ns.class_("AsqOvermodEnableSwitch", switch.Switch)
AsqIallEnableSwitch = si4713_ns.class_("AsqIallEnableSwitch", switch.Switch)
AsqIalhEnableSwitch = si4713_ns.class_("AsqIalhEnableSwitch", switch.Switch)
AsqIallSwitch = si4713_ns.class_("AsqIallSwitch", switch.Switch)
AsqIalhSwitch = si4713_ns.class_("AsqIalhSwitch", switch.Switch)
AsqOvermodSwitch = si4713_ns.class_("AsqOvermodSwitch", switch.Switch)
RdsEnable = si4713_ns.class_("RdsEnable", switch.Switch)
RDSEnableSwitch = si4713_ns.class_("RDSEnableSwitch", switch.Switch)
GPIOSwitch = si4713_ns.class_("GPIOSwitch", switch.Switch)
OutputGpioSwitch = si4713_ns.class_("OutputGpioSwitch", switch.Switch)
TUNER_SCHEMA = cv.Schema(
{
cv.Optional(CONF_ENABLE): switch.switch_schema(
PowerEnableSwitch,
TunerEnableSwitch,
device_class=DEVICE_CLASS_SWITCH,
entity_category=ENTITY_CATEGORY_CONFIG,
icon=ICON_RADIO_TOWER,
@ -68,7 +69,7 @@ PILOT_SCHEMA = cv.Schema(
)
COMPRESSOR_SCHEMA = cv.Schema(
ACOMP_SCHEMA = cv.Schema(
{
cv.Optional(CONF_ENABLE): switch.switch_schema(
AcompEnableSwitch,
@ -92,20 +93,20 @@ LIMITER_SCHEMA = cv.Schema(
ASQ_SCHEMA = cv.Schema(
{
cv.Optional(CONF_OVERMOD): switch.switch_schema(
AsqOvermodEnableSwitch,
device_class=DEVICE_CLASS_SWITCH,
entity_category=ENTITY_CATEGORY_CONFIG,
# icon=ICON_,
),
cv.Optional(CONF_IALL): switch.switch_schema(
AsqIallEnableSwitch,
AsqIallSwitch,
device_class=DEVICE_CLASS_SWITCH,
entity_category=ENTITY_CATEGORY_CONFIG,
# icon=ICON_,
),
cv.Optional(CONF_IALH): switch.switch_schema(
AsqIalhEnableSwitch,
AsqIalhSwitch,
device_class=DEVICE_CLASS_SWITCH,
entity_category=ENTITY_CATEGORY_CONFIG,
# icon=ICON_,
),
cv.Optional(CONF_OVERMOD): switch.switch_schema(
AsqOvermodSwitch,
device_class=DEVICE_CLASS_SWITCH,
entity_category=ENTITY_CATEGORY_CONFIG,
# icon=ICON_,
@ -127,19 +128,19 @@ RDS_SCHEMA = cv.Schema(
OUTPUT_SCHEMA = cv.Schema(
{
cv.Optional(CONF_GPIO1): switch.switch_schema(
GPIOSwitch,
OutputGpioSwitch,
device_class=DEVICE_CLASS_SWITCH,
entity_category=ENTITY_CATEGORY_CONFIG,
# icon=,
),
cv.Optional(CONF_GPIO2): switch.switch_schema(
GPIOSwitch,
OutputGpioSwitch,
device_class=DEVICE_CLASS_SWITCH,
entity_category=ENTITY_CATEGORY_CONFIG,
# icon=,
),
cv.Optional(CONF_GPIO3): switch.switch_schema(
GPIOSwitch,
OutputGpioSwitch,
device_class=DEVICE_CLASS_SWITCH,
entity_category=ENTITY_CATEGORY_CONFIG,
# icon=,
@ -163,7 +164,7 @@ CONFIG_SCHEMA = cv.Schema(
),
cv.Optional(CONF_TUNER): TUNER_SCHEMA,
cv.Optional(CONF_PILOT): PILOT_SCHEMA,
cv.Optional(CONF_COMPRESSOR): COMPRESSOR_SCHEMA,
cv.Optional(CONF_ACOMP): ACOMP_SCHEMA,
cv.Optional(CONF_LIMITER): LIMITER_SCHEMA,
cv.Optional(CONF_ASQ): ASQ_SCHEMA,
cv.Optional(CONF_RDS): RDS_SCHEMA,
@ -171,37 +172,47 @@ CONFIG_SCHEMA = cv.Schema(
}
)
async def new_switch(p, config, id, setter):
if c := config.get(id):
s = await switch.new_switch(c)
await cg.register_parented(s, p)
cg.add(setter(s))
return s
VARIABLES = {
None: [
[CONF_MUTE, None],
[CONF_MONO, None],
],
CONF_TUNER: [
[CONF_ENABLE, None],
],
CONF_PILOT: [
[CONF_ENABLE, None],
],
CONF_ACOMP: [
[CONF_ENABLE, None],
],
CONF_LIMITER: [
[CONF_ENABLE, None],
],
CONF_ASQ: [
[CONF_IALL, None],
[CONF_IALH, None],
[CONF_OVERMOD, None],
],
CONF_RDS: [
[CONF_ENABLE, None],
],
CONF_OUTPUT: [
[CONF_GPIO1, lambda sw: sw.set_pin(1)],
[CONF_GPIO2, lambda sw: sw.set_pin(2)],
[CONF_GPIO3, lambda sw: sw.set_pin(3)],
],
}
async def to_code(config):
p = await cg.get_variable(config[CONF_SI4713_ID])
await new_switch(p, config, CONF_MUTE, p.set_mute_switch)
await new_switch(p, config, CONF_MONO, p.set_mono_switch)
if tuner_config := config.get(CONF_TUNER):
await new_switch(p, tuner_config, CONF_ENABLE, p.set_power_enable_switch)
if pilot_config := config.get(CONF_PILOT):
await new_switch(p, pilot_config, CONF_ENABLE, p.set_pilot_enable_switch)
if compressor_config := config.get(CONF_COMPRESSOR):
await new_switch(p, compressor_config, CONF_ENABLE, p.set_acomp_enable_switch)
if limiter_config := config.get(CONF_LIMITER):
await new_switch(p, limiter_config, CONF_ENABLE, p.set_limiter_enable_switch)
if asq_config := config.get(CONF_ASQ):
await new_switch(p, asq_config, CONF_IALL, p.set_asq_iall_enable_switch)
await new_switch(p, asq_config, CONF_IALH, p.set_asq_ialh_enable_switch)
await new_switch(p, asq_config, CONF_OVERMOD, p.set_asq_overmod_enable_switch)
if rds_config := config.get(CONF_RDS):
await new_switch(p, rds_config, CONF_ENABLE, p.set_rds_enable_switch)
if output_config := config.get(CONF_OUTPUT):
gpio1 = await new_switch(p, output_config, CONF_GPIO1, p.set_gpio1_switch)
gpio2 = await new_switch(p, output_config, CONF_GPIO2, p.set_gpio2_switch)
gpio3 = await new_switch(p, output_config, CONF_GPIO3, p.set_gpio3_switch)
cg.add(gpio1.set_pin(1))
cg.add(gpio2.set_pin(2))
cg.add(gpio3.set_pin(3))
parent = await cg.get_variable(config[CONF_SI4713_ID])
async def new_switch(c, args, setter):
s = await switch.new_switch(c)
await cg.register_parented(s, parent)
sw = cg.add(getattr(parent, setter + "_switch")(s))
if cb := s[1]:
cb(sw)
await for_each_conf(config, VARIABLES, new_switch)

12
esphome/components/si4713_i2c/switch/asq_ialh_enable_switch.cpp
View file

@ -1,12 +0,0 @@
#include "asq_ialh_enable_switch.h"
namespace esphome {
namespace si4713 {
void AsqIalhEnableSwitch::write_state(bool value) {
this->publish_state(value);
this->parent_->set_asq_ialh_enable(value);
}
} // namespace si4713
} // namespace esphome

12
esphome/components/si4713_i2c/switch/asq_ialh_switch.cpp Normal file
View file

@ -0,0 +1,12 @@
#include "asq_ialh_switch.h"
namespace esphome {
namespace si4713 {
void AsqIalhSwitch::write_state(bool value) {
this->publish_state(value);
this->parent_->set_asq_ialh(value);
}
} // namespace si4713
} // namespace esphome

4
esphome/components/si4713_i2c/switch/asq_iall_enable_switch.h → esphome/components/si4713_i2c/switch/asq_ialh_switch.h
View file

@ -6,9 +6,9 @@
namespace esphome {
namespace si4713 {
class AsqIallEnableSwitch : public switch_::Switch, public Parented<Si4713Component> {
class AsqIalhSwitch : public switch_::Switch, public Parented<Si4713Component> {
public:
AsqIallEnableSwitch() = default;
AsqIalhSwitch() = default;
protected:
void write_state(bool value) override;

12
esphome/components/si4713_i2c/switch/asq_iall_enable_switch.cpp
View file

@ -1,12 +0,0 @@
#include "asq_iall_enable_switch.h"
namespace esphome {
namespace si4713 {
void AsqIallEnableSwitch::write_state(bool value) {
this->publish_state(value);
this->parent_->set_asq_iall_enable(value);
}
} // namespace si4713
} // namespace esphome

12
esphome/components/si4713_i2c/switch/asq_iall_switch.cpp Normal file
View file

@ -0,0 +1,12 @@
#include "asq_iall_switch.h"
namespace esphome {
namespace si4713 {
void AsqIallSwitch::write_state(bool value) {
this->publish_state(value);
this->parent_->set_asq_iall(value);
}
} // namespace si4713
} // namespace esphome

4
esphome/components/si4713_i2c/switch/asq_ialh_enable_switch.h → esphome/components/si4713_i2c/switch/asq_iall_switch.h
View file

@ -6,9 +6,9 @@
namespace esphome {
namespace si4713 {
class AsqIalhEnableSwitch : public switch_::Switch, public Parented<Si4713Component> {
class AsqIallSwitch : public switch_::Switch, public Parented<Si4713Component> {
public:
AsqIalhEnableSwitch() = default;
AsqIallSwitch() = default;
protected:
void write_state(bool value) override;

12
esphome/components/si4713_i2c/switch/asq_overmod_enable_switch.cpp
View file

@ -1,12 +0,0 @@
#include "asq_overmod_enable_switch.h"
namespace esphome {
namespace si4713 {
void AsqOvermodEnableSwitch::write_state(bool value) {
this->publish_state(value);
this->parent_->set_asq_overmod_enable(value);
}
} // namespace si4713
} // namespace esphome

12
esphome/components/si4713_i2c/switch/asq_overmod_switch.cpp Normal file
View file

@ -0,0 +1,12 @@
#include "asq_overmod_switch.h"
namespace esphome {
namespace si4713 {
void AsqOvermodSwitch::write_state(bool value) {
this->publish_state(value);
this->parent_->set_asq_overmod(value);
}
} // namespace si4713
} // namespace esphome

4
esphome/components/si4713_i2c/switch/asq_overmod_enable_switch.h → esphome/components/si4713_i2c/switch/asq_overmod_switch.h
View file

@ -6,9 +6,9 @@
namespace esphome {
namespace si4713 {
class AsqOvermodEnableSwitch : public switch_::Switch, public Parented<Si4713Component> {
class AsqOvermodSwitch : public switch_::Switch, public Parented<Si4713Component> {
public:
AsqOvermodEnableSwitch() = default;
AsqOvermodSwitch() = default;
protected:
void write_state(bool value) override;

12
esphome/components/si4713_i2c/switch/gpio_switch.cpp
View file

@ -1,12 +0,0 @@
#include "gpio_switch.h"
namespace esphome {
namespace si4713 {
void GPIOSwitch::write_state(bool value) {
this->publish_state(value);
this->parent_->set_gpio(this->pin_, value);
}
} // namespace si4713
} // namespace esphome

12
esphome/components/si4713_i2c/switch/output_gpio_switch.cpp Normal file
View file

@ -0,0 +1,12 @@
#include "output_gpio_switch.h"
namespace esphome {
namespace si4713 {
void OutputGpioSwitch::write_state(bool value) {
this->publish_state(value);
this->parent_->set_output_gpio(this->pin_, value);
}
} // namespace si4713
} // namespace esphome

4
esphome/components/si4713_i2c/switch/gpio_switch.h → esphome/components/si4713_i2c/switch/output_gpio_switch.h
View file

@ -6,9 +6,9 @@
namespace esphome {
namespace si4713 {
class GPIOSwitch : public switch_::Switch, public Parented<Si4713Component> {
class OutputGpioSwitch : public switch_::Switch, public Parented<Si4713Component> {
public:
GPIOSwitch() = default;
OutputGpioSwitch() = default;
void set_pin(uint8_t pin) { this->pin_ = pin - 1; }

12
esphome/components/si4713_i2c/switch/power_enable_switch.cpp
View file

@ -1,12 +0,0 @@
#include "power_enable_switch.h"
namespace esphome {
namespace si4713 {
void PowerEnableSwitch::write_state(bool value) {
this->publish_state(value);
this->parent_->set_power_enable(value);
}
} // namespace si4713
} // namespace esphome

12
esphome/components/si4713_i2c/switch/tuner_enable_switch.cpp Normal file
View file

@ -0,0 +1,12 @@
#include "tuner_enable_switch.h"
namespace esphome {
namespace si4713 {
void TunerEnableSwitch::write_state(bool value) {
this->publish_state(value);
this->parent_->set_tuner_enable(value);
}
} // namespace si4713
} // namespace esphome

4
esphome/components/si4713_i2c/switch/power_enable_switch.h → esphome/components/si4713_i2c/switch/tuner_enable_switch.h
View file

@ -6,9 +6,9 @@
namespace esphome {
namespace si4713 {
class PowerEnableSwitch : public switch_::Switch, public Parented<Si4713Component> {
class TunerEnableSwitch : public switch_::Switch, public Parented<Si4713Component> {
public:
PowerEnableSwitch() = default;
TunerEnableSwitch() = default;
protected:
void write_state(bool value) override;

41
esphome/components/si4713_i2c/text/__init__.py
View file

@ -22,6 +22,7 @@ from .. import (
CONF_RDS,
CONF_STATION,
ICON_FORMAT_TEXT,
for_each_conf,
)
RDSStationText = si4713_ns.class_("RDSStationText", text.Text)
@ -107,20 +108,6 @@ async def register_text(
)
async def new_text(
config,
*args,
min_length: Optional[int] = 0,
max_length: Optional[int] = 255,
pattern: Optional[str] = None,
):
var = cg.new_Pvariable(config[CONF_ID], *args)
await register_text(
var, config, min_length=min_length, max_length=max_length, pattern=pattern
)
return var
RDS_SCHEMA = cv.Schema(
{
cv.Optional(CONF_STATION): text_schema(
@ -143,17 +130,21 @@ CONFIG_SCHEMA = cv.Schema(
}
)
async def new_text_simple(p, config, id, setter, min_length, max_length, *args):
if c := config.get(id):
t = await new_text(c, *args, min_length=min_length, max_length=max_length)
await cg.register_parented(t, p)
cg.add(setter(t))
return t
VARIABLES = {
CONF_RDS: [
[CONF_STATION, 0, 8],
[CONF_TEXT, 0, 64],
],
}
async def to_code(config):
p = await cg.get_variable(config[CONF_SI4713_ID])
if rds_config := config.get(CONF_RDS):
await new_text_simple(p, rds_config, CONF_STATION, p.set_rds_station_text, 0, 8)
await new_text_simple(p, rds_config, CONF_TEXT, p.set_rds_text_text, 0, 64)
parent = await cg.get_variable(config[CONF_SI4713_ID])
async def new_text(c, args, setter):
var = cg.new_Pvariable(c[CONF_ID])
await register_text(var, c, min_length=args[1], max_length=args[2])
await cg.register_parented(var, parent)
cg.add(getattr(parent, setter + "_text")(var))
await for_each_conf(config, VARIABLES, new_text)

8
tests/components/si4713_i2c/test.esp32-s3-ard.yaml
View file

@ -33,7 +33,7 @@ si4713:
frequency: 32768
source: 'RCLK'
prescaler: 1
compressor:
acomp:
enable: True
preset: 'Custom'
threshold: -40
@ -104,7 +104,7 @@ number:
name: Reference Clock Frequency
prescaler:
name: Reference Clock Prescaler
compressor:
acomp:
threshold:
name: Dynamic Range Control Threshold
gain:
@ -137,7 +137,7 @@ switch:
pilot:
enable:
name: Pilot Tone Enable
compressor:
acomp:
enable:
name: Dynamic Range Control Enable
limiter:
@ -180,7 +180,7 @@ select:
refclk:
source:
name: Reference Clock Source
compressor:
acomp:
attack:
name: Dynamic Range Control Attack Time
release:

8
tests/components/si4713_i2c/test.esp32-s3-idf.yaml
View file

@ -33,7 +33,7 @@ si4713:
frequency: 32768
source: 'RCLK'
prescaler: 1
compressor:
acomp:
enable: True
preset: 'Custom'
threshold: -40
@ -104,7 +104,7 @@ number:
name: Reference Clock Frequency
prescaler:
name: Reference Clock Prescaler
compressor:
acomp:
threshold:
name: Dynamic Range Control Threshold
gain:
@ -137,7 +137,7 @@ switch:
pilot:
enable:
name: Pilot Tone Enable
compressor:
acomp:
enable:
name: Dynamic Range Control Enable
limiter:
@ -180,7 +180,7 @@ select:
refclk:
source:
name: Reference Clock Source
compressor:
acomp:
attack:
name: Dynamic Range Control Attack Time
release: