import esphome.const as ehc
from esphome.core import coroutine_with_priority
from . import const as c
from . import cpp_types as t
from .aes_key import create_aes_key
from .md5sum import get_md5sum_hexint
from .peer import peer_to_code, PEER_SCHEMA
from .receive_trigger import validate_receive_trigger, receive_trigger_to_code
COMPONENT_SCHEMA = cv.All(
cv.COMPONENT_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(t.Component),
cv.Optional(ehc.CONF_CHANNEL):
cv.All(cv.int_, cv.Range(min=1, max=14)),
cv.Optional(ehc.CONF_PASSWORD):
cv.All(cv.string, cv.Length(min=2)),
cv.Optional(c.CONF_AESKEY):
create_aes_key,
cv.Required(c.CONF_PEERS):
cv.ensure_list(PEER_SCHEMA),
cv.Optional(c.CONF_ON_RECEIVE):
validate_receive_trigger,
}), cv.has_at_most_one_key(ehc.CONF_PASSWORD, c.CONF_AESKEY))
@coroutine_with_priority(1.0)
def wifi_now_component_to_code(config):
var = cg.new_Pvariable(config[ehc.CONF_ID])
if ehc.CONF_CHANNEL in config:
cg.add(var.set_code_template(template_))
else:
code_ = config[CONF_CODE]
arr = cg.progmem_array(config[CONF_CODE_STORAGE_ID], code_)
cg.add(var.set_code_static(arr, len(code_)))
templ = await cg.templatable(config[CONF_CARRIER_FREQUENCY], args,
cg.uint32)
cg.add(var.set_carrier_frequency(templ))
# RC5
RC5Data, RC5BinarySensor, RC5Trigger, RC5Action, RC5Dumper = declare_protocol(
"RC5")
RC5_SCHEMA = cv.Schema({
cv.Required(CONF_ADDRESS):
cv.All(cv.hex_int, cv.Range(min=0, max=0x1F)),
cv.Required(CONF_COMMAND):
cv.All(cv.hex_int, cv.Range(min=0, max=0x7F)),
})
@register_binary_sensor("rc5", RC5BinarySensor, RC5_SCHEMA)
def rc5_binary_sensor(var, config):
cg.add(
var.set_data(
cg.StructInitializer(
RC5Data,
("address", config[CONF_ADDRESS]),
("command", config[CONF_COMMAND]),
)))
"Color Wipe",
{
cv.Optional(CONF_COLORS,
default=[{
CONF_NUM_LEDS: 1,
CONF_RANDOM: True
}]):
cv.ensure_list(
{
cv.Optional(CONF_RED, default=1.0): cv.percentage,
cv.Optional(CONF_GREEN, default=1.0): cv.percentage,
cv.Optional(CONF_BLUE, default=1.0): cv.percentage,
cv.Optional(CONF_WHITE, default=1.0): cv.percentage,
cv.Optional(CONF_RANDOM, default=False): cv.boolean,
cv.Required(CONF_NUM_LEDS): cv.All(cv.uint32_t,
cv.Range(min=1)),
}),
cv.Optional(CONF_ADD_LED_INTERVAL, default="0.1s"):
cv.positive_time_period_milliseconds,
cv.Optional(CONF_REVERSE, default=False):
cv.boolean,
},
)
def addressable_color_wipe_effect_to_code(config, effect_id):
var = cg.new_Pvariable(effect_id, config[CONF_NAME])
cg.add(var.set_add_led_interval(config[CONF_ADD_LED_INTERVAL]))
cg.add(var.set_reverse(config[CONF_REVERSE]))
colors = []
for color in config.get(CONF_COLORS, []):
colors.append(
cg.StructInitializer(
remote_receiver_ns = cg.esphome_ns.namespace("remote_receiver")
RemoteReceiverComponent = remote_receiver_ns.class_(
"RemoteReceiverComponent", remote_base.RemoteReceiverBase, cg.Component
)
MULTI_CONF = True
CONFIG_SCHEMA = remote_base.validate_triggers(
cv.Schema(
{
cv.GenerateID(): cv.declare_id(RemoteReceiverComponent),
cv.Required(CONF_PIN): cv.All(
pins.internal_gpio_input_pin_schema, pins.validate_has_interrupt
),
cv.Optional(CONF_DUMP, default=[]): remote_base.validate_dumpers,
cv.Optional(CONF_TOLERANCE, default=25): cv.All(
cv.percentage_int, cv.Range(min=0)
),
cv.SplitDefault(
CONF_BUFFER_SIZE, esp32="10000b", esp8266="1000b"
): cv.validate_bytes,
cv.Optional(
CONF_FILTER, default="50us"
): cv.positive_time_period_microseconds,
cv.Optional(
CONF_IDLE, default="10ms"
): cv.positive_time_period_microseconds,
cv.Optional(CONF_MEMORY_BLOCKS, default=3): cv.Range(min=1, max=8),
}
).extend(cv.COMPONENT_SCHEMA)
)
INA219Component = ina219_ns.class_("INA219Component", cg.PollingComponent,
i2c.I2CDevice)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(INA219Component),
cv.Optional(CONF_BUS_VOLTAGE):
sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 2, DEVICE_CLASS_VOLTAGE),
cv.Optional(CONF_SHUNT_VOLTAGE):
sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 2, DEVICE_CLASS_VOLTAGE),
cv.Optional(CONF_CURRENT):
sensor.sensor_schema(UNIT_AMPERE, ICON_EMPTY, 3, DEVICE_CLASS_CURRENT),
cv.Optional(CONF_POWER):
sensor.sensor_schema(UNIT_WATT, ICON_EMPTY, 2, DEVICE_CLASS_POWER),
cv.Optional(CONF_SHUNT_RESISTANCE, default=0.1):
cv.All(cv.resistance, cv.Range(min=0.0, max=32.0)),
cv.Optional(CONF_MAX_VOLTAGE, default=32.0):
cv.All(cv.voltage, cv.Range(min=0.0, max=32.0)),
cv.Optional(CONF_MAX_CURRENT, default=3.2):
cv.All(cv.current, cv.Range(min=0.0)),
}).extend(cv.polling_component_schema("60s")).extend(
i2c.i2c_device_schema(0x40)))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)
cg.add(var.set_shunt_resistance_ohm(config[CONF_SHUNT_RESISTANCE]))
cg.add(var.set_max_current_a(config[CONF_MAX_CURRENT]))
"on_off",
f"{CONF_TURN_ON_ACTION} and {CONF_TURN_OFF_ACTION} must both be defined",
):
automation.validate_automation(single=True),
cv.Inclusive(
CONF_TURN_OFF_ACTION,
"on_off",
f"{CONF_TURN_ON_ACTION} and {CONF_TURN_OFF_ACTION} must both be defined",
):
automation.validate_automation(single=True),
cv.Optional(CONF_STATE_CHANGE_ACTION):
automation.validate_automation(single=True),
cv.Required(CONF_PERIOD):
cv.All(
cv.positive_time_period_milliseconds,
cv.Range(min=core.TimePeriod(milliseconds=100)),
),
cv.Optional(CONF_RESTART_CYCLE_ON_STATE_CHANGE, default=False):
cv.boolean,
}).extend(cv.COMPONENT_SCHEMA)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await output.register_output(var, config)
if CONF_PIN in config:
pin = await cg.gpio_pin_expression(config[CONF_PIN])
cg.add(var.set_pin(pin))
if CONF_STATE_CHANGE_ACTION in config:
await automation.build_automation(
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import pins
from esphome.components import display
from esphome.const import CONF_CLK_PIN, CONF_DIO_PIN, CONF_ID, CONF_LAMBDA, CONF_INTENSITY
tm1637_ns = cg.esphome_ns.namespace('tm1637')
TM1637Display = tm1637_ns.class_('TM1637Display', cg.PollingComponent)
TM1637DisplayRef = TM1637Display.operator('ref')
CONFIG_SCHEMA = display.BASIC_DISPLAY_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(TM1637Display),
cv.Optional(CONF_INTENSITY, default=7): cv.All(cv.uint8_t, cv.Range(min=0, max=7)),
cv.Required(CONF_CLK_PIN): pins.internal_gpio_output_pin_schema,
cv.Required(CONF_DIO_PIN): pins.internal_gpio_output_pin_schema,
}).extend(cv.polling_component_schema('1s'))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield display.register_display(var, config)
clk = yield cg.gpio_pin_expression(config[CONF_CLK_PIN])
cg.add(var.set_clk_pin(clk))
dio = yield cg.gpio_pin_expression(config[CONF_DIO_PIN])
cg.add(var.set_dio_pin(dio))
cg.add(var.set_intensity(config[CONF_INTENSITY]))
CONF_CF_PIN = 'cf_pin'
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_id(HLW8012Component),
cv.Required(CONF_SEL_PIN): pins.gpio_output_pin_schema,
cv.Required(CONF_CF_PIN): cv.All(pins.internal_gpio_input_pullup_pin_schema,
pins.validate_has_interrupt),
cv.Required(CONF_CF1_PIN): cv.All(pins.internal_gpio_input_pullup_pin_schema,
pins.validate_has_interrupt),
cv.Optional(CONF_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 1),
cv.Optional(CONF_CURRENT): sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2),
cv.Optional(CONF_POWER): sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 1),
cv.Optional(CONF_CURRENT_RESISTOR, default=0.001): cv.resistance,
cv.Optional(CONF_VOLTAGE_DIVIDER, default=2351): cv.positive_float,
cv.Optional(CONF_CHANGE_MODE_EVERY, default=8): cv.All(cv.uint32_t, cv.Range(min=1)),
cv.Optional(CONF_INITIAL_MODE, default=CONF_VOLTAGE): cv.one_of(*INITIAL_MODES, lower=True),
}).extend(cv.polling_component_schema('60s'))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
sel = yield cg.gpio_pin_expression(config[CONF_SEL_PIN])
cg.add(var.set_sel_pin(sel))
cf = yield cg.gpio_pin_expression(config[CONF_CF_PIN])
cg.add(var.set_cf_pin(cf))
cf1 = yield cg.gpio_pin_expression(config[CONF_CF1_PIN])
cg.add(var.set_cf1_pin(cf1))
cv.Optional(CONF_CURRENT):
sensor.sensor_schema(
unit_of_measurement=UNIT_AMPERE,
accuracy_decimals=2,
device_class=DEVICE_CLASS_CURRENT,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_POWER):
sensor.sensor_schema(
unit_of_measurement=UNIT_WATT,
accuracy_decimals=2,
device_class=DEVICE_CLASS_POWER,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_SHUNT_RESISTANCE, default=0.1):
cv.All(cv.resistance, cv.Range(min=0.0, max=32.0)),
})
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID(): cv.declare_id(INA3221Component),
cv.Optional(CONF_CHANNEL_1): INA3221_CHANNEL_SCHEMA,
cv.Optional(CONF_CHANNEL_2): INA3221_CHANNEL_SCHEMA,
cv.Optional(CONF_CHANNEL_3): INA3221_CHANNEL_SCHEMA,
}).extend(cv.polling_component_schema("60s")).extend(
i2c.i2c_device_schema(0x40)))
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)
'1.5V': cg.global_ns.TOUCH_HVOLT_ATTEN_1V5,
'1V': cg.global_ns.TOUCH_HVOLT_ATTEN_1V,
'0.5V': cg.global_ns.TOUCH_HVOLT_ATTEN_0V5,
'0V': cg.global_ns.TOUCH_HVOLT_ATTEN_0V,
}
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(ESP32RawTouchComponent),
cv.Optional(CONF_SETUP_MODE, default=False):
cv.boolean,
cv.Optional(CONF_IIR_FILTER, default='0ms'):
cv.positive_time_period_milliseconds,
cv.Optional(CONF_SLEEP_DURATION, default='27306us'):
cv.All(cv.positive_time_period,
cv.Range(max=TimePeriod(microseconds=436906))),
cv.Optional(CONF_MEASUREMENT_DURATION, default='8192us'):
cv.All(cv.positive_time_period,
cv.Range(max=TimePeriod(microseconds=8192))),
cv.Optional(CONF_LOW_VOLTAGE_REFERENCE, default='0.5V'):
validate_voltage(LOW_VOLTAGE_REFERENCE),
cv.Optional(CONF_HIGH_VOLTAGE_REFERENCE, default='2.7V'):
validate_voltage(HIGH_VOLTAGE_REFERENCE),
cv.Optional(CONF_VOLTAGE_ATTENUATION, default='0V'):
validate_voltage(VOLTAGE_ATTENUATION),
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
touch = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(touch, config)
return cv.one_of(*uarts, upper=True)(uart)
CONFIG_SCHEMA = climate.CLIMATE_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(MitsubishiHeatPump),
cv.Optional(CONF_HARDWARE_UART, default="UART0"):
valid_uart,
cv.Optional(CONF_BAUD_RATE):
cv.positive_int,
# If polling interval is greater than 9 seconds, the HeatPump library
# reconnects, but doesn't then follow up with our data request.
cv.Optional(CONF_UPDATE_INTERVAL, default="500ms"):
cv.All(cv.update_interval, cv.Range(max=cv.TimePeriod(milliseconds=9000))),
# Optionally override the supported ClimateTraits.
cv.Optional(CONF_SUPPORTS, default={}):
cv.Schema({
cv.Optional(CONF_MODE, default=DEFAULT_CLIMATE_MODES):
cv.ensure_list(climate.validate_climate_mode),
cv.Optional(CONF_FAN_MODE, default=DEFAULT_FAN_MODES):
cv.ensure_list(climate.validate_climate_fan_mode),
cv.Optional(CONF_SWING_MODE, default=DEFAULT_SWING_MODES):
cv.ensure_list(climate.validate_climate_swing_mode),
}),
}).extend(cv.COMPONENT_SCHEMA)
@coroutine
DEVICE_CLASS_EMPTY,
STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_IIR_FILTER, default="OFF"):
cv.enum(IIR_FILTER_OPTIONS, upper=True),
cv.Optional(CONF_HEATER):
cv.Any(
None,
cv.All(
cv.Schema({
cv.Optional(CONF_TEMPERATURE, default=320):
cv.int_range(min=200, max=400),
cv.Optional(CONF_DURATION, default="150ms"):
cv.All(
cv.positive_time_period_milliseconds,
cv.Range(max=core.TimePeriod(milliseconds=4032)),
),
}),
cv.has_at_least_one_key(CONF_TEMPERATURE, CONF_DURATION),
),
),
}).extend(cv.polling_component_schema("60s")).extend(
i2c.i2c_device_schema(0x76)))
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)
if CONF_TEMPERATURE in config:
from . import XiaomiRTCGQ02LM
DEPENDENCIES = ["xiaomi_rtcgq02lm"]
CONF_BUTTON = "button"
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.use_id(XiaomiRTCGQ02LM),
cv.Optional(CONF_MOTION):
binary_sensor.binary_sensor_schema(
device_class=DEVICE_CLASS_MOTION).extend({
cv.Optional(CONF_TIMEOUT, default="5s"):
cv.All(
cv.positive_time_period_milliseconds,
cv.Range(max=TimePeriod(milliseconds=65535)),
),
}),
cv.Optional(CONF_LIGHT):
binary_sensor.binary_sensor_schema(device_class=DEVICE_CLASS_LIGHT),
cv.Optional(CONF_BUTTON):
binary_sensor.binary_sensor_schema().extend({
cv.Optional(CONF_TIMEOUT, default="200ms"):
cv.All(
cv.positive_time_period_milliseconds,
cv.Range(max=TimePeriod(milliseconds=65535)),
),
}),
})
DEPENDENCIES = ['i2c']
CONF_CHANNEL_1 = 'channel_1'
CONF_CHANNEL_2 = 'channel_2'
CONF_CHANNEL_3 = 'channel_3'
ina3221_ns = cg.esphome_ns.namespace('ina3221')
INA3221Component = ina3221_ns.class_('INA3221Component', cg.PollingComponent, i2c.I2CDevice)
INA3221_CHANNEL_SCHEMA = cv.Schema({
cv.Optional(CONF_BUS_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2),
cv.Optional(CONF_SHUNT_VOLTAGE): sensor.sensor_schema(UNIT_VOLT, ICON_FLASH, 2),
cv.Optional(CONF_CURRENT): sensor.sensor_schema(UNIT_AMPERE, ICON_FLASH, 2),
cv.Optional(CONF_POWER): sensor.sensor_schema(UNIT_WATT, ICON_FLASH, 2),
cv.Optional(CONF_SHUNT_RESISTANCE, default=0.1): cv.All(cv.resistance,
cv.Range(min=0.0, max=32.0)),
})
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_id(INA3221Component),
cv.Optional(CONF_CHANNEL_1): INA3221_CHANNEL_SCHEMA,
cv.Optional(CONF_CHANNEL_2): INA3221_CHANNEL_SCHEMA,
cv.Optional(CONF_CHANNEL_3): INA3221_CHANNEL_SCHEMA,
}).extend(cv.polling_component_schema('60s')).extend(i2c.i2c_device_schema(0x40))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)
cv.Required(CONF_VSYNC_PIN): pins.input_pin,
cv.Required(CONF_HREF_PIN): pins.input_pin,
cv.Required(CONF_PIXEL_CLOCK_PIN): pins.input_pin,
cv.Required(CONF_EXTERNAL_CLOCK): cv.Schema({
cv.Required(CONF_PIN): pins.output_pin,
cv.Optional(CONF_FREQUENCY, default='20MHz'): cv.All(cv.frequency, cv.one_of(20e6, 10e6)),
}),
cv.Required(CONF_I2C_PINS): cv.Schema({
cv.Required(CONF_SDA): pins.output_pin,
cv.Required(CONF_SCL): pins.output_pin,
}),
cv.Optional(CONF_RESET_PIN): pins.output_pin,
cv.Optional(CONF_POWER_DOWN_PIN): pins.output_pin,
cv.Optional(CONF_MAX_FRAMERATE, default='10 fps'): cv.All(cv.framerate,
cv.Range(min=0, min_included=False,
max=60)),
cv.Optional(CONF_IDLE_FRAMERATE, default='0.1 fps'): cv.All(cv.framerate,
cv.Range(min=0, max=1)),
cv.Optional(CONF_RESOLUTION, default='640X480'): cv.enum(FRAME_SIZES, upper=True),
cv.Optional(CONF_JPEG_QUALITY, default=10): cv.int_range(min=10, max=63),
cv.Optional(CONF_CONTRAST, default=0): camera_range_param,
cv.Optional(CONF_BRIGHTNESS, default=0): camera_range_param,
cv.Optional(CONF_SATURATION, default=0): camera_range_param,
cv.Optional(CONF_VERTICAL_FLIP, default=True): cv.boolean,
cv.Optional(CONF_HORIZONTAL_MIRROR, default=True): cv.boolean,
cv.Optional(CONF_TEST_PATTERN, default=False): cv.boolean,
}).extend(cv.COMPONENT_SCHEMA)
SETTERS = {
CONF_DATA_PINS: 'set_data_pins',
CONF_VSYNC_PIN: 'set_vsync_pin',
CONF_ID,
CONF_LAMBDA,
CONF_INTENSITY,
)
CODEOWNERS = ["@glmnet"]
tm1637_ns = cg.esphome_ns.namespace("tm1637")
TM1637Display = tm1637_ns.class_("TM1637Display", cg.PollingComponent)
TM1637DisplayRef = TM1637Display.operator("ref")
CONFIG_SCHEMA = display.BASIC_DISPLAY_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(TM1637Display),
cv.Optional(CONF_INTENSITY, default=7): cv.All(
cv.uint8_t, cv.Range(min=0, max=7)
),
cv.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema,
cv.Required(CONF_DIO_PIN): pins.gpio_output_pin_schema,
}
).extend(cv.polling_component_schema("1s"))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield display.register_display(var, config)
clk = yield cg.gpio_pin_expression(config[CONF_CLK_PIN])
cg.add(var.set_clk_pin(clk))
dio = yield cg.gpio_pin_expression(config[CONF_DIO_PIN])
@register_addressable_effect(
"addressable_color_wipe",
AddressableColorWipeEffect,
"Color Wipe",
{
cv.Optional(
CONF_COLORS, default=[{CONF_NUM_LEDS: 1, CONF_RANDOM: True}]
): cv.ensure_list(
{
cv.Optional(CONF_RED, default=1.0): cv.percentage,
cv.Optional(CONF_GREEN, default=1.0): cv.percentage,
cv.Optional(CONF_BLUE, default=1.0): cv.percentage,
cv.Optional(CONF_WHITE, default=1.0): cv.percentage,
cv.Optional(CONF_RANDOM, default=False): cv.boolean,
cv.Required(CONF_NUM_LEDS): cv.All(cv.uint32_t, cv.Range(min=1)),
}
),
cv.Optional(
CONF_ADD_LED_INTERVAL, default="0.1s"
): cv.positive_time_period_milliseconds,
cv.Optional(CONF_REVERSE, default=False): cv.boolean,
},
)
async def addressable_color_wipe_effect_to_code(config, effect_id):
var = cg.new_Pvariable(effect_id, config[CONF_NAME])
cg.add(var.set_add_led_interval(config[CONF_ADD_LED_INTERVAL]))
cg.add(var.set_reverse(config[CONF_REVERSE]))
colors = []
for color in config.get(CONF_COLORS, []):
colors.append(
cv.All(pins.internal_gpio_input_pullup_pin_schema,
pins.validate_has_interrupt),
cv.Optional(CONF_VOLTAGE):
sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 1, DEVICE_CLASS_VOLTAGE),
cv.Optional(CONF_CURRENT):
sensor.sensor_schema(UNIT_AMPERE, ICON_EMPTY, 2, DEVICE_CLASS_CURRENT),
cv.Optional(CONF_POWER):
sensor.sensor_schema(UNIT_WATT, ICON_EMPTY, 1, DEVICE_CLASS_POWER),
cv.Optional(CONF_ENERGY):
sensor.sensor_schema(UNIT_WATT_HOURS, ICON_EMPTY, 1, DEVICE_CLASS_ENERGY),
cv.Optional(CONF_CURRENT_RESISTOR, default=0.001):
cv.resistance,
cv.Optional(CONF_VOLTAGE_DIVIDER, default=2351):
cv.positive_float,
cv.Optional(CONF_CHANGE_MODE_EVERY, default=8):
cv.All(cv.uint32_t, cv.Range(min=1)),
cv.Optional(CONF_INITIAL_MODE, default=CONF_VOLTAGE):
cv.one_of(*INITIAL_MODES, lower=True),
}).extend(cv.polling_component_schema("60s"))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
sel = yield cg.gpio_pin_expression(config[CONF_SEL_PIN])
cg.add(var.set_sel_pin(sel))
cf = yield cg.gpio_pin_expression(config[CONF_CF_PIN])
cg.add(var.set_cf_pin(cf))
cf1 = yield cg.gpio_pin_expression(config[CONF_CF1_PIN])
cg.add(var.set_cf1_pin(cf1))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c
from esphome.const import CONF_FREQUENCY, CONF_ID
DEPENDENCIES = ["i2c"]
MULTI_CONF = True
pca9685_ns = cg.esphome_ns.namespace("pca9685")
PCA9685Output = pca9685_ns.class_("PCA9685Output", cg.Component, i2c.I2CDevice)
CONFIG_SCHEMA = (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(PCA9685Output),
cv.Required(CONF_FREQUENCY): cv.All(
cv.frequency, cv.Range(min=23.84, max=1525.88)
),
}
)
.extend(cv.COMPONENT_SCHEMA)
.extend(i2c.i2c_device_schema(0x40))
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID], config[CONF_FREQUENCY])
await cg.register_component(var, config)
await i2c.register_i2c_device(var, config)
)
return value
CONFIG_SCHEMA = cv.All(
display.FULL_DISPLAY_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(WaveshareEPaper),
cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
cv.Required(CONF_MODEL): cv.one_of(*MODELS, lower=True),
cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_BUSY_PIN): pins.gpio_input_pin_schema,
cv.Optional(CONF_FULL_UPDATE_EVERY): cv.uint32_t,
cv.Optional(CONF_RESET_DURATION): cv.All(
cv.positive_time_period_milliseconds,
cv.Range(max=core.TimePeriod(milliseconds=500)),
),
}
)
.extend(cv.polling_component_schema("1s"))
.extend(spi.spi_device_schema()),
validate_full_update_every_only_type_a,
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
)
async def to_code(config):
model_type, model = MODELS[config[CONF_MODEL]]
if model_type == "a":
rhs = WaveshareEPaperTypeA.new(model)
var = cg.Pvariable(config[CONF_ID], rhs, WaveshareEPaperTypeA)
CONF_ID,
CONF_LAMBDA,
CONF_INTENSITY,
)
CODEOWNERS = ["@glmnet"]
tm1637_ns = cg.esphome_ns.namespace("tm1637")
TM1637Display = tm1637_ns.class_("TM1637Display", cg.PollingComponent)
TM1637DisplayRef = TM1637Display.operator("ref")
CONFIG_SCHEMA = display.BASIC_DISPLAY_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(TM1637Display),
cv.Optional(CONF_INTENSITY, default=7):
cv.All(cv.uint8_t, cv.Range(min=0, max=7)),
cv.Required(CONF_CLK_PIN):
pins.gpio_output_pin_schema,
cv.Required(CONF_DIO_PIN):
pins.gpio_output_pin_schema,
}).extend(cv.polling_component_schema("1s"))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await display.register_display(var, config)
clk = await cg.gpio_pin_expression(config[CONF_CLK_PIN])
cg.add(var.set_clk_pin(clk))
dio = await cg.gpio_pin_expression(config[CONF_DIO_PIN])
ESP_PLATFORMS = [ESP_PLATFORM_ESP8266]
def valid_pwm_pin(value):
num = value[CONF_NUMBER]
cv.one_of(0, 1, 2, 3, 4, 5, 9, 10, 12, 13, 14, 15, 16)(num)
return value
esp8266_pwm_ns = cg.esphome_ns.namespace('esp8266_pwm')
ESP8266PWM = esp8266_pwm_ns.class_('ESP8266PWM', output.FloatOutput,
cg.Component)
SetFrequencyAction = esp8266_pwm_ns.class_('SetFrequencyAction',
automation.Action)
validate_frequency = cv.All(cv.frequency, cv.Range(min=1.0e-6))
CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend({
cv.Required(CONF_ID):
cv.declare_id(ESP8266PWM),
cv.Required(CONF_PIN):
cv.All(pins.internal_gpio_output_pin_schema, valid_pwm_pin),
cv.Optional(CONF_FREQUENCY, default='1kHz'):
validate_frequency,
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield output.register_output(var, config)
max31865_ns = cg.esphome_ns.namespace('max31865')
MAX31865Sensor = max31865_ns.class_('MAX31865Sensor', sensor.Sensor,
cg.PollingComponent, spi.SPIDevice)
MAX31865ConfigFilter = max31865_ns.enum('MAX31865ConfigFilter')
FILTER = {
'50HZ': MAX31865ConfigFilter.FILTER_50HZ,
'60HZ': MAX31865ConfigFilter.FILTER_60HZ,
}
CONFIG_SCHEMA = sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 2).extend(
{
cv.GenerateID():
cv.declare_id(MAX31865Sensor),
cv.Required(CONF_REFERENCE_RESISTANCE):
cv.All(cv.resistance, cv.Range(min=100, max=10000)),
cv.Required(CONF_RTD_NOMINAL_RESISTANCE):
cv.All(cv.resistance, cv.Range(min=100, max=1000)),
cv.Optional(CONF_MAINS_FILTER, default='60HZ'):
cv.enum(FILTER, upper=True, space=''),
cv.Optional(CONF_RTD_WIRES, default=4):
cv.int_range(min=2, max=4),
}).extend(cv.polling_component_schema('60s')).extend(
spi.spi_device_schema())
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield spi.register_spi_device(var, config)
yield sensor.register_sensor(var, config)
cv.Required(CONF_PIN):
pins.output_pin,
cv.Optional(CONF_FREQUENCY, default="20MHz"):
cv.All(cv.frequency, cv.one_of(20e6, 10e6)),
}),
cv.Required(CONF_I2C_PINS):
cv.Schema({
cv.Required(CONF_SDA): pins.output_pin,
cv.Required(CONF_SCL): pins.output_pin,
}),
cv.Optional(CONF_RESET_PIN):
pins.output_pin,
cv.Optional(CONF_POWER_DOWN_PIN):
pins.output_pin,
cv.Optional(CONF_MAX_FRAMERATE, default="10 fps"):
cv.All(cv.framerate, cv.Range(min=0, min_included=False, max=60)),
cv.Optional(CONF_IDLE_FRAMERATE, default="0.1 fps"):
cv.All(cv.framerate, cv.Range(min=0, max=1)),
cv.Optional(CONF_RESOLUTION, default="640X480"):
cv.enum(FRAME_SIZES, upper=True),
cv.Optional(CONF_JPEG_QUALITY, default=10):
cv.int_range(min=10, max=63),
cv.Optional(CONF_CONTRAST, default=0):
camera_range_param,
cv.Optional(CONF_BRIGHTNESS, default=0):
camera_range_param,
cv.Optional(CONF_SATURATION, default=0):
camera_range_param,
cv.Optional(CONF_VERTICAL_FLIP, default=True):
cv.boolean,
cv.Optional(CONF_HORIZONTAL_MIRROR, default=True):
if cg.is_template(code_):
template_ = await cg.templatable(code_, args, cg.std_vector.template(cg.int32))
cg.add(var.set_code_template(template_))
else:
code_ = config[CONF_CODE]
arr = cg.progmem_array(config[CONF_CODE_STORAGE_ID], code_)
cg.add(var.set_code_static(arr, len(code_)))
templ = await cg.templatable(config[CONF_CARRIER_FREQUENCY], args, cg.uint32)
cg.add(var.set_carrier_frequency(templ))
# RC5
RC5Data, RC5BinarySensor, RC5Trigger, RC5Action, RC5Dumper = declare_protocol("RC5")
RC5_SCHEMA = cv.Schema(
{
cv.Required(CONF_ADDRESS): cv.All(cv.hex_int, cv.Range(min=0, max=0x1F)),
cv.Required(CONF_COMMAND): cv.All(cv.hex_int, cv.Range(min=0, max=0x7F)),
}
)
@register_binary_sensor("rc5", RC5BinarySensor, RC5_SCHEMA)
def rc5_binary_sensor(var, config):
cg.add(
var.set_data(
cg.StructInitializer(
RC5Data,
("address", config[CONF_ADDRESS]),
("command", config[CONF_COMMAND]),
)
)
pins.internal_gpio_pin_number({CONF_OUTPUT: True}),
)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
_bus_declare_type,
cv.Optional(CONF_SDA, default="SDA"):
pin_with_input_and_output_support,
cv.SplitDefault(CONF_SDA_PULLUP_ENABLED, esp32_idf=True):
cv.All(cv.only_with_esp_idf, cv.boolean),
cv.Optional(CONF_SCL, default="SCL"):
pin_with_input_and_output_support,
cv.SplitDefault(CONF_SCL_PULLUP_ENABLED, esp32_idf=True):
cv.All(cv.only_with_esp_idf, cv.boolean),
cv.Optional(CONF_FREQUENCY, default="50kHz"):
cv.All(cv.frequency, cv.Range(min=0, min_included=False)),
cv.Optional(CONF_SCAN, default=True):
cv.boolean,
}).extend(cv.COMPONENT_SCHEMA)
@coroutine_with_priority(1.0)
async def to_code(config):
cg.add_global(i2c_ns.using)
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
cg.add(var.set_sda_pin(config[CONF_SDA]))
if CONF_SDA_PULLUP_ENABLED in config:
cg.add(var.set_sda_pullup_enabled(config[CONF_SDA_PULLUP_ENABLED]))
cg.add(var.set_scl_pin(config[CONF_SCL]))
cv.Optional(CONF_CURRENT):
sensor.sensor_schema(
unit_of_measurement=UNIT_AMPERE,
accuracy_decimals=3,
device_class=DEVICE_CLASS_CURRENT,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_POWER):
sensor.sensor_schema(
unit_of_measurement=UNIT_WATT,
accuracy_decimals=2,
device_class=DEVICE_CLASS_POWER,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_SHUNT_RESISTANCE, default=0.1):
cv.All(cv.resistance, cv.Range(min=0.0)),
cv.Optional(CONF_MAX_CURRENT, default=3.2):
cv.All(cv.current, cv.Range(min=0.0)),
}).extend(cv.polling_component_schema("60s")).extend(
i2c.i2c_device_schema(0x40)))
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)
cg.add(var.set_shunt_resistance_ohm(config[CONF_SHUNT_RESISTANCE]))
cg.add(var.set_max_current_a(config[CONF_MAX_CURRENT]))
),
cv.Optional(CONF_AUTOMATIC_SELF_CALIBRATION, default=True):
cv.boolean,
cv.Optional(CONF_ALTITUDE_COMPENSATION):
cv.All(
cv.float_with_unit("altitude", "(m|m a.s.l.|MAMSL|MASL)"),
cv.int_range(min=0, max=0xFFFF, max_included=False),
),
cv.Optional(CONF_AMBIENT_PRESSURE_COMPENSATION, default=0):
cv.pressure,
cv.Optional(CONF_TEMPERATURE_OFFSET):
cv.temperature,
cv.Optional(CONF_UPDATE_INTERVAL, default="60s"):
cv.All(
cv.positive_time_period_seconds,
cv.Range(min=core.TimePeriod(seconds=1),
max=core.TimePeriod(seconds=1800)),
),
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x61)))
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)
cg.add(
var.set_automatic_self_calibration(
config[CONF_AUTOMATIC_SELF_CALIBRATION]))
if CONF_ALTITUDE_COMPENSATION in config:
cg.add(
var.set_altitude_compensation(config[CONF_ALTITUDE_COMPENSATION]))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import pins
from esphome.components import remote_base
from esphome.const import CONF_CARRIER_DUTY_PERCENT, CONF_ID, CONF_PIN
AUTO_LOAD = ["remote_base"]
remote_transmitter_ns = cg.esphome_ns.namespace("remote_transmitter")
RemoteTransmitterComponent = remote_transmitter_ns.class_(
"RemoteTransmitterComponent", remote_base.RemoteTransmitterBase,
cg.Component)
MULTI_CONF = True
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(RemoteTransmitterComponent),
cv.Required(CONF_PIN):
pins.gpio_output_pin_schema,
cv.Required(CONF_CARRIER_DUTY_PERCENT):
cv.All(cv.percentage_int, cv.Range(min=1, max=100)),
}).extend(cv.COMPONENT_SCHEMA)
def to_code(config):
pin = yield cg.gpio_pin_expression(config[CONF_PIN])
var = cg.new_Pvariable(config[CONF_ID], pin)
yield cg.register_component(var, config)
cg.add(var.set_carrier_duty_percent(config[CONF_CARRIER_DUTY_PERCENT]))
ble_client.BLEClientNode)
PVVXDisplayRef = PVVXDisplay.operator("ref")
CONFIG_SCHEMA = (display.BASIC_DISPLAY_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(PVVXDisplay),
cv.Optional(CONF_TIME_ID):
cv.use_id(time.RealTimeClock),
cv.Optional(CONF_AUTO_CLEAR_ENABLED, default=True):
cv.boolean,
cv.Optional(CONF_DISCONNECT_DELAY, default="5s"):
cv.positive_time_period,
cv.Optional(CONF_VALIDITY_PERIOD, default="5min"):
cv.All(
cv.positive_time_period_seconds,
cv.Range(max=cv.TimePeriod(seconds=65535)),
),
}).extend(ble_client.BLE_CLIENT_SCHEMA).extend(
cv.polling_component_schema("60s")))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await display.register_display(var, config)
await ble_client.register_ble_node(var, config)
cg.add(
var.set_disconnect_delay(
config[CONF_DISCONNECT_DELAY].total_milliseconds))
cg.add(var.set_auto_clear(config[CONF_AUTO_CLEAR_ENABLED]))
cg.add(var.set_validity_period(config[CONF_VALIDITY_PERIOD].total_seconds))