binary_sensor.BinarySensor,
cg.Component,
esp32_ble_tracker.ESPBTDeviceListener,
)
CONFIG_SCHEMA = cv.All(
binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(BLEPresenceDevice),
cv.Optional(CONF_MAC_ADDRESS):
cv.mac_address,
cv.Optional(CONF_SERVICE_UUID):
esp32_ble_tracker.bt_uuid,
}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(
cv.COMPONENT_SCHEMA),
cv.has_exactly_one_key(CONF_MAC_ADDRESS, CONF_SERVICE_UUID),
)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield esp32_ble_tracker.register_ble_device(var, config)
yield binary_sensor.register_binary_sensor(var, config)
if CONF_MAC_ADDRESS in config:
cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
if CONF_SERVICE_UUID in config:
if len(config[CONF_SERVICE_UUID]) == len(
esp32_ble_tracker.bt_uuid16_format):
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import sensor
from esphome.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_RESOLUTION, UNIT_CELSIUS, \
ICON_THERMOMETER, CONF_ID
from . import DallasComponent, shelly_dallas_ns
DallasTemperatureSensor = shelly_dallas_ns.class_('DallasTemperatureSensor', sensor.Sensor)
CONFIG_SCHEMA = cv.All(sensor.sensor_schema(UNIT_CELSIUS, ICON_THERMOMETER, 1).extend({
cv.GenerateID(): cv.declare_id(DallasTemperatureSensor),
cv.GenerateID(CONF_DALLAS_ID): cv.use_id(DallasComponent),
cv.Optional(CONF_ADDRESS): cv.hex_int,
cv.Optional(CONF_INDEX): cv.positive_int,
cv.Optional(CONF_RESOLUTION, default=12): cv.int_range(min=9, max=12),
}), cv.has_exactly_one_key(CONF_ADDRESS, CONF_INDEX))
def to_code(config):
hub = yield cg.get_variable(config[CONF_DALLAS_ID])
if CONF_ADDRESS in config:
address = config[CONF_ADDRESS]
rhs = hub.Pget_sensor_by_address(address, config.get(CONF_RESOLUTION))
else:
rhs = hub.Pget_sensor_by_index(config[CONF_INDEX], config.get(CONF_RESOLUTION))
var = cg.Pvariable(config[CONF_ID], rhs)
yield sensor.register_sensor(var, config)
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])
var = cg.new_Pvariable(config[CONF_ID], hub)
await cg.register_component(var, config)
await sensor.register_sensor(var, config)
cg.add(hub.register_sensor_component(var))
await setup_component_core_(var, config, ".val")
vol.Optional(CONF_WINDOW_SIZE, default=15): cv.positive_not_null_int,
vol.Optional(CONF_SEND_EVERY, default=15): cv.positive_not_null_int,
vol.Optional(CONF_SEND_FIRST_AT): cv.positive_not_null_int,
}), validate_send_first_at),
vol.Optional(CONF_EXPONENTIAL_MOVING_AVERAGE): vol.Schema({
vol.Optional(CONF_ALPHA, default=0.1): cv.positive_float,
vol.Optional(CONF_SEND_EVERY, default=15): cv.positive_not_null_int,
}),
vol.Optional(CONF_LAMBDA): cv.lambda_,
vol.Optional(CONF_THROTTLE): cv.positive_time_period_milliseconds,
vol.Optional(CONF_DELTA): cv.float_,
vol.Optional(CONF_UNIQUE): None,
vol.Optional(CONF_HEARTBEAT): cv.positive_time_period_milliseconds,
vol.Optional(CONF_DEBOUNCE): cv.positive_time_period_milliseconds,
vol.Optional(CONF_OR): validate_recursive_filter,
}, cv.has_exactly_one_key(*FILTER_KEYS))
# Base
sensor_ns = esphome_ns.namespace('sensor')
Sensor = sensor_ns.class_('Sensor', Nameable)
SensorPtr = Sensor.operator('ptr')
MQTTSensorComponent = sensor_ns.class_('MQTTSensorComponent', mqtt.MQTTComponent)
PollingSensorComponent = sensor_ns.class_('PollingSensorComponent', PollingComponent, Sensor)
EmptySensor = sensor_ns.class_('EmptySensor', Sensor)
EmptyPollingParentSensor = sensor_ns.class_('EmptyPollingParentSensor', EmptySensor)
# Triggers
SensorStateTrigger = sensor_ns.class_('SensorStateTrigger', Trigger.template(float_))
SensorRawStateTrigger = sensor_ns.class_('SensorRawStateTrigger', Trigger.template(float_))
ValueRangeTrigger = sensor_ns.class_('ValueRangeTrigger', Trigger.template(float_), Component)
}),
vol.Optional(CONF_RAW): validate_raw,
vol.Optional(CONF_RC_SWITCH_RAW): RC_SWITCH_RAW_SCHEMA,
vol.Optional(CONF_RC_SWITCH_TYPE_A): RC_SWITCH_TYPE_A_SCHEMA,
vol.Optional(CONF_RC_SWITCH_TYPE_B): RC_SWITCH_TYPE_B_SCHEMA,
vol.Optional(CONF_RC_SWITCH_TYPE_C): RC_SWITCH_TYPE_C_SCHEMA,
vol.Optional(CONF_RC_SWITCH_TYPE_D): RC_SWITCH_TYPE_D_SCHEMA,
vol.Optional(CONF_REPEAT): vol.Any(cv.positive_not_null_int, cv.Schema({
vol.Required(CONF_TIMES): cv.positive_not_null_int,
vol.Required(CONF_WAIT_TIME): cv.positive_time_period_microseconds,
})),
cv.GenerateID(CONF_REMOTE_TRANSMITTER_ID): cv.use_variable_id(RemoteTransmitterComponent),
cv.GenerateID(CONF_TRANSMITTER_ID): cv.declare_variable_id(RemoteTransmitter),
vol.Optional(CONF_INVERTED): cv.invalid("Remote Transmitters do not support inverted mode!"),
}), cv.has_exactly_one_key(*REMOTE_KEYS))
def transmitter_base(full_config):
name = full_config[CONF_NAME]
key, config = next((k, v) for k, v in full_config.items() if k in REMOTE_KEYS)
if key == CONF_JVC:
return JVCTransmitter.new(name, config[CONF_DATA])
if key == CONF_LG:
return LGTransmitter.new(name, config[CONF_DATA], config[CONF_NBITS])
if key == CONF_NEC:
return NECTransmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
if key == CONF_PANASONIC:
return PanasonicTransmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
if key == CONF_SAMSUNG:
cv.GenerateID():
cv.declare_id(RS485Sensor),
cv.GenerateID(CONF_RS485_ID):
cv.use_id(RS485Component),
cv.Required(CONF_DEVICE):
state_hex_schema,
cv.Optional(CONF_SUB_DEVICE):
state_hex_schema,
cv.Optional(CONF_COMMAND_STATE):
command_hex_schema,
cv.Optional(CONF_LAMBDA):
cv.returning_lambda,
cv.Optional(CONF_DATA):
STATE_NUM_SCHEMA
}).extend(cv.polling_component_schema('60s')),
cv.has_exactly_one_key(CONF_LAMBDA, CONF_DATA))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await rs485.register_rs485_device(var, config)
if CONF_LAMBDA in config:
template_ = await cg.process_lambda(
config[CONF_LAMBDA], [(uint8_ptr_const, 'data'),
(num_t_const, 'len')],
return_type=cg.optional.template(float))
cg.add(var.set_template(template_))
if CONF_DATA in config:
data = config[CONF_DATA]
command_hex_schema,
cv.Optional(CONF_COMMAND_HEAT):
command_hex_schema,
cv.Optional(CONF_COMMAND_COOL):
command_hex_schema,
cv.Optional(CONF_COMMAND_AWAY):
command_hex_schema,
cv.Optional(CONF_COMMAND_HOME):
command_hex_schema,
}).extend(rs485.RS485_DEVICE_SCHEMA).extend({
cv.Optional(CONF_COMMAND_ON):
cv.invalid("RS485 Climate do not support command_on!"),
cv.Optional(CONF_STATE_ON):
cv.invalid("RS485 Climate do not support state_on!")
}).extend(cv.COMPONENT_SCHEMA),
cv.has_exactly_one_key(CONF_SENSOR, CONF_STATE_CURRENT),
cv.has_at_least_one_key(CONF_COMMAND_HEAT, CONF_COMMAND_COOL,
CONF_COMMAND_AUTO))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await climate.register_climate(var, config)
await rs485.register_rs485_device(var, config)
templ = await cg.templatable(config[CONF_COMMAND_TEMPERATURE],
[(cg.float_.operator('const'), 'x')],
cmd_hex_t)
cg.add(var.set_command_temperature(templ))
import esphome.config_validation as cv
from esphome.components import binary_sensor, esp32_ble_tracker
from esphome.const import CONF_MAC_ADDRESS, CONF_SERVICE_UUID, CONF_ID
DEPENDENCIES = ['esp32_ble_tracker']
ble_presence_ns = cg.esphome_ns.namespace('ble_presence')
BLEPresenceDevice = ble_presence_ns.class_('BLEPresenceDevice', binary_sensor.BinarySensor,
cg.Component, esp32_ble_tracker.ESPBTDeviceListener)
CONFIG_SCHEMA = cv.All(binary_sensor.BINARY_SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(BLEPresenceDevice),
cv.Optional(CONF_MAC_ADDRESS): cv.mac_address,
cv.Optional(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(
cv.COMPONENT_SCHEMA), cv.has_exactly_one_key(CONF_MAC_ADDRESS, CONF_SERVICE_UUID))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield esp32_ble_tracker.register_ble_device(var, config)
yield binary_sensor.register_binary_sensor(var, config)
if CONF_MAC_ADDRESS in config:
cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
if CONF_SERVICE_UUID in config:
if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
cg.add(var.set_service_uuid16(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID])))
elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid32_format):
