from . import cpp_types as t
def maybe_simple_value_or_default(*validators, **kwargs):
key = kwargs.pop('key', ehc.CONF_VALUE)
validator = cv.All(*validators)
def validate(value):
if isinstance(value, dict):
return validator(value)
return validator({key: value})
return validate
@automation.register_action(c.ACTION_ABORT, t.TerminalAction, cv.All({}))
@coroutine
def abort_action_to_code(config, action_id, template_arg, args):
text = "sendaction->stop(); return true;"
lambda_ = yield cg.process_lambda(Lambda(text), args, return_type=cg.bool_)
yield cg.new_Pvariable(action_id, template_arg, lambda_)
@automation.register_action(c.ACTION_RETRY_SEND, t.TerminalAction,
maybe_simple_value_or_default(
cv.Schema({
cv.Optional(c.CONF_MAX_RETRIES, default=2):
cv.int_,
}),
key=c.CONF_MAX_RETRIES))
@coroutine
cv.declare_id(Sensor),
cv.Optional(CONF_UNIT_OF_MEASUREMENT):
unit_of_measurement,
cv.Optional(CONF_ICON):
icon,
cv.Optional(CONF_ACCURACY_DECIMALS):
accuracy_decimals,
cv.Optional(CONF_DEVICE_CLASS):
device_class,
cv.Optional(CONF_STATE_CLASS):
validate_state_class,
cv.Optional(CONF_FORCE_UPDATE, default=False):
cv.boolean,
cv.Optional(CONF_EXPIRE_AFTER):
cv.All(
cv.requires_component("mqtt"),
cv.Any(None, cv.positive_time_period_milliseconds),
),
cv.Optional(CONF_FILTERS):
validate_filters,
cv.Optional(CONF_ON_VALUE):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(SensorStateTrigger),
}),
cv.Optional(CONF_ON_RAW_VALUE):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(SensorRawStateTrigger),
}),
cv.Optional(CONF_ON_VALUE_RANGE):
automation.validate_automation(
)
return config
CONFIG_SCHEMA = cv.All(
sensor.sensor_schema(accuracy_decimals=2, ).extend({
cv.GenerateID():
cv.declare_id(NextionSensor),
cv.Optional(CONF_PRECISION, default=0):
cv.int_range(min=0, max=8),
cv.Optional(CONF_WAVE_CHANNEL_ID):
CheckWaveID,
cv.Optional(CONF_COMPONENT_ID):
cv.uint8_t,
cv.Optional(CONF_WAVE_MAX_LENGTH, default=255):
cv.int_range(min=1, max=1024),
cv.Optional(CONF_WAVE_MAX_VALUE, default=100):
cv.int_range(min=1, max=1024),
cv.Optional(CONF_WAVEFORM_SEND_LAST_VALUE, default=True):
cv.boolean,
}).extend(CONFIG_SENSOR_COMPONENT_SCHEMA).extend(
cv.polling_component_schema("never")),
cv.has_exactly_one_key(CONF_COMPONENT_ID, CONF_COMPONENT_NAME,
CONF_VARIABLE_NAME),
_validate,
)
async def to_code(config):
hub = await cg.get_variable(config[CONF_NEXTION_ID])
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_EMPTY, 2, DEVICE_CLASS_TEMPERATURE,
STATE_CLASS_MEASUREMENT).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()))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await spi.register_spi_device(var, config)
await sensor.register_sensor(var, config)
# Copy over all fields to subfolder:
trace = {}
for f in fields:
if f in config:
trace[f] = config.pop(f)
config[subfolder] = cv.ensure_list(subschema)(trace)
return config
def _relocate_trace(config):
return _relocate_fields_to_subfolder(config, CONF_TRACES,
GRAPH_TRACE_SCHEMA)
CONFIG_SCHEMA = cv.All(
GRAPH_SCHEMA,
_relocate_trace,
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
cg.add(var.set_duration(config[CONF_DURATION]))
cg.add(var.set_width(config[CONF_WIDTH]))
cg.add(var.set_height(config[CONF_HEIGHT]))
await cg.register_component(var, config)
# Graph options
if CONF_X_GRID in config:
cg.add(var.set_grid_x(config[CONF_X_GRID]))
if CONF_Y_GRID in config:
cg.add(var.set_grid_y(config[CONF_Y_GRID]))
CONF_RESET_PIN, CONF_CS_PIN, CONF_CONTRAST)
DEPENDENCIES = ['spi']
pcd8544_ns = cg.esphome_ns.namespace('pcd8544')
PCD8544 = pcd8544_ns.class_('PCD8544', cg.PollingComponent,
display.DisplayBuffer, spi.SPIDevice)
CONFIG_SCHEMA = cv.All(
display.FULL_DISPLAY_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(PCD8544),
cv.Required(CONF_DC_PIN):
pins.gpio_output_pin_schema,
cv.Required(CONF_RESET_PIN):
pins.gpio_output_pin_schema,
cv.Required(CONF_CS_PIN):
pins.gpio_output_pin_schema, # CE
cv.Optional(CONF_CONTRAST, default=0x7f):
cv.int_,
}).extend(cv.polling_component_schema('1s')).extend(
spi.spi_device_schema()),
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield display.register_display(var, config)
yield spi.register_spi_device(var, config)
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import pins
from esphome.components import spi, st7735_base
from esphome.const import CONF_DC_PIN, CONF_ID, CONF_LAMBDA, CONF_PAGES
AUTO_LOAD = ['st7735_base']
DEPENDENCIES = ['spi']
st7735_spi = cg.esphome_ns.namespace('st7735_spi')
SPIST7735 = st7735_spi.class_('SPIST7735', st7735_base.ST7735, spi.SPIDevice)
CONFIG_SCHEMA = cv.All(
st7735_base.ST7735_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(SPIST7735),
cv.Required(CONF_DC_PIN):
pins.gpio_output_pin_schema,
}).extend(cv.COMPONENT_SCHEMA).extend(spi.spi_device_schema()),
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield st7735_base.setup_st7735(var, config)
yield spi.register_spi_device(var, config)
dc = yield cg.gpio_pin_expression(config[CONF_DC_PIN])
cg.add(var.set_dc_pin(dc))
CONF_SPEED_DATAPOINT = "speed_datapoint"
CONF_OSCILLATION_DATAPOINT = "oscillation_datapoint"
CONF_DIRECTION_DATAPOINT = "direction_datapoint"
TuyaFan = tuya_ns.class_("TuyaFan", cg.Component)
CONFIG_SCHEMA = cv.All(
fan.FAN_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID):
cv.declare_id(TuyaFan),
cv.GenerateID(CONF_TUYA_ID):
cv.use_id(Tuya),
cv.Optional(CONF_OSCILLATION_DATAPOINT):
cv.uint8_t,
cv.Optional(CONF_SPEED_DATAPOINT):
cv.uint8_t,
cv.Optional(CONF_SWITCH_DATAPOINT):
cv.uint8_t,
cv.Optional(CONF_DIRECTION_DATAPOINT):
cv.uint8_t,
cv.Optional(CONF_SPEED_COUNT, default=3):
cv.int_range(min=1, max=256),
}).extend(cv.COMPONENT_SCHEMA),
cv.has_at_least_one_key(CONF_SPEED_DATAPOINT, CONF_SWITCH_DATAPOINT),
)
def to_code(config):
parent = yield cg.get_variable(config[CONF_TUYA_ID])
state = yield fan.create_fan_state(config)
device_class=DEVICE_CLASS_TEMPERATURE,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(
unit_of_measurement=UNIT_PERCENT,
icon=ICON_WATER_PERCENT,
accuracy_decimals=2,
device_class=DEVICE_CLASS_HUMIDITY,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_AUTOMATIC_SELF_CALIBRATION, default=True):
cv.boolean,
cv.Optional(CONF_ALTITUDE_COMPENSATION, default="0m"):
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):
cv.pressure,
cv.Optional(CONF_TEMPERATURE_OFFSET, default="4°C"):
cv.temperature,
cv.Optional(CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE):
cv.use_id(sensor.Sensor),
}).extend(cv.polling_component_schema("60s")).extend(
i2c.i2c_device_schema(0x62)))
SENSOR_MAP = {
CONF_CO2: "set_co2_sensor",
CONF_TEMPERATURE: "set_temperature_sensor",
CONF_HUMIDITY: "set_humidity_sensor",
}
CONF_DRIVE_STRENGTH = "drive_strength"
ESP32_PIN_SCHEMA = cv.All(
{
cv.GenerateID():
_choose_pin_declaration,
cv.Required(CONF_NUMBER):
validate_gpio_pin,
cv.Optional(CONF_MODE, default={}):
cv.Schema({
cv.Optional(CONF_INPUT, default=False): cv.boolean,
cv.Optional(CONF_OUTPUT, default=False): cv.boolean,
cv.Optional(CONF_OPEN_DRAIN, default=False): cv.boolean,
cv.Optional(CONF_PULLUP, default=False): cv.boolean,
cv.Optional(CONF_PULLDOWN, default=False): cv.boolean,
}),
cv.Optional(CONF_INVERTED, default=False):
cv.boolean,
cv.SplitDefault(CONF_DRIVE_STRENGTH, esp32_idf="20mA"):
cv.All(
cv.only_with_esp_idf,
cv.float_with_unit("current", "mA", optional_unit=True),
cv.enum(DRIVE_STRENGTHS),
),
},
validate_supports,
)
@pins.PIN_SCHEMA_REGISTRY.register("esp32", ESP32_PIN_SCHEMA)
}
entry = {
cv.Required(CONF_BINARY_SENSOR): cv.use_id(binary_sensor.BinarySensor),
cv.Required(CONF_VALUE): cv.float_,
}
CONFIG_SCHEMA = cv.typed_schema(
{
CONF_GROUP:
sensor.sensor_schema(UNIT_EMPTY, ICON_CHECK_CIRCLE_OUTLINE, 0,
DEVICE_CLASS_EMPTY).extend({
cv.GenerateID():
cv.declare_id(BinarySensorMap),
cv.Required(CONF_CHANNELS):
cv.All(cv.ensure_list(entry),
cv.Length(min=1)),
}),
},
lower=True,
)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield sensor.register_sensor(var, config)
constant = SENSOR_MAP_TYPES[config[CONF_TYPE]]
cg.add(var.set_sensor_type(constant))
for ch in config[CONF_CHANNELS]:
cv.Optional(CONF_OVERSAMPLING, default="16X"):
cv.enum(OVERSAMPLING_OPTIONS, upper=True),
}),
cv.Optional(CONF_GAS_RESISTANCE):
sensor.sensor_schema(UNIT_OHM, ICON_GAS_CYLINDER, 1, DEVICE_CLASS_EMPTY),
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)))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)
config[CONF_USE_ADDRESS] = use_address
return config
CONF_OUTPUT_POWER = 'output_power'
CONFIG_SCHEMA = cv.All(cv.Schema({
cv.GenerateID(): cv.declare_id(WiFiComponent),
cv.Optional(CONF_NETWORKS): cv.ensure_list(WIFI_NETWORK_STA),
cv.Optional(CONF_SSID): cv.ssid,
cv.Optional(CONF_PASSWORD): validate_password,
cv.Optional(CONF_MANUAL_IP): STA_MANUAL_IP_SCHEMA,
cv.Optional(CONF_AP): WIFI_NETWORK_AP,
cv.Optional(CONF_DOMAIN, default='.local'): cv.domain_name,
cv.Optional(CONF_REBOOT_TIMEOUT, default='15min'): cv.positive_time_period_milliseconds,
cv.SplitDefault(CONF_POWER_SAVE_MODE, esp8266='none', esp32='light'):
cv.enum(WIFI_POWER_SAVE_MODES, upper=True),
cv.Optional(CONF_FAST_CONNECT, default=False): cv.boolean,
cv.Optional(CONF_USE_ADDRESS): cv.string_strict,
cv.SplitDefault(CONF_OUTPUT_POWER, esp8266=20.0): cv.All(
cv.decibel, cv.float_range(min=10.0, max=20.5)),
cv.Optional('hostname'): cv.invalid("The hostname option has been removed in 1.11.0"),
}), validate)
def safe_ip(ip):
if ip is None:
return IPAddress(0, 0, 0, 0)
return IPAddress(*ip.args)
"If you give clock_pin, you must also specify data_pin")
return config
raise cv.Invalid(
"Must specify at least one of 'pin' or 'clock_pin'+'data_pin'")
CONFIG_SCHEMA = cv.All(
light.ADDRESSABLE_LIGHT_SCHEMA.extend({
cv.GenerateID(CONF_OUTPUT_ID):
cv.declare_id(NeoPixelBusLightOutputBase),
cv.Optional(CONF_TYPE, default='GRB'):
validate_type,
cv.Optional(CONF_VARIANT, default='800KBPS'):
validate_variant,
cv.Optional(CONF_METHOD, default=None):
validate_method,
cv.Optional(CONF_PIN):
pins.output_pin,
cv.Optional(CONF_CLOCK_PIN):
pins.output_pin,
cv.Optional(CONF_DATA_PIN):
pins.output_pin,
cv.Required(CONF_NUM_LEDS):
cv.positive_not_null_int,
}).extend(cv.COMPONENT_SCHEMA), validate, validate_method_pin)
def to_code(config):
has_white = 'W' in config[CONF_TYPE]
template = cg.TemplateArguments(
getattr(cg.global_ns, format_method(config)))
raise cv.Invalid("Include has invalid file extension {} - valid extensions are {}"
"".format(ext, ', '.join(VALID_INCLUDE_EXTS)))
return value
CONFIG_SCHEMA = cv.Schema({
cv.Required(CONF_NAME): cv.valid_name,
cv.Required(CONF_PLATFORM): cv.one_of('ESP8266', 'ESP32', upper=True),
cv.Required(CONF_BOARD): validate_board,
cv.Optional(CONF_COMMENT): cv.string,
cv.Optional(CONF_ARDUINO_VERSION, default='recommended'): validate_arduino_version,
cv.Optional(CONF_BUILD_PATH, default=default_build_path): cv.string,
cv.Optional(CONF_PLATFORMIO_OPTIONS, default={}): cv.Schema({
cv.string_strict: cv.Any([cv.string], cv.string),
}),
cv.SplitDefault(CONF_ESP8266_RESTORE_FROM_FLASH, esp8266=False): cv.All(cv.only_on_esp8266,
cv.boolean),
cv.SplitDefault(CONF_BOARD_FLASH_MODE, esp8266='dout'): cv.one_of(*BUILD_FLASH_MODES,
lower=True),
cv.Optional(CONF_ON_BOOT): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(StartupTrigger),
cv.Optional(CONF_PRIORITY, default=600.0): cv.float_,
}),
cv.Optional(CONF_ON_SHUTDOWN): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(ShutdownTrigger),
}),
cv.Optional(CONF_ON_LOOP): automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(LoopTrigger),
}),
cv.Optional(CONF_INCLUDES, default=[]): cv.ensure_list(valid_include),
cv.Optional(CONF_LIBRARIES, default=[]): cv.ensure_list(cv.string_strict),
StateTrigger = climate_ns.class_("StateTrigger", automation.Trigger.template())
CLIMATE_SCHEMA = cv.ENTITY_BASE_SCHEMA.extend(
cv.MQTT_COMMAND_COMPONENT_SCHEMA).extend({
cv.GenerateID():
cv.declare_id(Climate),
cv.OnlyWith(CONF_MQTT_ID, "mqtt"):
cv.declare_id(mqtt.MQTTClimateComponent),
cv.Optional(CONF_VISUAL, default={}):
cv.Schema({
cv.Optional(CONF_MIN_TEMPERATURE): cv.temperature,
cv.Optional(CONF_MAX_TEMPERATURE): cv.temperature,
cv.Optional(CONF_TEMPERATURE_STEP): cv.temperature,
}),
cv.Optional(CONF_ACTION_STATE_TOPIC):
cv.All(cv.requires_component("mqtt"), cv.publish_topic),
cv.Optional(CONF_AWAY_COMMAND_TOPIC):
cv.All(cv.requires_component("mqtt"), cv.publish_topic),
cv.Optional(CONF_AWAY_STATE_TOPIC):
cv.All(cv.requires_component("mqtt"), cv.publish_topic),
cv.Optional(CONF_CURRENT_TEMPERATURE_STATE_TOPIC):
cv.All(cv.requires_component("mqtt"), cv.publish_topic),
cv.Optional(CONF_FAN_MODE_COMMAND_TOPIC):
cv.All(cv.requires_component("mqtt"), cv.publish_topic),
cv.Optional(CONF_FAN_MODE_STATE_TOPIC):
cv.All(cv.requires_component("mqtt"), cv.publish_topic),
cv.Optional(CONF_MODE_COMMAND_TOPIC):
cv.All(cv.requires_component("mqtt"), cv.publish_topic),
cv.Optional(CONF_MODE_STATE_TOPIC):
cv.All(cv.requires_component("mqtt"), cv.publish_topic),
cv.Optional(CONF_SWING_MODE_COMMAND_TOPIC):
CONF_VALUE_TYPE,
CONF_WRITE_LAMBDA,
)
DEPENDENCIES = ["modbus_controller"]
CODEOWNERS = ["@martgras"]
ModbusOutput = modbus_controller_ns.class_("ModbusOutput", cg.Component,
output.FloatOutput, SensorItem)
CONFIG_SCHEMA = cv.All(
output.FLOAT_OUTPUT_SCHEMA.extend(ModbusItemBaseSchema).extend({
cv.GenerateID():
cv.declare_id(ModbusOutput),
cv.Optional(CONF_WRITE_LAMBDA):
cv.returning_lambda,
cv.Optional(CONF_MULTIPLY, default=1.0):
cv.float_,
}),
validate_modbus_register,
)
async def to_code(config):
byte_offset, reg_count = modbus_calc_properties(config)
var = cg.new_Pvariable(
config[CONF_ID],
config[CONF_ADDRESS],
byte_offset,
config[CONF_VALUE_TYPE],
reg_count,
CODEOWNERS = ["@justfalter"]
addressable_light_ns = cg.esphome_ns.namespace("addressable_light")
AddressableLightDisplay = addressable_light_ns.class_(
"AddressableLightDisplay", display.DisplayBuffer, cg.PollingComponent)
CONFIG_SCHEMA = cv.All(
display.FULL_DISPLAY_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(AddressableLightDisplay),
cv.Required(CONF_ADDRESSABLE_LIGHT_ID):
cv.use_id(light.AddressableLightState),
cv.Required(CONF_WIDTH):
cv.positive_int,
cv.Required(CONF_HEIGHT):
cv.positive_int,
cv.Optional(CONF_UPDATE_INTERVAL, default="16ms"):
cv.positive_time_period_milliseconds,
cv.Optional(CONF_PIXEL_MAPPER):
cv.returning_lambda,
}),
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
wrapped_light = await cg.get_variable(config[CONF_ADDRESSABLE_LIGHT_ID])
cg.add(var.set_width(config[CONF_WIDTH]))
cg.add(var.set_height(config[CONF_HEIGHT]))
raise cv.Invalid(
"The 'full_update_every' option is only available for models "
"'1.54in', '1.54inV2', '2.13in', '2.90in', and '2.90inV2'.")
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,
}).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)
value[CONF_ID])
return value
CONFIG_SCHEMA = automation.validate_automation(
{
# Don't declare id as cv.declare_id yet, because the ID type
# dpeends on the mode. Will be checked later with assign_declare_id
cv.Required(CONF_ID):
cv.string_strict,
cv.Optional(CONF_MODE, default=CONF_SINGLE):
cv.one_of(*SCRIPT_MODES, lower=True),
cv.Optional(CONF_MAX_RUNS):
cv.positive_int,
},
extra_validators=cv.All(check_max_runs, assign_declare_id),
)
def to_code(config):
# Register all variables first, so that scripts can use other scripts
triggers = []
for conf in config:
trigger = cg.new_Pvariable(conf[CONF_ID])
# Add a human-readable name to the script
cg.add(trigger.set_name(conf[CONF_ID].id))
if CONF_MAX_RUNS in conf:
cg.add(trigger.set_max_runs(conf[CONF_MAX_RUNS]))
if conf[CONF_MODE] == CONF_QUEUED:
TM1651_BRIGHTNESS_OPTIONS = {
1: TM1651Display.TM1651_BRIGHTNESS_LOW,
2: TM1651Display.TM1651_BRIGHTNESS_MEDIUM,
3: TM1651Display.TM1651_BRIGHTNESS_HIGH
}
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(TM1651Display),
cv.Required(CONF_CLK_PIN):
pins.internal_gpio_output_pin_schema,
cv.Required(CONF_DIO_PIN):
pins.internal_gpio_output_pin_schema,
})
validate_level_percent = cv.All(cv.int_range(min=0, max=100))
validate_level = cv.All(cv.int_range(min=0, max=7))
validate_brightness = cv.enum(TM1651_BRIGHTNESS_OPTIONS, int=True)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
clk_pin = yield cg.gpio_pin_expression(config[CONF_CLK_PIN])
cg.add(var.set_clk_pin(clk_pin))
dio_pin = yield cg.gpio_pin_expression(config[CONF_DIO_PIN])
cg.add(var.set_dio_pin(dio_pin))
# https://platformio.org/lib/show/6865/TM1651
cg.add_library('6865', '1.0.1')
"U_QWORD": 4,
"U_QWORDU_R": 4,
"S_QWORD": 4,
"U_QWORD_R": 4,
"FP32": 2,
"FP32_R": 2,
}
MULTI_CONF = True
_LOGGER = logging.getLogger(__name__)
CONFIG_SCHEMA = cv.All(
cv.Schema({
cv.GenerateID():
cv.declare_id(ModbusController),
cv.Optional(CONF_COMMAND_THROTTLE, default="0ms"):
cv.positive_time_period_milliseconds,
}).extend(cv.polling_component_schema("60s")).extend(
modbus.modbus_device_schema(0x01)))
ModbusItemBaseSchema = cv.Schema(
{
cv.GenerateID(CONF_MODBUS_CONTROLLER_ID):
cv.use_id(ModbusController),
cv.Optional(CONF_ADDRESS):
cv.positive_int,
cv.Optional(CONF_CUSTOM_COMMAND):
cv.ensure_list(cv.hex_uint8_t),
cv.Exclusive(
CONF_OFFSET,
"offset",
),
cv.Optional(CONF_METHOD, default="right"):
cv.enum(TOTAL_DAILY_ENERGY_METHODS, lower=True),
}).extend(cv.COMPONENT_SCHEMA))
FINAL_VALIDATE_SCHEMA = cv.All(
cv.Schema(
{
cv.Required(CONF_ID): cv.use_id(TotalDailyEnergy),
cv.Optional(CONF_ICON): cv.icon,
cv.Optional(CONF_UNIT_OF_MEASUREMENT):
sensor.validate_unit_of_measurement,
cv.Optional(CONF_ACCURACY_DECIMALS):
sensor.validate_accuracy_decimals,
cv.Required(CONF_POWER_ID): cv.use_id(sensor.Sensor),
},
extra=cv.ALLOW_EXTRA,
),
inherit_property_from(CONF_ICON, CONF_POWER_ID),
inherit_property_from(CONF_UNIT_OF_MEASUREMENT,
CONF_POWER_ID,
transform=inherit_unit_of_measurement),
inherit_property_from(CONF_ACCURACY_DECIMALS,
CONF_POWER_ID,
transform=inherit_accuracy_decimals),
)
async def to_code(config):
var = await sensor.new_sensor(config)
await cg.register_component(var, config)
cv.All(
cv.ensure_list(
cv.Schema({
cv.Optional(CONF_STATE, default=True):
cv.boolean,
cv.Optional(CONF_BRIGHTNESS, default=1.0):
cv.percentage,
cv.Optional(CONF_COLOR_BRIGHTNESS, default=1.0):
cv.percentage,
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.Required(CONF_DURATION):
cv.positive_time_period_milliseconds,
}),
cv.has_at_least_one_key(
CONF_STATE,
CONF_BRIGHTNESS,
CONF_COLOR_BRIGHTNESS,
CONF_RED,
CONF_GREEN,
CONF_BLUE,
CONF_WHITE,
),
),
cv.Length(min=2),
),
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c, pn532
from esphome.const import CONF_ID
AUTO_LOAD = ["pn532"]
CODEOWNERS = ["@OttoWinter", "@jesserockz"]
DEPENDENCIES = ["i2c"]
pn532_i2c_ns = cg.esphome_ns.namespace("pn532_i2c")
PN532I2C = pn532_i2c_ns.class_("PN532I2C", pn532.PN532, i2c.I2CDevice)
CONFIG_SCHEMA = cv.All(
pn532.PN532_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(PN532I2C),
}).extend(i2c.i2c_device_schema(0x24)))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await pn532.setup_pn532(var, config)
await i2c.register_i2c_device(var, config)
CONF_OUTDOOR_TEMPERATURE = "outdoor_temperature"
CONF_POWER_USAGE = "power_usage"
CONF_HUMIDITY_SETPOINT = "humidity_setpoint"
midea_ac_ns = cg.esphome_ns.namespace("midea_ac")
MideaAC = midea_ac_ns.class_("MideaAC", climate.Climate, cg.Component)
CONFIG_SCHEMA = cv.All(
climate.CLIMATE_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(MideaAC),
cv.GenerateID(CONF_MIDEA_DONGLE_ID): cv.use_id(MideaDongle),
cv.Optional(CONF_BEEPER, default=False): cv.boolean,
cv.Optional(CONF_SWING_HORIZONTAL, default=False): cv.boolean,
cv.Optional(CONF_SWING_BOTH, default=False): cv.boolean,
cv.Optional(CONF_OUTDOOR_TEMPERATURE): sensor.sensor_schema(
UNIT_CELSIUS, ICON_THERMOMETER, 0, DEVICE_CLASS_TEMPERATURE
),
cv.Optional(CONF_POWER_USAGE): sensor.sensor_schema(
UNIT_WATT, ICON_POWER, 0, DEVICE_CLASS_POWER
),
cv.Optional(CONF_HUMIDITY_SETPOINT): sensor.sensor_schema(
UNIT_PERCENT, ICON_WATER_PERCENT, 0, DEVICE_CLASS_HUMIDITY
),
}
).extend(cv.COMPONENT_SCHEMA)
)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield climate.register_climate(var, config)
unit_of_measurement=UNIT_CELSIUS,
icon=ICON_THERMOMETER,
accuracy_decimals=2,
device_class=DEVICE_CLASS_TEMPERATURE,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
unit_of_measurement=UNIT_PERCENT,
icon=ICON_WATER_PERCENT,
accuracy_decimals=2,
device_class=DEVICE_CLASS_HUMIDITY,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_AUTOMATIC_SELF_CALIBRATION, default=True): cv.boolean,
cv.Optional(CONF_ALTITUDE_COMPENSATION, default="0m"): 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): cv.pressure,
cv.Optional(CONF_TEMPERATURE_OFFSET, default="4°C"): cv.temperature,
cv.Optional(CONF_AMBIENT_PRESSURE_COMPENSATION_SOURCE): cv.use_id(
sensor.Sensor
),
}
)
.extend(cv.polling_component_schema("60s"))
.extend(i2c.i2c_device_schema(0x62))
)
SENSOR_MAP = {
CONF_CO2: "set_co2_sensor",
CONF_TEMPERATURE: "set_temperature_sensor",
cg.PollingComponent,
ble_client.BLEClientNode,
)
BLETextSensorNotifyTrigger = ble_client_ns.class_(
"BLETextSensorNotifyTrigger", automation.Trigger.template(cg.std_string))
CONFIG_SCHEMA = cv.All(
text_sensor.TEXT_SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(BLETextSensor),
cv.Required(CONF_SERVICE_UUID):
esp32_ble_tracker.bt_uuid,
cv.Required(CONF_CHARACTERISTIC_UUID):
esp32_ble_tracker.bt_uuid,
cv.Optional(CONF_DESCRIPTOR_UUID):
esp32_ble_tracker.bt_uuid,
cv.Optional(CONF_NOTIFY, default=False):
cv.boolean,
cv.Optional(CONF_ON_NOTIFY):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(BLETextSensorNotifyTrigger),
}),
}).extend(cv.polling_component_schema("60s")).extend(
ble_client.BLE_CLIENT_SCHEMA))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
if len(config[CONF_SERVICE_UUID]) == len(
esp32_ble_tracker.bt_uuid16_format):
ST7735_MODEL = cv.enum(MODELS, upper=True, space="_")
ST7735_SCHEMA = display.FULL_DISPLAY_SCHEMA.extend({
cv.Required(CONF_MODEL):
ST7735_MODEL,
cv.Optional(CONF_RESET_PIN):
pins.gpio_output_pin_schema,
}).extend(cv.polling_component_schema("1s"))
CONFIG_SCHEMA = cv.All(
ST7735_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(SPIST7735),
cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
cv.Required(CONF_DEVICE_WIDTH): cv.int_,
cv.Required(CONF_DEVICE_HEIGHT): cv.int_,
cv.Required(CONF_COL_START): cv.int_,
cv.Required(CONF_ROW_START): cv.int_,
cv.Optional(CONF_EIGHT_BIT_COLOR, default=False): cv.boolean,
cv.Optional(CONF_USE_BGR, default=False): cv.boolean,
}).extend(cv.COMPONENT_SCHEMA).extend(spi.spi_device_schema()),
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
)
async def setup_st7735(var, config):
await cg.register_component(var, config)
await display.register_display(var, config)
if CONF_RESET_PIN in config:
reset = await cg.gpio_pin_expression(config[CONF_RESET_PIN])
cg.add(var.set_reset_pin(reset))
).extend({
cv.GenerateID():
cv.declare_id(PulseCounterSensor),
cv.Required(CONF_PIN):
validate_pulse_counter_pin,
cv.Optional(
CONF_COUNT_MODE,
default={
CONF_RISING_EDGE: "INCREMENT",
CONF_FALLING_EDGE: "DISABLE",
},
):
cv.All(
cv.Schema({
cv.Required(CONF_RISING_EDGE): COUNT_MODE_SCHEMA,
cv.Required(CONF_FALLING_EDGE): COUNT_MODE_SCHEMA,
}),
validate_count_mode,
),
cv.Optional(CONF_INTERNAL_FILTER, default="13us"):
validate_internal_filter,
cv.Optional(CONF_TOTAL):
sensor.sensor_schema(UNIT_PULSES, ICON_PULSE, 0, DEVICE_CLASS_EMPTY,
STATE_CLASS_NONE),
}).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 sensor.register_sensor(var, config)
