import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.const import CONF_ID
from esphome.components import Filesystem
AUTO_LOAD = ["Filesystem"]
CONFLICTS_WITH = ["SD"]
SD_MMC_FilesystemComponent = Filesystem.filesystem_ns.class_(
"SD_MMC_Filesystem", cg.Component)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID(CONF_ID):
cv.declare_id(SD_MMC_FilesystemComponent),
}).extend(cv.COMPONENT_SCHEMA))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
bmp085_ns = cg.esphome_ns.namespace("bmp085")
BMP085Component = bmp085_ns.class_("BMP085Component", cg.PollingComponent,
i2c.I2CDevice)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(BMP085Component),
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(
UNIT_CELSIUS,
ICON_EMPTY,
1,
DEVICE_CLASS_TEMPERATURE,
STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_PRESSURE):
sensor.sensor_schema(
UNIT_HECTOPASCAL,
ICON_EMPTY,
1,
DEVICE_CLASS_PRESSURE,
STATE_CLASS_MEASUREMENT,
),
}).extend(cv.polling_component_schema("60s")).extend(
i2c.i2c_device_schema(0x77)))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
IS_PLATFORM_COMPONENT = True
touchscreen_ns = cg.esphome_ns.namespace("touchscreen")
Touchscreen = touchscreen_ns.class_("Touchscreen")
TouchRotation = touchscreen_ns.enum("TouchRotation")
TouchPoint = touchscreen_ns.struct("TouchPoint")
TouchListener = touchscreen_ns.class_("TouchListener")
CONF_DISPLAY = "display"
CONF_TOUCHSCREEN_ID = "touchscreen_id"
TOUCHSCREEN_SCHEMA = cv.Schema({
cv.GenerateID(CONF_DISPLAY):
cv.use_id(display.DisplayBuffer),
cv.Optional(CONF_ON_TOUCH):
automation.validate_automation(single=True),
})
async def register_touchscreen(var, config):
disp = await cg.get_variable(config[CONF_DISPLAY])
cg.add(var.set_display(disp))
if CONF_ON_TOUCH in config:
await automation.build_automation(
var.get_touch_trigger(),
[(TouchPoint, "touch")],
config[CONF_ON_TOUCH],
)
"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",
mpu6050_ns = cg.esphome_ns.namespace('mpu6050')
MPU6050Component = mpu6050_ns.class_('MPU6050Component', cg.PollingComponent,
i2c.I2CDevice)
accel_schema = sensor.sensor_schema(UNIT_METER_PER_SECOND_SQUARED,
ICON_BRIEFCASE_DOWNLOAD, 2)
gyro_schema = sensor.sensor_schema(UNIT_DEGREE_PER_SECOND,
ICON_SCREEN_ROTATION, 2)
temperature_schema = sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_id(MPU6050Component),
cv.Optional(CONF_ACCEL_X): accel_schema,
cv.Optional(CONF_ACCEL_Y): accel_schema,
cv.Optional(CONF_ACCEL_Z): accel_schema,
cv.Optional(CONF_GYRO_X): gyro_schema,
cv.Optional(CONF_GYRO_Y): gyro_schema,
cv.Optional(CONF_GYRO_Z): gyro_schema,
cv.Optional(CONF_TEMPERATURE): temperature_schema,
}).extend(cv.polling_component_schema('60s')).extend(
i2c.i2c_device_schema(0x68))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)
for d in ['x', 'y', 'z']:
accel_key = f'accel_{d}'
if accel_key in config:
cv.Optional(
CONF_MIN_SAVE_INTERVAL, default="0s"
): cv.positive_time_period_milliseconds,
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.Required(CONF_POWER_ID): cv.use_id(sensor.Sensor),
},
extra=cv.ALLOW_EXTRA,
),
inherit_property_from(CONF_ICON, CONF_POWER_ID),
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await sensor.register_sensor(var, config)
sens = await cg.get_variable(config[CONF_POWER_ID])
cg.add(var.set_parent(sens))
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(FingerprintGrowComponent),
cv.Optional(CONF_SENSING_PIN):
pins.gpio_input_pin_schema,
cv.Optional(CONF_PASSWORD):
cv.uint32_t,
cv.Optional(CONF_NEW_PASSWORD):
cv.uint32_t,
cv.Optional(CONF_ON_FINGER_SCAN_MATCHED):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(FingerScanMatchedTrigger),
}),
cv.Optional(CONF_ON_FINGER_SCAN_UNMATCHED):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(FingerScanUnmatchedTrigger),
}),
cv.Optional(CONF_ON_ENROLLMENT_SCAN):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(EnrollmentScanTrigger),
}),
cv.Optional(CONF_ON_ENROLLMENT_DONE):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(EnrollmentDoneTrigger),
}),
cv.Optional(CONF_ON_ENROLLMENT_FAILED):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(EnrollmentFailedTrigger),
}),
}).extend(cv.polling_component_schema("500ms")).extend(
uart.UART_DEVICE_SCHEMA))
cv.Optional(CONF_SWING_HORIZONTAL_ACTION):
automation.validate_automation(single=True),
cv.Optional(CONF_SWING_OFF_ACTION):
automation.validate_automation(single=True),
cv.Optional(CONF_SWING_VERTICAL_ACTION):
automation.validate_automation(single=True),
cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH):
cv.temperature,
cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_LOW):
cv.temperature,
cv.Optional(CONF_HYSTERESIS, default=0.5):
cv.temperature,
cv.Optional(CONF_AWAY_CONFIG):
cv.Schema({
cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_HIGH):
cv.temperature,
cv.Optional(CONF_DEFAULT_TARGET_TEMPERATURE_LOW):
cv.temperature,
}),
}).extend(cv.COMPONENT_SCHEMA),
cv.has_at_least_one_key(CONF_COOL_ACTION, CONF_DRY_ACTION,
CONF_FAN_ONLY_ACTION, CONF_HEAT_ACTION),
validate_thermostat,
)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield climate.register_climate(var, config)
auto_mode_available = CONF_HEAT_ACTION in config and CONF_COOL_ACTION in config
DEPENDENCIES = ["i2c"]
bmp085_ns = cg.esphome_ns.namespace("bmp085")
BMP085Component = bmp085_ns.class_("BMP085Component", cg.PollingComponent,
i2c.I2CDevice)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(BMP085Component),
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(
unit_of_measurement=UNIT_CELSIUS,
accuracy_decimals=1,
device_class=DEVICE_CLASS_TEMPERATURE,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_PRESSURE):
sensor.sensor_schema(
unit_of_measurement=UNIT_HECTOPASCAL,
accuracy_decimals=1,
device_class=DEVICE_CLASS_PRESSURE,
state_class=STATE_CLASS_MEASUREMENT,
),
}).extend(cv.polling_component_schema("60s")).extend(
i2c.i2c_device_schema(0x77)))
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)
from esphome.const import CONF_FREQUENCY, CONF_ID, CONF_SCAN, CONF_SCL, CONF_SDA, CONF_ADDRESS, \
CONF_I2C_ID
from esphome.core import coroutine, coroutine_with_priority
CODEOWNERS = ['@esphome/core']
i2c_ns = cg.esphome_ns.namespace('i2c')
I2CComponent = i2c_ns.class_('I2CComponent', cg.Component)
I2CDevice = i2c_ns.class_('I2CDevice')
MULTI_CONF = True
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(I2CComponent),
cv.Optional(CONF_SDA, default='SDA'):
pins.input_pin,
cv.Optional(CONF_SCL, default='SCL'):
pins.input_pin,
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)
def to_code(config):
cg.add_global(i2c_ns.using)
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
cg.add(var.set_sda_pin(config[CONF_SDA]))
cg.add(var.set_scl_pin(config[CONF_SCL]))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import i2c, mcp23x17_base, mcp23xxx_base
from esphome.const import CONF_ID
AUTO_LOAD = ["mcp23x17_base"]
CODEOWNERS = ["@jesserockz"]
DEPENDENCIES = ["i2c"]
MULTI_CONF = True
mcp23017_ns = cg.esphome_ns.namespace("mcp23017")
MCP23017 = mcp23017_ns.class_("MCP23017", mcp23x17_base.MCP23X17Base,
i2c.I2CDevice)
CONFIG_SCHEMA = (cv.Schema({
cv.Required(CONF_ID): cv.declare_id(MCP23017),
}).extend(mcp23xxx_base.MCP23XXX_CONFIG_SCHEMA).extend(
i2c.i2c_device_schema(0x20)))
async def to_code(config):
var = await mcp23xxx_base.register_mcp23xxx(config)
await i2c.register_i2c_device(var, config)
raise cv.Invalid("WPA password must be at most 64 characters long")
return value
def validate_channel(value):
value = cv.positive_int(value)
if value < 1:
raise cv.Invalid("Minimum WiFi channel is 1")
if value > 14:
raise cv.Invalid("Maximum WiFi channel is 14")
return value
AP_MANUAL_IP_SCHEMA = cv.Schema({
cv.Required(CONF_STATIC_IP): cv.ipv4,
cv.Required(CONF_GATEWAY): cv.ipv4,
cv.Required(CONF_SUBNET): cv.ipv4,
})
STA_MANUAL_IP_SCHEMA = AP_MANUAL_IP_SCHEMA.extend({
cv.Optional(CONF_DNS1, default="0.0.0.0"):
cv.ipv4,
cv.Optional(CONF_DNS2, default="0.0.0.0"):
cv.ipv4,
})
WIFI_NETWORK_BASE = cv.Schema({
cv.GenerateID():
cv.declare_id(WiFiAP),
cv.Optional(CONF_SSID):
cv.ssid,
DEPENDENCIES = ["i2c"]
aht10_ns = cg.esphome_ns.namespace("aht10")
AHT10Component = aht10_ns.class_("AHT10Component", cg.PollingComponent, i2c.I2CDevice)
CONFIG_SCHEMA = (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(AHT10Component),
cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
unit_of_measurement=UNIT_CELSIUS,
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,
accuracy_decimals=2,
device_class=DEVICE_CLASS_HUMIDITY,
state_class=STATE_CLASS_MEASUREMENT,
),
}
)
.extend(cv.polling_component_schema("60s"))
.extend(i2c.i2c_device_schema(0x38))
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
}
validate_climate_swing_mode = cv.enum(CLIMATE_SWING_MODES, upper=True)
# Actions
ControlAction = climate_ns.class_("ControlAction", automation.Action)
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
),
CONFIG_SCHEMA = cv.All(
cv.Schema({
cv.GenerateID():
cv.declare_id(XPT2046Component),
cv.Optional(CONF_IRQ_PIN):
pins.gpio_input_pin_schema,
cv.Optional(CONF_CALIBRATION_X_MIN, default=0):
cv.int_range(min=0, max=4095),
cv.Optional(CONF_CALIBRATION_X_MAX, default=4095):
cv.int_range(min=0, max=4095),
cv.Optional(CONF_CALIBRATION_Y_MIN, default=0):
cv.int_range(min=0, max=4095),
cv.Optional(CONF_CALIBRATION_Y_MAX, default=4095):
cv.int_range(min=0, max=4095),
cv.Optional(CONF_DIMENSION_X, default=100):
cv.positive_not_null_int,
cv.Optional(CONF_DIMENSION_Y, default=100):
cv.positive_not_null_int,
cv.Optional(CONF_THRESHOLD, default=400):
cv.int_range(min=0, max=4095),
cv.Optional(CONF_REPORT_INTERVAL, default="never"):
report_interval,
cv.Optional(CONF_SWAP_X_Y, default=False):
cv.boolean,
cv.Optional(CONF_ON_STATE):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(XPT2046OnStateTrigger),
}),
}).extend(cv.polling_component_schema("50ms")).extend(
spi.spi_device_schema()),
validate_xpt2046,
CONFIG_SCHEMA = sensor.sensor_schema(
UNIT_PULSES_PER_MINUTE, ICON_PULSE, 2).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),
}).extend(cv.polling_component_schema('60s'))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield sensor.register_sensor(var, config)
pin = yield cg.gpio_pin_expression(config[CONF_PIN])
cg.add(var.set_pin(pin))
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(PZEMAC),
cv.Optional(CONF_VOLTAGE):
sensor.sensor_schema(
unit_of_measurement=UNIT_VOLT,
accuracy_decimals=1,
device_class=DEVICE_CLASS_VOLTAGE,
state_class=STATE_CLASS_MEASUREMENT,
),
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_ENERGY):
sensor.sensor_schema(
unit_of_measurement=UNIT_WATT_HOURS,
accuracy_decimals=0,
device_class=DEVICE_CLASS_ENERGY,
state_class=STATE_CLASS_TOTAL_INCREASING,
),
cv.Optional(CONF_FREQUENCY):
sensor.sensor_schema(
unit_of_measurement=UNIT_HERTZ,
icon=ICON_CURRENT_AC,
accuracy_decimals=1,
state_class=STATE_CLASS_MEASUREMENT,
),
cv.Optional(CONF_POWER_FACTOR):
sensor.sensor_schema(
accuracy_decimals=2,
device_class=DEVICE_CLASS_POWER_FACTOR,
state_class=STATE_CLASS_MEASUREMENT,
),
}).extend(cv.polling_component_schema("60s")).extend(
modbus.modbus_device_schema(0x01)))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import core, pins, automation
from esphome.automation import maybe_simple_id
from esphome.const import CONF_ID, CONF_ADDRESS, CONF_UPDATE_INTERVAL
from esphome.components import modbus
AUTO_LOAD = ['modbus', 'sensor']
genvex_ns = cg.esphome_ns.namespace('genvex')
Genvex = genvex_ns.class_('Genvex', cg.PollingComponent, modbus.ModbusDevice)
CONF_GENVEX_ID = 'genvex_id'
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_id(Genvex),
cv.Required(CONF_ADDRESS): cv.int_range(min=1, max=100),
}).extend(cv.polling_component_schema('60s')).extend(modbus.modbus_device_schema(0x01))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield modbus.register_modbus_device(var, config)
if CONF_ADDRESS in config:
cg.add(var.set_address(config[CONF_ADDRESS]))
if CONF_UPDATE_INTERVAL in config:
cg.add(var.set_update_interval(config[CONF_UPDATE_INTERVAL]))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome import automation
from esphome.automation import maybe_simple_id
from esphome.components import power_supply
from esphome.const import CONF_ID, CONF_INVERTED, CONF_LEVEL, CONF_MAX_POWER, \
CONF_MIN_POWER, CONF_POWER_SUPPLY
from esphome.core import CORE, coroutine
CODEOWNERS = ['@esphome/core']
IS_PLATFORM_COMPONENT = True
BINARY_OUTPUT_SCHEMA = cv.Schema({
cv.Optional(CONF_POWER_SUPPLY):
cv.use_id(power_supply.PowerSupply),
cv.Optional(CONF_INVERTED):
cv.boolean,
})
FLOAT_OUTPUT_SCHEMA = BINARY_OUTPUT_SCHEMA.extend({
cv.Optional(CONF_MAX_POWER):
cv.percentage,
cv.Optional(CONF_MIN_POWER):
cv.percentage,
})
output_ns = cg.esphome_ns.namespace('output')
BinaryOutput = output_ns.class_('BinaryOutput')
BinaryOutputPtr = BinaryOutput.operator('ptr')
FloatOutput = output_ns.class_('FloatOutput', BinaryOutput)
FloatOutputPtr = FloatOutput.operator('ptr')
from esphome.components import i2c, sensor
from esphome.const import CONF_ID,\
CONF_BATTERY_LEVEL, CONF_BRIGHTNESS, UNIT_PERCENT, ICON_BATTERY
DEPENDENCIES = ['i2c']
axp192_ns = cg.esphome_ns.namespace('axp192')
AXP192Component = axp192_ns.class_('AXP192Component', cg.PollingComponent,
i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(AXP192Component),
cv.Optional(CONF_BATTERY_LEVEL):
sensor.sensor_schema(UNIT_PERCENT, ICON_BATTERY, 1).extend({}),
cv.Optional(CONF_BRIGHTNESS, default=1.0):
cv.percentage,
}).extend(cv.polling_component_schema('60s')).extend(
i2c.i2c_device_schema(0x77))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield i2c.register_i2c_device(var, config)
if CONF_BATTERY_LEVEL in config:
conf = config[CONF_BATTERY_LEVEL]
sens = yield sensor.new_sensor(conf)
cg.add(var.set_batterylevel_sensor(sens))
'int[]': cg.std_vector.template(cg.int32),
'float[]': cg.std_vector.template(float),
'string[]': cg.std_vector.template(cg.std_string),
}
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(APIServer),
cv.Optional(CONF_PORT, default=6053):
cv.port,
cv.Optional(CONF_PASSWORD, default=''):
cv.string_strict,
cv.Optional(CONF_REBOOT_TIMEOUT, default='15min'):
cv.positive_time_period_milliseconds,
cv.Optional(CONF_SERVICES):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_id(UserServiceTrigger),
cv.Required(CONF_SERVICE):
cv.valid_name,
cv.Optional(CONF_VARIABLES, default={}):
cv.Schema({
cv.validate_id_name:
cv.one_of(*SERVICE_ARG_NATIVE_TYPES, lower=True),
}),
}),
}).extend(cv.COMPONENT_SCHEMA)
@coroutine_with_priority(40.0)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
field_strength_schema = sensor.sensor_schema(UNIT_MICROTESLA, ICON_MAGNET, 1,
DEVICE_CLASS_EMPTY)
heading_schema = sensor.sensor_schema(UNIT_DEGREES, ICON_SCREEN_ROTATION, 1,
DEVICE_CLASS_EMPTY)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(HMC5883LComponent),
cv.Optional(CONF_ADDRESS):
cv.i2c_address,
cv.Optional(CONF_OVERSAMPLING, default="1x"):
validate_enum(HMC5883LOversamplings, units="x"),
cv.Optional(CONF_RANGE, default="130µT"):
validate_enum(HMC5883L_RANGES, units=["uT", "µT"]),
cv.Optional(CONF_FIELD_STRENGTH_X):
field_strength_schema,
cv.Optional(CONF_FIELD_STRENGTH_Y):
field_strength_schema,
cv.Optional(CONF_FIELD_STRENGTH_Z):
field_strength_schema,
cv.Optional(CONF_HEADING):
heading_schema,
}).extend(cv.polling_component_schema("60s")).extend(
i2c.i2c_device_schema(0x1E)))
def auto_data_rate(config):
interval_sec = config[CONF_UPDATE_INTERVAL].seconds
interval_hz = 1.0 / interval_sec
for datarate in sorted(HMC5883LDatarates.keys()):
"16X": BMP280IIRFilter.BMP280_IIR_FILTER_16X,
}
BMP280Component = bmp280_ns.class_("BMP280Component", cg.PollingComponent,
i2c.I2CDevice)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(BMP280Component),
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(UNIT_CELSIUS, ICON_EMPTY, 1,
DEVICE_CLASS_TEMPERATURE).extend({
cv.Optional(CONF_OVERSAMPLING, default="16X"):
cv.enum(OVERSAMPLING_OPTIONS, upper=True),
}),
cv.Optional(CONF_PRESSURE):
sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_EMPTY, 1,
DEVICE_CLASS_PRESSURE).extend({
cv.Optional(CONF_OVERSAMPLING, default="16X"):
cv.enum(OVERSAMPLING_OPTIONS, upper=True),
}),
cv.Optional(CONF_IIR_FILTER, default="OFF"):
cv.enum(IIR_FILTER_OPTIONS, upper=True),
}).extend(cv.polling_component_schema("60s")).extend(
i2c.i2c_device_schema(0x77)))
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)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(BME680Component),
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
cv.Optional(CONF_OVERSAMPLING, default='16X'):
cv.enum(OVERSAMPLING_OPTIONS, upper=True),
}),
cv.Optional(CONF_PRESSURE):
sensor.sensor_schema(UNIT_HECTOPASCAL, ICON_GAUGE, 1).extend({
cv.Optional(CONF_OVERSAMPLING, default='16X'):
cv.enum(OVERSAMPLING_OPTIONS, upper=True),
}),
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(UNIT_PERCENT, ICON_WATER_PERCENT, 1).extend({
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),
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))
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(CONF_DSMR_ID):
cv.use_id(Dsmr),
cv.Optional("energy_delivered_lux"):
sensor.sensor_schema(
UNIT_KILOWATT_HOURS,
ICON_EMPTY,
3,
DEVICE_CLASS_ENERGY,
STATE_CLASS_TOTAL_INCREASING,
),
cv.Optional("energy_delivered_tariff1"):
sensor.sensor_schema(
UNIT_KILOWATT_HOURS,
ICON_EMPTY,
3,
DEVICE_CLASS_ENERGY,
STATE_CLASS_TOTAL_INCREASING,
),
cv.Optional("energy_delivered_tariff2"):
sensor.sensor_schema(
UNIT_KILOWATT_HOURS,
ICON_EMPTY,
3,
DEVICE_CLASS_ENERGY,
STATE_CLASS_TOTAL_INCREASING,
),
cv.Optional("energy_returned_lux"):
sensor.sensor_schema(
UNIT_KILOWATT_HOURS,
ICON_EMPTY,
3,
DEVICE_CLASS_ENERGY,
STATE_CLASS_TOTAL_INCREASING,
),
cv.Optional("energy_returned_tariff1"):
sensor.sensor_schema(
UNIT_KILOWATT_HOURS,
ICON_EMPTY,
3,
DEVICE_CLASS_ENERGY,
STATE_CLASS_TOTAL_INCREASING,
),
cv.Optional("energy_returned_tariff2"):
sensor.sensor_schema(
UNIT_KILOWATT_HOURS,
ICON_EMPTY,
3,
DEVICE_CLASS_ENERGY,
STATE_CLASS_TOTAL_INCREASING,
),
cv.Optional("total_imported_energy"):
sensor.sensor_schema(
UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
ICON_EMPTY,
3,
DEVICE_CLASS_EMPTY,
STATE_CLASS_NONE,
),
cv.Optional("total_exported_energy"):
sensor.sensor_schema(
UNIT_KILOVOLT_AMPS_REACTIVE_HOURS,
ICON_EMPTY,
3,
DEVICE_CLASS_EMPTY,
STATE_CLASS_NONE,
),
cv.Optional("power_delivered"):
sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER,
STATE_CLASS_MEASUREMENT),
cv.Optional("power_returned"):
sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER,
STATE_CLASS_MEASUREMENT),
cv.Optional("reactive_power_delivered"):
sensor.sensor_schema(
UNIT_KILOVOLT_AMPS_REACTIVE,
ICON_EMPTY,
3,
DEVICE_CLASS_POWER,
STATE_CLASS_MEASUREMENT,
),
cv.Optional("reactive_power_returned"):
sensor.sensor_schema(
UNIT_KILOVOLT_AMPS_REACTIVE,
ICON_EMPTY,
3,
DEVICE_CLASS_POWER,
STATE_CLASS_MEASUREMENT,
),
cv.Optional("electricity_threshold"):
sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 3, DEVICE_CLASS_EMPTY,
STATE_CLASS_NONE),
cv.Optional("electricity_switch_position"):
sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 3, DEVICE_CLASS_EMPTY,
STATE_CLASS_NONE),
cv.Optional("electricity_failures"):
sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY,
STATE_CLASS_NONE),
cv.Optional("electricity_long_failures"):
sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY,
STATE_CLASS_NONE),
cv.Optional("electricity_sags_l1"):
sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY,
STATE_CLASS_NONE),
cv.Optional("electricity_sags_l2"):
sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY,
STATE_CLASS_NONE),
cv.Optional("electricity_sags_l3"):
sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY,
STATE_CLASS_NONE),
cv.Optional("electricity_swells_l1"):
sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY,
STATE_CLASS_NONE),
cv.Optional("electricity_swells_l2"):
sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY,
STATE_CLASS_NONE),
cv.Optional("electricity_swells_l3"):
sensor.sensor_schema(UNIT_EMPTY, ICON_EMPTY, 0, DEVICE_CLASS_EMPTY,
STATE_CLASS_NONE),
cv.Optional("current_l1"):
sensor.sensor_schema(UNIT_AMPERE, ICON_EMPTY, 1, DEVICE_CLASS_CURRENT,
STATE_CLASS_MEASUREMENT),
cv.Optional("current_l2"):
sensor.sensor_schema(UNIT_AMPERE, ICON_EMPTY, 1, DEVICE_CLASS_CURRENT,
STATE_CLASS_MEASUREMENT),
cv.Optional("current_l3"):
sensor.sensor_schema(UNIT_AMPERE, ICON_EMPTY, 1, DEVICE_CLASS_CURRENT,
STATE_CLASS_MEASUREMENT),
cv.Optional("power_delivered_l1"):
sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER,
STATE_CLASS_MEASUREMENT),
cv.Optional("power_delivered_l2"):
sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER,
STATE_CLASS_MEASUREMENT),
cv.Optional("power_delivered_l3"):
sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER,
STATE_CLASS_MEASUREMENT),
cv.Optional("power_returned_l1"):
sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER,
STATE_CLASS_MEASUREMENT),
cv.Optional("power_returned_l2"):
sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER,
STATE_CLASS_MEASUREMENT),
cv.Optional("power_returned_l3"):
sensor.sensor_schema(UNIT_KILOWATT, ICON_EMPTY, 3, DEVICE_CLASS_POWER,
STATE_CLASS_MEASUREMENT),
cv.Optional("reactive_power_delivered_l1"):
sensor.sensor_schema(
UNIT_KILOVOLT_AMPS_REACTIVE,
ICON_EMPTY,
3,
DEVICE_CLASS_EMPTY,
STATE_CLASS_MEASUREMENT,
),
cv.Optional("reactive_power_delivered_l2"):
sensor.sensor_schema(
UNIT_KILOVOLT_AMPS_REACTIVE,
ICON_EMPTY,
3,
DEVICE_CLASS_EMPTY,
STATE_CLASS_MEASUREMENT,
),
cv.Optional("reactive_power_delivered_l3"):
sensor.sensor_schema(
UNIT_KILOVOLT_AMPS_REACTIVE,
ICON_EMPTY,
3,
DEVICE_CLASS_EMPTY,
STATE_CLASS_MEASUREMENT,
),
cv.Optional("reactive_power_returned_l1"):
sensor.sensor_schema(
UNIT_KILOVOLT_AMPS_REACTIVE,
ICON_EMPTY,
3,
DEVICE_CLASS_EMPTY,
STATE_CLASS_MEASUREMENT,
),
cv.Optional("reactive_power_returned_l2"):
sensor.sensor_schema(
UNIT_KILOVOLT_AMPS_REACTIVE,
ICON_EMPTY,
3,
DEVICE_CLASS_EMPTY,
STATE_CLASS_MEASUREMENT,
),
cv.Optional("reactive_power_returned_l3"):
sensor.sensor_schema(
UNIT_KILOVOLT_AMPS_REACTIVE,
ICON_EMPTY,
3,
DEVICE_CLASS_EMPTY,
STATE_CLASS_MEASUREMENT,
),
cv.Optional("voltage_l1"):
sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 1, DEVICE_CLASS_VOLTAGE,
STATE_CLASS_NONE),
cv.Optional("voltage_l2"):
sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 1, DEVICE_CLASS_VOLTAGE,
STATE_CLASS_NONE),
cv.Optional("voltage_l3"):
sensor.sensor_schema(UNIT_VOLT, ICON_EMPTY, 1, DEVICE_CLASS_VOLTAGE,
STATE_CLASS_NONE),
cv.Optional("gas_delivered"):
sensor.sensor_schema(
UNIT_CUBIC_METER,
ICON_EMPTY,
3,
DEVICE_CLASS_GAS,
STATE_CLASS_TOTAL_INCREASING,
),
cv.Optional("gas_delivered_be"):
sensor.sensor_schema(
UNIT_CUBIC_METER,
ICON_EMPTY,
3,
DEVICE_CLASS_GAS,
STATE_CLASS_TOTAL_INCREASING,
),
}).extend(cv.COMPONENT_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 text_sensor.register_text_sensor(var, config)
if CONF_LAMBDA in config:
template_ = await cg.process_lambda(config[CONF_LAMBDA], [],
return_type=cg.optional.template(
cg.std_string))
cg.add(var.set_template(template_))
@automation.register_action(
"text_sensor.template.publish",
TextSensorPublishAction,
cv.Schema({
cv.Required(CONF_ID): cv.use_id(text_sensor.TextSensor),
cv.Required(CONF_STATE): cv.templatable(cv.string_strict),
}),
)
async def text_sensor_template_publish_to_code(config, action_id, template_arg,
args):
paren = await cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
template_ = await cg.templatable(config[CONF_STATE], args, cg.std_string)
cg.add(var.set_state(template_))
return var
path=[CONF_BOARD],
)
value = value.copy()
value[CONF_VARIANT] = BOARD_TO_VARIANT[board]
return value
CONF_PLATFORM_VERSION = "platform_version"
ARDUINO_FRAMEWORK_SCHEMA = cv.All(
cv.Schema(
{
cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
cv.Optional(CONF_SOURCE): cv.string_strict,
cv.Optional(CONF_PLATFORM_VERSION): _parse_platform_version,
}
),
_arduino_check_versions,
)
CONF_SDKCONFIG_OPTIONS = "sdkconfig_options"
ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
cv.Schema(
{
cv.Optional(CONF_VERSION, default="recommended"): cv.string_strict,
cv.Optional(CONF_SOURCE): cv.string_strict,
cv.Optional(CONF_PLATFORM_VERSION): _parse_platform_version,
cv.Optional(CONF_SDKCONFIG_OPTIONS, default={}): {
cv.string_strict: cv.string_strict
DEPENDENCIES = ["esp32_ble_tracker"]
AUTO_LOAD = ["xiaomi_ble"]
xiaomi_lywsd02_ns = cg.esphome_ns.namespace("xiaomi_lywsd02")
XiaomiLYWSD02 = xiaomi_lywsd02_ns.class_("XiaomiLYWSD02",
esp32_ble_tracker.ESPBTDeviceListener,
cg.Component)
CONFIG_SCHEMA = (cv.Schema({
cv.GenerateID():
cv.declare_id(XiaomiLYWSD02),
cv.Required(CONF_MAC_ADDRESS):
cv.mac_address,
cv.Optional(CONF_TEMPERATURE):
sensor.sensor_schema(UNIT_CELSIUS, ICON_EMPTY, 1,
DEVICE_CLASS_TEMPERATURE),
cv.Optional(CONF_HUMIDITY):
sensor.sensor_schema(UNIT_PERCENT, ICON_EMPTY, 1, DEVICE_CLASS_HUMIDITY),
cv.Optional(CONF_BATTERY_LEVEL):
sensor.sensor_schema(UNIT_PERCENT, ICON_EMPTY, 0, DEVICE_CLASS_BATTERY),
}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await esp32_ble_tracker.register_ble_device(var, config)
cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
CONFIG_SCHEMA = cv.Schema(
{
cv.GenerateID(): cv.declare_id(OTAComponent),
cv.Optional(CONF_SAFE_MODE, default=True): cv.boolean,
cv.SplitDefault(CONF_PORT, esp8266=8266, esp32=3232): cv.port,
cv.Optional(CONF_PASSWORD, default=""): cv.string,
cv.Optional(
CONF_REBOOT_TIMEOUT, default="5min"
): cv.positive_time_period_milliseconds,
cv.Optional(CONF_NUM_ATTEMPTS, default="10"): cv.positive_not_null_int,
cv.Optional(CONF_ON_STATE_CHANGE): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OTAStateChangeTrigger),
}
),
cv.Optional(CONF_ON_BEGIN): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OTAStartTrigger),
}
),
cv.Optional(CONF_ON_ERROR): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OTAErrorTrigger),
}
),
cv.Optional(CONF_ON_PROGRESS): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OTAProgressTrigger),
}
),
cv.Optional(CONF_ON_END): automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(OTAEndTrigger),
}
),
}
).extend(cv.COMPONENT_SCHEMA)
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import binary_sensor
from esphome.const import CONF_BINARY_SENSORS, CONF_ID, CONF_LAMBDA
from .. import custom_ns
CustomBinarySensorConstructor = custom_ns.class_(
"CustomBinarySensorConstructor")
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_id(CustomBinarySensorConstructor),
cv.Required(CONF_LAMBDA):
cv.returning_lambda,
cv.Required(CONF_BINARY_SENSORS):
cv.ensure_list(binary_sensor.binary_sensor_schema()),
})
async def to_code(config):
template_ = await cg.process_lambda(
config[CONF_LAMBDA],
[],
return_type=cg.std_vector.template(binary_sensor.BinarySensorPtr),
)
rhs = CustomBinarySensorConstructor(template_)
custom = cg.variable(config[CONF_ID], rhs)
for i, conf in enumerate(config[CONF_BINARY_SENSORS]):
rhs = custom.Pget_binary_sensor(i)
await binary_sensor.register_binary_sensor(rhs, conf)
