Rename esphomeyaml to esphome (#426)

* Rename * Update * Add migration * Fix * Fix dashboard * Change test * Fixes * Code cleanup * Fix import order * Update * Automate docker builds * Shellcheck
2025-09-19 11:42:20 +01:00 · 2019-02-13 16:54:02 +01:00
parent 1b8d242505
commit 3d9301a0f7
234 changed files with 1869 additions and 2000 deletions
--- a/esphome/components/sensor/init.py
+++ b/esphome/components/sensor/init.py
@@ -0,0 +1,262 @@
+import voluptuous as vol
+
+from esphome import automation
+from esphome.automation import CONDITION_REGISTRY
+from esphome.components import mqtt
+from esphome.components.mqtt import setup_mqtt_component
+import esphome.config_validation as cv
+from esphome.const import CONF_ABOVE, CONF_ACCURACY_DECIMALS, CONF_ALPHA, CONF_BELOW, \
+    CONF_DEBOUNCE, CONF_DELTA, CONF_EXPIRE_AFTER, CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_FILTERS, \
+    CONF_FILTER_NAN, CONF_FILTER_OUT, CONF_HEARTBEAT, CONF_ICON, CONF_ID, CONF_INTERNAL, \
+    CONF_LAMBDA, CONF_MQTT_ID, CONF_MULTIPLY, CONF_OFFSET, CONF_ON_RAW_VALUE, CONF_ON_VALUE, \
+    CONF_ON_VALUE_RANGE, CONF_OR, CONF_SEND_EVERY, CONF_SEND_FIRST_AT, \
+    CONF_SLIDING_WINDOW_MOVING_AVERAGE, CONF_THROTTLE, CONF_TRIGGER_ID, CONF_UNIQUE, \
+    CONF_UNIT_OF_MEASUREMENT, CONF_WINDOW_SIZE
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_types import App, Component, Nameable, PollingComponent, Trigger, \
+    esphome_ns, float_, optional
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+
+def validate_recursive_filter(value):
+    return FILTERS_SCHEMA(value)
+
+
+def validate_send_first_at(value):
+    send_first_at = value.get(CONF_SEND_FIRST_AT)
+    send_every = value[CONF_SEND_EVERY]
+    if send_first_at is not None and send_first_at > send_every:
+        raise vol.Invalid("send_first_at must be smaller than or equal to send_every! {} <= {}"
+                          "".format(send_first_at, send_every))
+    return value
+
+
+FILTER_KEYS = [CONF_OFFSET, CONF_MULTIPLY, CONF_FILTER_OUT, CONF_FILTER_NAN,
+               CONF_SLIDING_WINDOW_MOVING_AVERAGE, CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_LAMBDA,
+               CONF_THROTTLE, CONF_DELTA, CONF_UNIQUE, CONF_HEARTBEAT, CONF_DEBOUNCE, CONF_OR]
+
+FILTERS_SCHEMA = cv.ensure_list({
+    vol.Optional(CONF_OFFSET): cv.float_,
+    vol.Optional(CONF_MULTIPLY): cv.float_,
+    vol.Optional(CONF_FILTER_OUT): cv.float_,
+    vol.Optional(CONF_FILTER_NAN): None,
+    vol.Optional(CONF_SLIDING_WINDOW_MOVING_AVERAGE): vol.All(vol.Schema({
+        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)
+
+# Filters
+Filter = sensor_ns.class_('Filter')
+SlidingWindowMovingAverageFilter = sensor_ns.class_('SlidingWindowMovingAverageFilter', Filter)
+ExponentialMovingAverageFilter = sensor_ns.class_('ExponentialMovingAverageFilter', Filter)
+LambdaFilter = sensor_ns.class_('LambdaFilter', Filter)
+OffsetFilter = sensor_ns.class_('OffsetFilter', Filter)
+MultiplyFilter = sensor_ns.class_('MultiplyFilter', Filter)
+FilterOutValueFilter = sensor_ns.class_('FilterOutValueFilter', Filter)
+FilterOutNANFilter = sensor_ns.class_('FilterOutNANFilter', Filter)
+ThrottleFilter = sensor_ns.class_('ThrottleFilter', Filter)
+DebounceFilter = sensor_ns.class_('DebounceFilter', Filter, Component)
+HeartbeatFilter = sensor_ns.class_('HeartbeatFilter', Filter, Component)
+DeltaFilter = sensor_ns.class_('DeltaFilter', Filter)
+OrFilter = sensor_ns.class_('OrFilter', Filter)
+UniqueFilter = sensor_ns.class_('UniqueFilter', Filter)
+SensorInRangeCondition = sensor_ns.class_('SensorInRangeCondition', Filter)
+
+SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
+    cv.GenerateID(CONF_MQTT_ID): cv.declare_variable_id(MQTTSensorComponent),
+    vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string_strict,
+    vol.Optional(CONF_ICON): cv.icon,
+    vol.Optional(CONF_ACCURACY_DECIMALS): vol.Coerce(int),
+    vol.Optional(CONF_EXPIRE_AFTER): vol.All(cv.requires_component('mqtt'),
+                                             vol.Any(None, cv.positive_time_period_milliseconds)),
+    vol.Optional(CONF_FILTERS): FILTERS_SCHEMA,
+    vol.Optional(CONF_ON_VALUE): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(SensorStateTrigger),
+    }),
+    vol.Optional(CONF_ON_RAW_VALUE): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(SensorRawStateTrigger),
+    }),
+    vol.Optional(CONF_ON_VALUE_RANGE): automation.validate_automation({
+        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(ValueRangeTrigger),
+        vol.Optional(CONF_ABOVE): cv.float_,
+        vol.Optional(CONF_BELOW): cv.float_,
+    }, cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW)),
+})
+
+SENSOR_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(SENSOR_SCHEMA.schema)
+
+
+def setup_filter(config):
+    if CONF_OFFSET in config:
+        yield OffsetFilter.new(config[CONF_OFFSET])
+    elif CONF_MULTIPLY in config:
+        yield MultiplyFilter.new(config[CONF_MULTIPLY])
+    elif CONF_FILTER_OUT in config:
+        yield FilterOutValueFilter.new(config[CONF_FILTER_OUT])
+    elif CONF_FILTER_NAN in config:
+        yield FilterOutNANFilter.new()
+    elif CONF_SLIDING_WINDOW_MOVING_AVERAGE in config:
+        conf = config[CONF_SLIDING_WINDOW_MOVING_AVERAGE]
+        yield SlidingWindowMovingAverageFilter.new(conf[CONF_WINDOW_SIZE], conf[CONF_SEND_EVERY],
+                                                   conf.get(CONF_SEND_FIRST_AT))
+    elif CONF_EXPONENTIAL_MOVING_AVERAGE in config:
+        conf = config[CONF_EXPONENTIAL_MOVING_AVERAGE]
+        yield ExponentialMovingAverageFilter.new(conf[CONF_ALPHA], conf[CONF_SEND_EVERY])
+    elif CONF_LAMBDA in config:
+        for lambda_ in process_lambda(config[CONF_LAMBDA], [(float_, 'x')],
+                                      return_type=optional.template(float_)):
+            yield None
+        yield LambdaFilter.new(lambda_)
+    elif CONF_THROTTLE in config:
+        yield ThrottleFilter.new(config[CONF_THROTTLE])
+    elif CONF_DELTA in config:
+        yield DeltaFilter.new(config[CONF_DELTA])
+    elif CONF_OR in config:
+        for filters in setup_filters(config[CONF_OR]):
+            yield None
+        yield OrFilter.new(filters)
+    elif CONF_HEARTBEAT in config:
+        yield App.register_component(HeartbeatFilter.new(config[CONF_HEARTBEAT]))
+    elif CONF_DEBOUNCE in config:
+        yield App.register_component(DebounceFilter.new(config[CONF_DEBOUNCE]))
+    elif CONF_UNIQUE in config:
+        yield UniqueFilter.new()
+
+
+def setup_filters(config):
+    filters = []
+    for conf in config:
+        for filter in setup_filter(conf):
+            yield None
+        filters.append(filter)
+    yield filters
+
+
+def setup_sensor_core_(sensor_var, config):
+    if CONF_INTERNAL in config:
+        add(sensor_var.set_internal(config[CONF_INTERNAL]))
+    if CONF_UNIT_OF_MEASUREMENT in config:
+        add(sensor_var.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))
+    if CONF_ICON in config:
+        add(sensor_var.set_icon(config[CONF_ICON]))
+    if CONF_ACCURACY_DECIMALS in config:
+        add(sensor_var.set_accuracy_decimals(config[CONF_ACCURACY_DECIMALS]))
+    if CONF_FILTERS in config:
+        for filters in setup_filters(config[CONF_FILTERS]):
+            yield
+        add(sensor_var.set_filters(filters))
+
+    for conf in config.get(CONF_ON_VALUE, []):
+        rhs = sensor_var.make_state_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automation(trigger, float_, conf)
+    for conf in config.get(CONF_ON_RAW_VALUE, []):
+        rhs = sensor_var.make_raw_state_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        automation.build_automation(trigger, float_, conf)
+    for conf in config.get(CONF_ON_VALUE_RANGE, []):
+        rhs = sensor_var.make_value_range_trigger()
+        trigger = Pvariable(conf[CONF_TRIGGER_ID], rhs)
+        add(App.register_component(trigger))
+        if CONF_ABOVE in conf:
+            for template_ in templatable(conf[CONF_ABOVE], float_, float_):
+                yield
+            add(trigger.set_min(template_))
+        if CONF_BELOW in conf:
+            for template_ in templatable(conf[CONF_BELOW], float_, float_):
+                yield
+            add(trigger.set_max(template_))
+        automation.build_automation(trigger, float_, conf)
+
+    mqtt_ = sensor_var.Pget_mqtt()
+    if CONF_EXPIRE_AFTER in config:
+        if config[CONF_EXPIRE_AFTER] is None:
+            add(mqtt_.disable_expire_after())
+        else:
+            add(mqtt_.set_expire_after(config[CONF_EXPIRE_AFTER]))
+    setup_mqtt_component(mqtt_, config)
+
+
+def setup_sensor(sensor_obj, config):
+    if not CORE.has_id(config[CONF_ID]):
+        sensor_obj = Pvariable(config[CONF_ID], sensor_obj, has_side_effects=True)
+    CORE.add_job(setup_sensor_core_, sensor_obj, config)
+
+
+def register_sensor(var, config):
+    sensor_var = Pvariable(config[CONF_ID], var, has_side_effects=True)
+    add(App.register_sensor(sensor_var))
+    CORE.add_job(setup_sensor_core_, sensor_var, config)
+
+
+BUILD_FLAGS = '-DUSE_SENSOR'
+
+CONF_SENSOR_IN_RANGE = 'sensor.in_range'
+SENSOR_IN_RANGE_CONDITION_SCHEMA = vol.All({
+    vol.Required(CONF_ID): cv.use_variable_id(Sensor),
+    vol.Optional(CONF_ABOVE): cv.float_,
+    vol.Optional(CONF_BELOW): cv.float_,
+}, cv.has_at_least_one_key(CONF_ABOVE, CONF_BELOW))
+
+
+@CONDITION_REGISTRY.register(CONF_SENSOR_IN_RANGE, SENSOR_IN_RANGE_CONDITION_SCHEMA)
+def sensor_in_range_to_code(config, condition_id, arg_type, template_arg):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_sensor_in_range_condition(template_arg)
+    type = SensorInRangeCondition.template(arg_type)
+    cond = Pvariable(condition_id, rhs, type=type)
+
+    if CONF_ABOVE in config:
+        add(cond.set_min(config[CONF_ABOVE]))
+    if CONF_BELOW in config:
+        add(cond.set_max(config[CONF_BELOW]))
+
+    yield cond
+
+
+def core_to_hass_config(data, config):
+    ret = mqtt.build_hass_config(data, 'sensor', config, include_state=True, include_command=False)
+    if ret is None:
+        return None
+    if CONF_UNIT_OF_MEASUREMENT in config:
+        ret['unit_of_measurement'] = config[CONF_UNIT_OF_MEASUREMENT]
+    if CONF_EXPIRE_AFTER in config:
+        expire = config[CONF_EXPIRE_AFTER]
+        if expire is not None:
+            ret['expire_after'] = expire.total_seconds
+    if CONF_ICON in config:
+        ret['icon'] = config[CONF_ICON]
+    return ret
--- a/esphome/components/sensor/adc.py
+++ b/esphome/components/sensor/adc.py
@@ -0,0 +1,66 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ATTENUATION, CONF_ID, CONF_NAME, CONF_PIN, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, global_ns
+
+ATTENUATION_MODES = {
+    '0db': global_ns.ADC_0db,
+    '2.5db': global_ns.ADC_2_5db,
+    '6db': global_ns.ADC_6db,
+    '11db': global_ns.ADC_11db,
+}
+
+
+def validate_adc_pin(value):
+    vcc = str(value).upper()
+    if vcc == 'VCC':
+        return cv.only_on_esp8266(vcc)
+    return pins.analog_pin(value)
+
+
+ADCSensorComponent = sensor.sensor_ns.class_('ADCSensorComponent', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ADCSensorComponent),
+    vol.Required(CONF_PIN): validate_adc_pin,
+    vol.Optional(CONF_ATTENUATION): vol.All(cv.only_on_esp32, cv.one_of(*ATTENUATION_MODES,
+                                                                        lower=True)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    pin = config[CONF_PIN]
+    if pin == 'VCC':
+        pin = 0
+    rhs = App.make_adc_sensor(config[CONF_NAME], pin,
+                              config.get(CONF_UPDATE_INTERVAL))
+    adc = Pvariable(config[CONF_ID], rhs)
+    if CONF_ATTENUATION in config:
+        add(adc.set_attenuation(ATTENUATION_MODES[config[CONF_ATTENUATION]]))
+    sensor.setup_sensor(adc, config)
+    setup_component(adc, config)
+
+
+BUILD_FLAGS = '-DUSE_ADC_SENSOR'
+
+
+def required_build_flags(config):
+    if config[CONF_PIN] == 'VCC':
+        return '-DUSE_ADC_SENSOR_VCC'
+    return None
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
+
+
+def includes(config):
+    if config[CONF_PIN] == 'VCC':
+        return 'ADC_MODE(ADC_VCC);'
+    return None
--- a/esphome/components/sensor/ads1115.py
+++ b/esphome/components/sensor/ads1115.py
@@ -0,0 +1,76 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+from esphome.components.ads1115 import ADS1115Component
+import esphome.config_validation as cv
+from esphome.const import CONF_ADS1115_ID, CONF_GAIN, CONF_MULTIPLEXER, CONF_NAME, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import get_variable
+from esphome.py_compat import string_types
+
+DEPENDENCIES = ['ads1115']
+
+ADS1115Multiplexer = sensor.sensor_ns.enum('ADS1115Multiplexer')
+MUX = {
+    'A0_A1': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_N1,
+    'A0_A3': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_N3,
+    'A1_A3': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P1_N3,
+    'A2_A3': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P2_N3,
+    'A0_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P0_NG,
+    'A1_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P1_NG,
+    'A2_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P2_NG,
+    'A3_GND': ADS1115Multiplexer.ADS1115_MULTIPLEXER_P3_NG,
+}
+
+ADS1115Gain = sensor.sensor_ns.enum('ADS1115Gain')
+GAIN = {
+    '6.144': ADS1115Gain.ADS1115_GAIN_6P144,
+    '4.096': ADS1115Gain.ADS1115_GAIN_6P096,
+    '2.048': ADS1115Gain.ADS1115_GAIN_2P048,
+    '1.024': ADS1115Gain.ADS1115_GAIN_1P024,
+    '0.512': ADS1115Gain.ADS1115_GAIN_0P512,
+    '0.256': ADS1115Gain.ADS1115_GAIN_0P256,
+}
+
+
+def validate_gain(value):
+    if isinstance(value, float):
+        value = u'{:0.03f}'.format(value)
+    elif not isinstance(value, string_types):
+        raise vol.Invalid('invalid gain "{}"'.format(value))
+
+    return cv.one_of(*GAIN)(value)
+
+
+def validate_mux(value):
+    value = cv.string(value).upper()
+    value = value.replace(' ', '_')
+    return cv.one_of(*MUX)(value)
+
+
+ADS1115Sensor = sensor.sensor_ns.class_('ADS1115Sensor', sensor.EmptySensor)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ADS1115Sensor),
+    vol.Required(CONF_MULTIPLEXER): validate_mux,
+    vol.Required(CONF_GAIN): validate_gain,
+    cv.GenerateID(CONF_ADS1115_ID): cv.use_variable_id(ADS1115Component),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_ADS1115_ID]):
+        yield
+
+    mux = MUX[config[CONF_MULTIPLEXER]]
+    gain = GAIN[config[CONF_GAIN]]
+    rhs = hub.get_sensor(config[CONF_NAME], mux, gain, config.get(CONF_UPDATE_INTERVAL))
+    sensor.register_sensor(rhs, config)
+
+
+BUILD_FLAGS = '-DUSE_ADS1115_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/apds9960.py
+++ b/esphome/components/sensor/apds9960.py
@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+from esphome.components.apds9960 import APDS9960, CONF_APDS9960_ID
+import esphome.config_validation as cv
+from esphome.const import CONF_NAME, CONF_TYPE
+from esphome.cpp_generator import get_variable
+
+DEPENDENCIES = ['apds9960']
+
+TYPES = {
+    'CLEAR': 'make_clear_channel',
+    'RED': 'make_red_channel',
+    'GREEN': 'make_green_channel',
+    'BLUE': 'make_blue_channel',
+    'PROXIMITY': 'make_proximity',
+}
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(sensor.Sensor),
+    vol.Required(CONF_TYPE): cv.one_of(*TYPES, upper=True),
+    cv.GenerateID(CONF_APDS9960_ID): cv.use_variable_id(APDS9960)
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_APDS9960_ID]):
+        yield
+    func = getattr(hub, TYPES[config[CONF_TYPE]])
+    rhs = func(config[CONF_NAME])
+    sensor.register_sensor(rhs, config)
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/bh1750.py
+++ b/esphome/components/sensor/bh1750.py
@@ -0,0 +1,45 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_RESOLUTION, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+DEPENDENCIES = ['i2c']
+
+BH1750Resolution = sensor.sensor_ns.enum('BH1750Resolution')
+BH1750_RESOLUTIONS = {
+    4.0: BH1750Resolution.BH1750_RESOLUTION_4P0_LX,
+    1.0: BH1750Resolution.BH1750_RESOLUTION_1P0_LX,
+    0.5: BH1750Resolution.BH1750_RESOLUTION_0P5_LX,
+}
+
+BH1750Sensor = sensor.sensor_ns.class_('BH1750Sensor', sensor.PollingSensorComponent,
+                                       i2c.I2CDevice)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(BH1750Sensor),
+    vol.Optional(CONF_ADDRESS, default=0x23): cv.i2c_address,
+    vol.Optional(CONF_RESOLUTION): vol.All(cv.positive_float, cv.one_of(*BH1750_RESOLUTIONS)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_bh1750_sensor(config[CONF_NAME], config[CONF_ADDRESS],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    bh1750 = Pvariable(config[CONF_ID], rhs)
+    if CONF_RESOLUTION in config:
+        add(bh1750.set_resolution(BH1750_RESOLUTIONS[config[CONF_RESOLUTION]]))
+    sensor.setup_sensor(bh1750, config)
+    setup_component(bh1750, config)
+
+
+BUILD_FLAGS = '-DUSE_BH1750'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/ble_rssi.py
+++ b/esphome/components/sensor/ble_rssi.py
@@ -0,0 +1,30 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+from esphome.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+    make_address_array
+import esphome.config_validation as cv
+from esphome.const import CONF_MAC_ADDRESS, CONF_NAME
+from esphome.cpp_generator import get_variable
+from esphome.cpp_types import esphome_ns
+
+DEPENDENCIES = ['esp32_ble_tracker']
+
+ESP32BLERSSISensor = esphome_ns.class_('ESP32BLERSSISensor', sensor.Sensor)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ESP32BLERSSISensor),
+    vol.Required(CONF_MAC_ADDRESS): cv.mac_address,
+    cv.GenerateID(CONF_ESP32_BLE_ID): cv.use_variable_id(ESP32BLETracker)
+}))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_ESP32_BLE_ID]):
+        yield
+    rhs = hub.make_rssi_sensor(config[CONF_NAME], make_address_array(config[CONF_MAC_ADDRESS]))
+    sensor.register_sensor(rhs, config)
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/bme280.py
+++ b/esphome/components/sensor/bme280.py
@@ -0,0 +1,93 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_HUMIDITY, CONF_ID, CONF_IIR_FILTER, CONF_NAME, \
+    CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+BME280Oversampling = sensor.sensor_ns.enum('BME280Oversampling')
+OVERSAMPLING_OPTIONS = {
+    'NONE': BME280Oversampling.BME280_OVERSAMPLING_NONE,
+    '1X': BME280Oversampling.BME280_OVERSAMPLING_1X,
+    '2X': BME280Oversampling.BME280_OVERSAMPLING_2X,
+    '4X': BME280Oversampling.BME280_OVERSAMPLING_4X,
+    '8X': BME280Oversampling.BME280_OVERSAMPLING_8X,
+    '16X': BME280Oversampling.BME280_OVERSAMPLING_16X,
+}
+
+BME280IIRFilter = sensor.sensor_ns.enum('BME280IIRFilter')
+IIR_FILTER_OPTIONS = {
+    'OFF': BME280IIRFilter.BME280_IIR_FILTER_OFF,
+    '2X': BME280IIRFilter.BME280_IIR_FILTER_2X,
+    '4X': BME280IIRFilter.BME280_IIR_FILTER_4X,
+    '8X': BME280IIRFilter.BME280_IIR_FILTER_8X,
+    '16X': BME280IIRFilter.BME280_IIR_FILTER_16X,
+}
+
+BME280_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    vol.Optional(CONF_OVERSAMPLING): cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
+})
+
+BME280Component = sensor.sensor_ns.class_('BME280Component', PollingComponent, i2c.I2CDevice)
+BME280TemperatureSensor = sensor.sensor_ns.class_('BME280TemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+BME280PressureSensor = sensor.sensor_ns.class_('BME280PressureSensor',
+                                               sensor.EmptyPollingParentSensor)
+BME280HumiditySensor = sensor.sensor_ns.class_('BME280HumiditySensor',
+                                               sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(BME280Component),
+    vol.Optional(CONF_ADDRESS, default=0x77): cv.i2c_address,
+    vol.Required(CONF_TEMPERATURE): cv.nameable(BME280_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME280TemperatureSensor),
+    })),
+    vol.Required(CONF_PRESSURE): cv.nameable(BME280_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME280PressureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(BME280_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME280HumiditySensor),
+    })),
+    vol.Optional(CONF_IIR_FILTER): cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_bme280_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_PRESSURE][CONF_NAME],
+                                 config[CONF_HUMIDITY][CONF_NAME],
+                                 config[CONF_ADDRESS],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    bme280 = Pvariable(config[CONF_ID], rhs)
+    if CONF_OVERSAMPLING in config[CONF_TEMPERATURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_TEMPERATURE][CONF_OVERSAMPLING]]
+        add(bme280.set_temperature_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_PRESSURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_PRESSURE][CONF_OVERSAMPLING]]
+        add(bme280.set_pressure_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_HUMIDITY]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_HUMIDITY][CONF_OVERSAMPLING]]
+        add(bme280.set_humidity_oversampling(constant))
+    if CONF_IIR_FILTER in config:
+        constant = IIR_FILTER_OPTIONS[config[CONF_IIR_FILTER]]
+        add(bme280.set_iir_filter(constant))
+
+    sensor.setup_sensor(bme280.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bme280.Pget_pressure_sensor(), config[CONF_PRESSURE])
+    sensor.setup_sensor(bme280.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    setup_component(bme280, config)
+
+
+BUILD_FLAGS = '-DUSE_BME280'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_PRESSURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]
--- a/esphome/components/sensor/bme680.py
+++ b/esphome/components/sensor/bme680.py
@@ -0,0 +1,117 @@
+import voluptuous as vol
+
+from esphome import core
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_DURATION, CONF_GAS_RESISTANCE, CONF_HEATER, \
+    CONF_HUMIDITY, CONF_ID, CONF_IIR_FILTER, CONF_NAME, CONF_OVERSAMPLING, CONF_PRESSURE, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+BME680Oversampling = sensor.sensor_ns.enum('BME680Oversampling')
+OVERSAMPLING_OPTIONS = {
+    'NONE': BME680Oversampling.BME680_OVERSAMPLING_NONE,
+    '1X': BME680Oversampling.BME680_OVERSAMPLING_1X,
+    '2X': BME680Oversampling.BME680_OVERSAMPLING_2X,
+    '4X': BME680Oversampling.BME680_OVERSAMPLING_4X,
+    '8X': BME680Oversampling.BME680_OVERSAMPLING_8X,
+    '16X': BME680Oversampling.BME680_OVERSAMPLING_16X,
+}
+
+BME680IIRFilter = sensor.sensor_ns.enum('BME680IIRFilter')
+IIR_FILTER_OPTIONS = {
+    'OFF': BME680IIRFilter.BME680_IIR_FILTER_OFF,
+    '1X': BME680IIRFilter.BME680_IIR_FILTER_1X,
+    '3X': BME680IIRFilter.BME680_IIR_FILTER_3X,
+    '7X': BME680IIRFilter.BME680_IIR_FILTER_7X,
+    '15X': BME680IIRFilter.BME680_IIR_FILTER_15X,
+    '31X': BME680IIRFilter.BME680_IIR_FILTER_31X,
+    '63X': BME680IIRFilter.BME680_IIR_FILTER_63X,
+    '127X': BME680IIRFilter.BME680_IIR_FILTER_127X,
+}
+
+BME680_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    vol.Optional(CONF_OVERSAMPLING): cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
+})
+
+BME680Component = sensor.sensor_ns.class_('BME680Component', PollingComponent, i2c.I2CDevice)
+BME680TemperatureSensor = sensor.sensor_ns.class_('BME680TemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+BME680PressureSensor = sensor.sensor_ns.class_('BME680PressureSensor',
+                                               sensor.EmptyPollingParentSensor)
+BME680HumiditySensor = sensor.sensor_ns.class_('BME680HumiditySensor',
+                                               sensor.EmptyPollingParentSensor)
+BME680GasResistanceSensor = sensor.sensor_ns.class_('BME680GasResistanceSensor',
+                                                    sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(BME680Component),
+    vol.Optional(CONF_ADDRESS, default=0x76): cv.i2c_address,
+    vol.Required(CONF_TEMPERATURE): cv.nameable(BME680_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME680TemperatureSensor),
+    })),
+    vol.Required(CONF_PRESSURE): cv.nameable(BME680_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME680PressureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(BME680_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME680HumiditySensor),
+    })),
+    vol.Required(CONF_GAS_RESISTANCE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BME680GasResistanceSensor),
+    })),
+    vol.Optional(CONF_IIR_FILTER): cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
+    vol.Optional(CONF_HEATER): vol.Any(None, vol.All(vol.Schema({
+        vol.Optional(CONF_TEMPERATURE, default=320): vol.All(vol.Coerce(int), vol.Range(200, 400)),
+        vol.Optional(CONF_DURATION, default='150ms'): vol.All(
+            cv.positive_time_period_milliseconds, vol.Range(max=core.TimePeriod(milliseconds=4032)))
+    }, cv.has_at_least_one_key(CONF_TEMPERATURE, CONF_DURATION)))),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_bme680_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_PRESSURE][CONF_NAME],
+                                 config[CONF_HUMIDITY][CONF_NAME],
+                                 config[CONF_GAS_RESISTANCE][CONF_NAME],
+                                 config[CONF_ADDRESS],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    bme680 = Pvariable(config[CONF_ID], rhs)
+    if CONF_OVERSAMPLING in config[CONF_TEMPERATURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_TEMPERATURE][CONF_OVERSAMPLING]]
+        add(bme680.set_temperature_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_PRESSURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_PRESSURE][CONF_OVERSAMPLING]]
+        add(bme680.set_pressure_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_HUMIDITY]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_HUMIDITY][CONF_OVERSAMPLING]]
+        add(bme680.set_humidity_oversampling(constant))
+    if CONF_IIR_FILTER in config:
+        constant = IIR_FILTER_OPTIONS[config[CONF_IIR_FILTER]]
+        add(bme680.set_iir_filter(constant))
+    if CONF_HEATER in config:
+        conf = config[CONF_HEATER]
+        if not conf:
+            add(bme680.set_heater(0, 0))
+        else:
+            add(bme680.set_heater(conf[CONF_TEMPERATURE], conf[CONF_DURATION]))
+
+    sensor.setup_sensor(bme680.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bme680.Pget_pressure_sensor(), config[CONF_PRESSURE])
+    sensor.setup_sensor(bme680.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    sensor.setup_sensor(bme680.Pget_gas_resistance_sensor(), config[CONF_GAS_RESISTANCE])
+    setup_component(bme680, config)
+
+
+BUILD_FLAGS = '-DUSE_BME680'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_PRESSURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY]),
+            sensor.core_to_hass_config(data, config[CONF_GAS_RESISTANCE])]
--- a/esphome/components/sensor/bmp085.py
+++ b/esphome/components/sensor/bmp085.py
@@ -0,0 +1,50 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_PRESSURE, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import HexIntLiteral, Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+BMP085Component = sensor.sensor_ns.class_('BMP085Component', PollingComponent, i2c.I2CDevice)
+BMP085TemperatureSensor = sensor.sensor_ns.class_('BMP085TemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+BMP085PressureSensor = sensor.sensor_ns.class_('BMP085PressureSensor',
+                                               sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(BMP085Component),
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BMP085TemperatureSensor),
+    })),
+    vol.Required(CONF_PRESSURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BMP085PressureSensor),
+    })),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_bmp085_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_PRESSURE][CONF_NAME],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    bmp = Pvariable(config[CONF_ID], rhs)
+    if CONF_ADDRESS in config:
+        add(bmp.set_address(HexIntLiteral(config[CONF_ADDRESS])))
+
+    sensor.setup_sensor(bmp.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bmp.Pget_pressure_sensor(), config[CONF_PRESSURE])
+    setup_component(bmp, config)
+
+
+BUILD_FLAGS = '-DUSE_BMP085_SENSOR'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_PRESSURE])]
--- a/esphome/components/sensor/bmp280.py
+++ b/esphome/components/sensor/bmp280.py
@@ -0,0 +1,82 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_IIR_FILTER, CONF_NAME, \
+    CONF_OVERSAMPLING, CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+BMP280Oversampling = sensor.sensor_ns.enum('BMP280Oversampling')
+OVERSAMPLING_OPTIONS = {
+    'NONE': BMP280Oversampling.BMP280_OVERSAMPLING_NONE,
+    '1X': BMP280Oversampling.BMP280_OVERSAMPLING_1X,
+    '2X': BMP280Oversampling.BMP280_OVERSAMPLING_2X,
+    '4X': BMP280Oversampling.BMP280_OVERSAMPLING_4X,
+    '8X': BMP280Oversampling.BMP280_OVERSAMPLING_8X,
+    '16X': BMP280Oversampling.BMP280_OVERSAMPLING_16X,
+}
+
+BMP280IIRFilter = sensor.sensor_ns.enum('BMP280IIRFilter')
+IIR_FILTER_OPTIONS = {
+    'OFF': BMP280IIRFilter.BMP280_IIR_FILTER_OFF,
+    '2X': BMP280IIRFilter.BMP280_IIR_FILTER_2X,
+    '4X': BMP280IIRFilter.BMP280_IIR_FILTER_4X,
+    '8X': BMP280IIRFilter.BMP280_IIR_FILTER_8X,
+    '16X': BMP280IIRFilter.BMP280_IIR_FILTER_16X,
+}
+
+BMP280_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    vol.Optional(CONF_OVERSAMPLING): cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
+})
+
+BMP280Component = sensor.sensor_ns.class_('BMP280Component', PollingComponent, i2c.I2CDevice)
+BMP280TemperatureSensor = sensor.sensor_ns.class_('BMP280TemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+BMP280PressureSensor = sensor.sensor_ns.class_('BMP280PressureSensor',
+                                               sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(BMP280Component),
+    vol.Optional(CONF_ADDRESS, default=0x77): cv.i2c_address,
+    vol.Required(CONF_TEMPERATURE): cv.nameable(BMP280_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BMP280TemperatureSensor),
+    })),
+    vol.Required(CONF_PRESSURE): cv.nameable(BMP280_OVERSAMPLING_SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(BMP280PressureSensor),
+    })),
+    vol.Optional(CONF_IIR_FILTER): cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_bmp280_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_PRESSURE][CONF_NAME],
+                                 config[CONF_ADDRESS],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    bmp280 = Pvariable(config[CONF_ID], rhs)
+    if CONF_OVERSAMPLING in config[CONF_TEMPERATURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_TEMPERATURE][CONF_OVERSAMPLING]]
+        add(bmp280.set_temperature_oversampling(constant))
+    if CONF_OVERSAMPLING in config[CONF_PRESSURE]:
+        constant = OVERSAMPLING_OPTIONS[config[CONF_PRESSURE][CONF_OVERSAMPLING]]
+        add(bmp280.set_pressure_oversampling(constant))
+    if CONF_IIR_FILTER in config:
+        constant = IIR_FILTER_OPTIONS[config[CONF_IIR_FILTER]]
+        add(bmp280.set_iir_filter(constant))
+
+    sensor.setup_sensor(bmp280.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(bmp280.Pget_pressure_sensor(), config[CONF_PRESSURE])
+    setup_component(bmp280, config)
+
+
+BUILD_FLAGS = '-DUSE_BMP280'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_PRESSURE])]
--- a/esphome/components/sensor/cse7766.py
+++ b/esphome/components/sensor/cse7766.py
@@ -0,0 +1,67 @@
+import voluptuous as vol
+
+from esphome.components import sensor, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CURRENT, CONF_ID, CONF_NAME, CONF_POWER, CONF_UART_ID, \
+    CONF_UPDATE_INTERVAL, CONF_VOLTAGE
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['uart']
+
+CSE7766Component = sensor.sensor_ns.class_('CSE7766Component', PollingComponent, uart.UARTDevice)
+CSE7766VoltageSensor = sensor.sensor_ns.class_('CSE7766VoltageSensor',
+                                               sensor.EmptySensor)
+CSE7766CurrentSensor = sensor.sensor_ns.class_('CSE7766CurrentSensor',
+                                               sensor.EmptySensor)
+CSE7766PowerSensor = sensor.sensor_ns.class_('CSE7766PowerSensor',
+                                             sensor.EmptySensor)
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CSE7766Component),
+    cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
+
+    vol.Optional(CONF_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(CSE7766VoltageSensor),
+    })),
+    vol.Optional(CONF_CURRENT): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(CSE7766CurrentSensor),
+    })),
+    vol.Optional(CONF_POWER): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(CSE7766PowerSensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_VOLTAGE, CONF_CURRENT,
+                                                               CONF_POWER))
+
+
+def to_code(config):
+    for uart_ in get_variable(config[CONF_UART_ID]):
+        yield
+
+    rhs = App.make_cse7766(uart_, config.get(CONF_UPDATE_INTERVAL))
+    cse = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_VOLTAGE in config:
+        conf = config[CONF_VOLTAGE]
+        sensor.register_sensor(cse.make_voltage_sensor(conf[CONF_NAME]), conf)
+    if CONF_CURRENT in config:
+        conf = config[CONF_CURRENT]
+        sensor.register_sensor(cse.make_current_sensor(conf[CONF_NAME]), conf)
+    if CONF_POWER in config:
+        conf = config[CONF_POWER]
+        sensor.register_sensor(cse.make_power_sensor(conf[CONF_NAME]), conf)
+    setup_component(cse, config)
+
+
+BUILD_FLAGS = '-DUSE_CSE7766'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_VOLTAGE, CONF_CURRENT, CONF_POWER):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret
--- a/esphome/components/sensor/custom.py
+++ b/esphome/components/sensor/custom.py
@@ -0,0 +1,37 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_SENSORS
+from esphome.cpp_generator import Pvariable, add, process_lambda, variable
+from esphome.cpp_types import std_vector
+
+CustomSensorConstructor = sensor.sensor_ns.class_('CustomSensorConstructor')
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(CustomSensorConstructor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Required(CONF_SENSORS): cv.ensure_list(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(sensor.Sensor),
+    })),
+})
+
+
+def to_code(config):
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=std_vector.template(sensor.SensorPtr)):
+        yield
+
+    rhs = CustomSensorConstructor(template_)
+    custom = variable(config[CONF_ID], rhs)
+    for i, conf in enumerate(config[CONF_SENSORS]):
+        var = Pvariable(conf[CONF_ID], custom.get_sensor(i))
+        add(var.set_name(conf[CONF_NAME]))
+        sensor.setup_sensor(var, conf)
+
+
+BUILD_FLAGS = '-DUSE_CUSTOM_SENSOR'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, sens) for sens in config[CONF_SENSORS]]
--- a/esphome/components/sensor/dallas.py
+++ b/esphome/components/sensor/dallas.py
@@ -0,0 +1,38 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+from esphome.components.dallas import DallasComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_NAME, \
+    CONF_RESOLUTION
+from esphome.cpp_generator import HexIntLiteral, get_variable
+
+DallasTemperatureSensor = sensor.sensor_ns.class_('DallasTemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(DallasTemperatureSensor),
+    vol.Exclusive(CONF_ADDRESS, 'dallas'): cv.hex_int,
+    vol.Exclusive(CONF_INDEX, 'dallas'): cv.positive_int,
+    cv.GenerateID(CONF_DALLAS_ID): cv.use_variable_id(DallasComponent),
+    vol.Optional(CONF_RESOLUTION): vol.All(vol.Coerce(int), vol.Range(min=9, max=12)),
+}), cv.has_at_least_one_key(CONF_ADDRESS, CONF_INDEX))
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_DALLAS_ID]):
+        yield
+    if CONF_ADDRESS in config:
+        address = HexIntLiteral(config[CONF_ADDRESS])
+        rhs = hub.Pget_sensor_by_address(config[CONF_NAME], address, config.get(CONF_RESOLUTION))
+    else:
+        rhs = hub.Pget_sensor_by_index(config[CONF_NAME], config[CONF_INDEX],
+                                       config.get(CONF_RESOLUTION))
+    sensor.register_sensor(rhs, config)
+
+
+BUILD_FLAGS = '-DUSE_DALLAS_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/dht.py
+++ b/esphome/components/sensor/dht.py
@@ -0,0 +1,64 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_MODEL, CONF_NAME, \
+    CONF_PIN, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent
+from esphome.pins import gpio_input_pullup_pin_schema
+
+DHTModel = sensor.sensor_ns.enum('DHTModel')
+DHT_MODELS = {
+    'AUTO_DETECT': DHTModel.DHT_MODEL_AUTO_DETECT,
+    'DHT11': DHTModel.DHT_MODEL_DHT11,
+    'DHT22': DHTModel.DHT_MODEL_DHT22,
+    'AM2302': DHTModel.DHT_MODEL_AM2302,
+    'RHT03': DHTModel.DHT_MODEL_RHT03,
+    'SI7021': DHTModel.DHT_MODEL_SI7021,
+}
+
+DHTComponent = sensor.sensor_ns.class_('DHTComponent', PollingComponent)
+DHTTemperatureSensor = sensor.sensor_ns.class_('DHTTemperatureSensor',
+                                               sensor.EmptyPollingParentSensor)
+DHTHumiditySensor = sensor.sensor_ns.class_('DHTHumiditySensor',
+                                            sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(DHTComponent),
+    vol.Required(CONF_PIN): gpio_input_pullup_pin_schema,
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(DHTTemperatureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(DHTHumiditySensor),
+    })),
+    vol.Optional(CONF_MODEL): cv.one_of(*DHT_MODELS, upper=True),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for pin in gpio_output_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_dht_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                              config[CONF_HUMIDITY][CONF_NAME],
+                              pin, config.get(CONF_UPDATE_INTERVAL))
+    dht = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_MODEL in config:
+        constant = DHT_MODELS[config[CONF_MODEL]]
+        add(dht.set_dht_model(constant))
+
+    sensor.setup_sensor(dht.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(dht.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    setup_component(dht, config)
+
+
+BUILD_FLAGS = '-DUSE_DHT_SENSOR'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]
--- a/esphome/components/sensor/dht12.py
+++ b/esphome/components/sensor/dht12.py
@@ -0,0 +1,47 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+DHT12Component = sensor.sensor_ns.class_('DHT12Component', PollingComponent, i2c.I2CDevice)
+DHT12TemperatureSensor = sensor.sensor_ns.class_('DHT12TemperatureSensor',
+                                                 sensor.EmptyPollingParentSensor)
+DHT12HumiditySensor = sensor.sensor_ns.class_('DHT12HumiditySensor',
+                                              sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(DHT12Component),
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(DHT12TemperatureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(DHT12HumiditySensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_dht12_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                config[CONF_HUMIDITY][CONF_NAME],
+                                config.get(CONF_UPDATE_INTERVAL))
+    dht = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(dht.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(dht.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    setup_component(dht, config)
+
+
+BUILD_FLAGS = '-DUSE_DHT12_SENSOR'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]
--- a/esphome/components/sensor/duty_cycle.py
+++ b/esphome/components/sensor/duty_cycle.py
@@ -0,0 +1,34 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_PIN, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App
+
+DutyCycleSensor = sensor.sensor_ns.class_('DutyCycleSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(DutyCycleSensor),
+    vol.Required(CONF_PIN): pins.internal_gpio_input_pin_schema,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for pin in gpio_input_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_duty_cycle_sensor(config[CONF_NAME], pin,
+                                     config.get(CONF_UPDATE_INTERVAL))
+    duty = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(duty, config)
+    setup_component(duty, config)
+
+
+BUILD_FLAGS = '-DUSE_DUTY_CYCLE_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/esp32_hall.py
+++ b/esphome/components/sensor/esp32_hall.py
@@ -0,0 +1,32 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL, ESP_PLATFORM_ESP32
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Application
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+MakeESP32HallSensor = Application.struct('MakeESP32HallSensor')
+ESP32HallSensor = sensor.sensor_ns.class_('ESP32HallSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(ESP32HallSensor),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_esp32_hall_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    hall = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(hall, config)
+    setup_component(hall, config)
+
+
+BUILD_FLAGS = '-DUSE_ESP32_HALL_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/hdc1080.py
+++ b/esphome/components/sensor/hdc1080.py
@@ -0,0 +1,47 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+HDC1080Component = sensor.sensor_ns.class_('HDC1080Component', PollingComponent, i2c.I2CDevice)
+HDC1080TemperatureSensor = sensor.sensor_ns.class_('HDC1080TemperatureSensor',
+                                                   sensor.EmptyPollingParentSensor)
+HDC1080HumiditySensor = sensor.sensor_ns.class_('HDC1080HumiditySensor',
+                                                sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HDC1080Component),
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HDC1080TemperatureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HDC1080HumiditySensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_hdc1080_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                  config[CONF_HUMIDITY][CONF_NAME],
+                                  config.get(CONF_UPDATE_INTERVAL))
+    hdc1080 = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(hdc1080.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(hdc1080.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    setup_component(hdc1080, config)
+
+
+BUILD_FLAGS = '-DUSE_HDC1080_SENSOR'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]
--- a/esphome/components/sensor/hlw8012.py
+++ b/esphome/components/sensor/hlw8012.py
@@ -0,0 +1,76 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_CF1_PIN, CONF_CF_PIN, CONF_CHANGE_MODE_EVERY, CONF_CURRENT, \
+    CONF_CURRENT_RESISTOR, CONF_ID, CONF_NAME, CONF_POWER, CONF_SEL_PIN, CONF_UPDATE_INTERVAL, \
+    CONF_VOLTAGE, CONF_VOLTAGE_DIVIDER
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App, PollingComponent
+
+HLW8012Component = sensor.sensor_ns.class_('HLW8012Component', PollingComponent)
+HLW8012VoltageSensor = sensor.sensor_ns.class_('HLW8012VoltageSensor', sensor.EmptySensor)
+HLW8012CurrentSensor = sensor.sensor_ns.class_('HLW8012CurrentSensor', sensor.EmptySensor)
+HLW8012PowerSensor = sensor.sensor_ns.class_('HLW8012PowerSensor', sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HLW8012Component),
+    vol.Required(CONF_SEL_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_CF_PIN): pins.input_pin,
+    vol.Required(CONF_CF1_PIN): pins.input_pin,
+
+    vol.Optional(CONF_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HLW8012VoltageSensor),
+    })),
+    vol.Optional(CONF_CURRENT): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HLW8012CurrentSensor),
+    })),
+    vol.Optional(CONF_POWER): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HLW8012PowerSensor),
+    })),
+
+    vol.Optional(CONF_CURRENT_RESISTOR): cv.resistance,
+    vol.Optional(CONF_VOLTAGE_DIVIDER): cv.positive_float,
+    vol.Optional(CONF_CHANGE_MODE_EVERY): vol.All(cv.uint32_t, vol.Range(min=1)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_VOLTAGE, CONF_CURRENT,
+                                                               CONF_POWER))
+
+
+def to_code(config):
+    for sel in gpio_output_pin_expression(config[CONF_SEL_PIN]):
+        yield
+
+    rhs = App.make_hlw8012(sel, config[CONF_CF_PIN], config[CONF_CF1_PIN],
+                           config.get(CONF_UPDATE_INTERVAL))
+    hlw = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_VOLTAGE in config:
+        conf = config[CONF_VOLTAGE]
+        sensor.register_sensor(hlw.make_voltage_sensor(conf[CONF_NAME]), conf)
+    if CONF_CURRENT in config:
+        conf = config[CONF_CURRENT]
+        sensor.register_sensor(hlw.make_current_sensor(conf[CONF_NAME]), conf)
+    if CONF_POWER in config:
+        conf = config[CONF_POWER]
+        sensor.register_sensor(hlw.make_power_sensor(conf[CONF_NAME]), conf)
+    if CONF_CURRENT_RESISTOR in config:
+        add(hlw.set_current_resistor(config[CONF_CURRENT_RESISTOR]))
+    if CONF_VOLTAGE_DIVIDER in config:
+        add(hlw.set_voltage_divider(config[CONF_VOLTAGE_DIVIDER]))
+    if CONF_CHANGE_MODE_EVERY in config:
+        add(hlw.set_change_mode_every(config[CONF_CHANGE_MODE_EVERY]))
+    setup_component(hlw, config)
+
+
+BUILD_FLAGS = '-DUSE_HLW8012'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_VOLTAGE, CONF_CURRENT, CONF_POWER):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret
--- a/esphome/components/sensor/hmc5883l.py
+++ b/esphome/components/sensor/hmc5883l.py
@@ -0,0 +1,97 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_RANGE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+CONF_FIELD_STRENGTH_X = 'field_strength_x'
+CONF_FIELD_STRENGTH_Y = 'field_strength_y'
+CONF_FIELD_STRENGTH_Z = 'field_strength_z'
+CONF_HEADING = 'heading'
+
+HMC5883LComponent = sensor.sensor_ns.class_('HMC5883LComponent', PollingComponent, i2c.I2CDevice)
+HMC5883LFieldStrengthSensor = sensor.sensor_ns.class_('HMC5883LFieldStrengthSensor',
+                                                      sensor.EmptyPollingParentSensor)
+HMC5883LHeadingSensor = sensor.sensor_ns.class_('HMC5883LHeadingSensor',
+                                                sensor.EmptyPollingParentSensor)
+
+HMC5883LRange = sensor.sensor_ns.enum('HMC5883LRange')
+HMC5883L_RANGES = {
+    88: HMC5883LRange.HMC5883L_RANGE_88_UT,
+    130: HMC5883LRange.HMC5883L_RANGE_130_UT,
+    190: HMC5883LRange.HMC5883L_RANGE_190_UT,
+    250: HMC5883LRange.HMC5883L_RANGE_250_UT,
+    400: HMC5883LRange.HMC5883L_RANGE_400_UT,
+    470: HMC5883LRange.HMC5883L_RANGE_470_UT,
+    560: HMC5883LRange.HMC5883L_RANGE_560_UT,
+    810: HMC5883LRange.HMC5883L_RANGE_810_UT,
+}
+
+
+def validate_range(value):
+    value = cv.string(value)
+    if value.endswith(u'µT') or value.endswith('uT'):
+        value = value[:-2]
+    return cv.one_of(*HMC5883L_RANGES, int=True)(value)
+
+
+SENSOR_KEYS = [CONF_FIELD_STRENGTH_X, CONF_FIELD_STRENGTH_Y, CONF_FIELD_STRENGTH_Z,
+               CONF_HEADING]
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HMC5883LComponent),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+    vol.Optional(CONF_FIELD_STRENGTH_X): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HMC5883LFieldStrengthSensor),
+    })),
+    vol.Optional(CONF_FIELD_STRENGTH_Y): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HMC5883LFieldStrengthSensor),
+    })),
+    vol.Optional(CONF_FIELD_STRENGTH_Z): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HMC5883LFieldStrengthSensor),
+    })),
+    vol.Optional(CONF_HEADING): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HMC5883LHeadingSensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+    vol.Optional(CONF_RANGE): validate_range,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS))
+
+
+def to_code(config):
+    rhs = App.make_hmc5883l(config.get(CONF_UPDATE_INTERVAL))
+    hmc = Pvariable(config[CONF_ID], rhs)
+    if CONF_ADDRESS in config:
+        add(hmc.set_address(config[CONF_ADDRESS]))
+    if CONF_RANGE in config:
+        add(hmc.set_range(HMC5883L_RANGES[config[CONF_RANGE]]))
+    if CONF_FIELD_STRENGTH_X in config:
+        conf = config[CONF_FIELD_STRENGTH_X]
+        sensor.register_sensor(hmc.Pmake_x_sensor(conf[CONF_NAME]), conf)
+    if CONF_FIELD_STRENGTH_Y in config:
+        conf = config[CONF_FIELD_STRENGTH_Y]
+        sensor.register_sensor(hmc.Pmake_y_sensor(conf[CONF_NAME]), conf)
+    if CONF_FIELD_STRENGTH_Z in config:
+        conf = config[CONF_FIELD_STRENGTH_Z]
+        sensor.register_sensor(hmc.Pmake_z_sensor(conf[CONF_NAME]), conf)
+    if CONF_HEADING in config:
+        conf = config[CONF_HEADING]
+        sensor.register_sensor(hmc.Pmake_heading_sensor(conf[CONF_NAME]), conf)
+    setup_component(hmc, config)
+
+
+BUILD_FLAGS = '-DUSE_HMC5883L'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_FIELD_STRENGTH_X, CONF_FIELD_STRENGTH_Y, CONF_FIELD_STRENGTH_Z, CONF_HEADING):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret
--- a/esphome/components/sensor/homeassistant.py
+++ b/esphome/components/sensor/homeassistant.py
@@ -0,0 +1,29 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ENTITY_ID, CONF_ID, CONF_NAME
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_types import App
+
+DEPENDENCIES = ['api']
+
+HomeassistantSensor = sensor.sensor_ns.class_('HomeassistantSensor', sensor.Sensor)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HomeassistantSensor),
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+}))
+
+
+def to_code(config):
+    rhs = App.make_homeassistant_sensor(config[CONF_NAME], config[CONF_ENTITY_ID])
+    subs = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(subs, config)
+
+
+BUILD_FLAGS = '-DUSE_HOMEASSISTANT_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/htu21d.py
+++ b/esphome/components/sensor/htu21d.py
@@ -0,0 +1,48 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Application, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+MakeHTU21DSensor = Application.struct('MakeHTU21DSensor')
+HTU21DComponent = sensor.sensor_ns.class_('HTU21DComponent', PollingComponent, i2c.I2CDevice)
+HTU21DTemperatureSensor = sensor.sensor_ns.class_('HTU21DTemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+HTU21DHumiditySensor = sensor.sensor_ns.class_('HTU21DHumiditySensor',
+                                               sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HTU21DComponent),
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HTU21DTemperatureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(HTU21DHumiditySensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_htu21d_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_HUMIDITY][CONF_NAME],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    htu21d = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(htu21d.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(htu21d.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    setup_component(htu21d, config)
+
+
+BUILD_FLAGS = '-DUSE_HTU21D_SENSOR'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]
--- a/esphome/components/sensor/hx711.py
+++ b/esphome/components/sensor/hx711.py
@@ -0,0 +1,53 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_CLK_PIN, CONF_GAIN, CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App, Application
+
+MakeHX711Sensor = Application.struct('MakeHX711Sensor')
+HX711Sensor = sensor.sensor_ns.class_('HX711Sensor', sensor.PollingSensorComponent)
+
+CONF_DOUT_PIN = 'dout_pin'
+
+HX711Gain = sensor.sensor_ns.enum('HX711Gain')
+GAINS = {
+    128: HX711Gain.HX711_GAIN_128,
+    32: HX711Gain.HX711_GAIN_32,
+    64: HX711Gain.HX711_GAIN_64,
+}
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(HX711Sensor),
+    vol.Required(CONF_DOUT_PIN): pins.gpio_input_pin_schema,
+    vol.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_GAIN): cv.one_of(*GAINS, int=True),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for dout_pin in gpio_input_pin_expression(config[CONF_DOUT_PIN]):
+        yield
+    for sck_pin in gpio_input_pin_expression(config[CONF_CLK_PIN]):
+        yield
+
+    rhs = App.make_hx711_sensor(config[CONF_NAME], dout_pin, sck_pin,
+                                config.get(CONF_UPDATE_INTERVAL))
+    hx711 = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_GAIN in config:
+        add(hx711.set_gain(GAINS[config[CONF_GAIN]]))
+
+    sensor.setup_sensor(hx711, config)
+    setup_component(hx711, config)
+
+
+BUILD_FLAGS = '-DUSE_HX711'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/ina219.py
+++ b/esphome/components/sensor/ina219.py
@@ -0,0 +1,76 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_BUS_VOLTAGE, CONF_CURRENT, CONF_ID, \
+    CONF_MAX_CURRENT, CONF_MAX_VOLTAGE, CONF_NAME, CONF_POWER, CONF_SHUNT_RESISTANCE, \
+    CONF_SHUNT_VOLTAGE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+INA219Component = sensor.sensor_ns.class_('INA219Component', PollingComponent, i2c.I2CDevice)
+INA219VoltageSensor = sensor.sensor_ns.class_('INA219VoltageSensor',
+                                              sensor.EmptyPollingParentSensor)
+INA219CurrentSensor = sensor.sensor_ns.class_('INA219CurrentSensor',
+                                              sensor.EmptyPollingParentSensor)
+INA219PowerSensor = sensor.sensor_ns.class_('INA219PowerSensor', sensor.EmptyPollingParentSensor)
+
+SENSOR_KEYS = [CONF_BUS_VOLTAGE, CONF_SHUNT_VOLTAGE, CONF_CURRENT,
+               CONF_POWER]
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(INA219Component),
+    vol.Optional(CONF_ADDRESS, default=0x40): cv.i2c_address,
+    vol.Optional(CONF_BUS_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA219VoltageSensor),
+    })),
+    vol.Optional(CONF_SHUNT_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA219VoltageSensor),
+    })),
+    vol.Optional(CONF_CURRENT): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA219CurrentSensor),
+    })),
+    vol.Optional(CONF_POWER): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA219PowerSensor),
+    })),
+    vol.Optional(CONF_SHUNT_RESISTANCE, default=0.1): vol.All(cv.resistance,
+                                                              vol.Range(min=0.0, max=32.0)),
+    vol.Optional(CONF_MAX_VOLTAGE, default=32.0): vol.All(cv.voltage, vol.Range(min=0.0, max=32.0)),
+    vol.Optional(CONF_MAX_CURRENT, default=3.2): vol.All(cv.current, vol.Range(min=0.0)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS))
+
+
+def to_code(config):
+    rhs = App.make_ina219(config[CONF_SHUNT_RESISTANCE],
+                          config[CONF_MAX_CURRENT], config[CONF_MAX_VOLTAGE],
+                          config[CONF_ADDRESS], config.get(CONF_UPDATE_INTERVAL))
+    ina = Pvariable(config[CONF_ID], rhs)
+    if CONF_BUS_VOLTAGE in config:
+        conf = config[CONF_BUS_VOLTAGE]
+        sensor.register_sensor(ina.Pmake_bus_voltage_sensor(conf[CONF_NAME]), conf)
+    if CONF_SHUNT_VOLTAGE in config:
+        conf = config[CONF_SHUNT_VOLTAGE]
+        sensor.register_sensor(ina.Pmake_shunt_voltage_sensor(conf[CONF_NAME]), conf)
+    if CONF_CURRENT in config:
+        conf = config[CONF_CURRENT]
+        sensor.register_sensor(ina.Pmake_current_sensor(conf[CONF_NAME]), conf)
+    if CONF_POWER in config:
+        conf = config[CONF_POWER]
+        sensor.register_sensor(ina.Pmake_power_sensor(conf[CONF_NAME]), conf)
+    setup_component(ina, config)
+
+
+BUILD_FLAGS = '-DUSE_INA219'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_BUS_VOLTAGE, CONF_SHUNT_VOLTAGE, CONF_CURRENT, CONF_POWER):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret
--- a/esphome/components/sensor/ina3221.py
+++ b/esphome/components/sensor/ina3221.py
@@ -0,0 +1,91 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_BUS_VOLTAGE, CONF_CURRENT, CONF_ID, CONF_NAME, \
+    CONF_POWER, CONF_SHUNT_RESISTANCE, CONF_SHUNT_VOLTAGE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+CONF_CHANNEL_1 = 'channel_1'
+CONF_CHANNEL_2 = 'channel_2'
+CONF_CHANNEL_3 = 'channel_3'
+
+INA3221Component = sensor.sensor_ns.class_('INA3221Component', PollingComponent, i2c.I2CDevice)
+INA3221VoltageSensor = sensor.sensor_ns.class_('INA3221VoltageSensor',
+                                               sensor.EmptyPollingParentSensor)
+INA3221CurrentSensor = sensor.sensor_ns.class_('INA3221CurrentSensor',
+                                               sensor.EmptyPollingParentSensor)
+INA3221PowerSensor = sensor.sensor_ns.class_('INA3221PowerSensor', sensor.EmptyPollingParentSensor)
+
+SENSOR_KEYS = [CONF_BUS_VOLTAGE, CONF_SHUNT_VOLTAGE, CONF_CURRENT, CONF_POWER]
+
+INA3221_CHANNEL_SCHEMA = vol.All(vol.Schema({
+    vol.Optional(CONF_BUS_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA3221VoltageSensor),
+    })),
+    vol.Optional(CONF_SHUNT_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA3221VoltageSensor),
+    })),
+    vol.Optional(CONF_CURRENT): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA3221CurrentSensor),
+    })),
+    vol.Optional(CONF_POWER): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(INA3221PowerSensor),
+    })),
+    vol.Optional(CONF_SHUNT_RESISTANCE, default=0.1): vol.All(cv.resistance,
+                                                              vol.Range(min=0.0, max=32.0)),
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS))
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(INA3221Component),
+    vol.Optional(CONF_ADDRESS, default=0x40): cv.i2c_address,
+    vol.Optional(CONF_CHANNEL_1): INA3221_CHANNEL_SCHEMA,
+    vol.Optional(CONF_CHANNEL_2): INA3221_CHANNEL_SCHEMA,
+    vol.Optional(CONF_CHANNEL_3): INA3221_CHANNEL_SCHEMA,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+})
+
+
+def to_code(config):
+    rhs = App.make_ina3221(config[CONF_ADDRESS], config.get(CONF_UPDATE_INTERVAL))
+    ina = Pvariable(config[CONF_ID], rhs)
+    for i, channel in enumerate([CONF_CHANNEL_1, CONF_CHANNEL_2, CONF_CHANNEL_3]):
+        if channel not in config:
+            continue
+        conf = config[channel]
+        if CONF_SHUNT_RESISTANCE in conf:
+            add(ina.set_shunt_resistance(i, conf[CONF_SHUNT_RESISTANCE]))
+        if CONF_BUS_VOLTAGE in conf:
+            c = conf[CONF_BUS_VOLTAGE]
+            sensor.register_sensor(ina.Pmake_bus_voltage_sensor(i, c[CONF_NAME]), c)
+        if CONF_SHUNT_VOLTAGE in conf:
+            c = conf[CONF_SHUNT_VOLTAGE]
+            sensor.register_sensor(ina.Pmake_shunt_voltage_sensor(i, c[CONF_NAME]), c)
+        if CONF_CURRENT in conf:
+            c = conf[CONF_CURRENT]
+            sensor.register_sensor(ina.Pmake_current_sensor(i, c[CONF_NAME]), c)
+        if CONF_POWER in conf:
+            c = conf[CONF_POWER]
+            sensor.register_sensor(ina.Pmake_power_sensor(i, c[CONF_NAME]), c)
+
+    setup_component(ina, config)
+
+
+BUILD_FLAGS = '-DUSE_INA3221'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for channel in (CONF_CHANNEL_1, CONF_CHANNEL_2, CONF_CHANNEL_3):
+        if channel not in config:
+            continue
+        conf = config[channel]
+        for key in (CONF_BUS_VOLTAGE, CONF_SHUNT_VOLTAGE, CONF_CURRENT, CONF_POWER):
+            if key in conf:
+                ret.append(sensor.core_to_hass_config(data, conf[key]))
+    return ret
--- a/esphome/components/sensor/max31855.py
+++ b/esphome/components/sensor/max31855.py
@@ -0,0 +1,39 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CS_PIN, CONF_ID, CONF_NAME, CONF_SPI_ID, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App
+
+MAX31855Sensor = sensor.sensor_ns.class_('MAX31855Sensor', sensor.PollingSensorComponent,
+                                         spi.SPIDevice)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MAX31855Sensor),
+    cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
+    vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for spi_ in get_variable(config[CONF_SPI_ID]):
+        yield
+    for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
+        yield
+    rhs = App.make_max31855_sensor(config[CONF_NAME], spi_, cs,
+                                   config.get(CONF_UPDATE_INTERVAL))
+    max31855 = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(max31855, config)
+    setup_component(max31855, config)
+
+
+BUILD_FLAGS = '-DUSE_MAX31855_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/max6675.py
+++ b/esphome/components/sensor/max6675.py
@@ -0,0 +1,40 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor, spi
+from esphome.components.spi import SPIComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CS_PIN, CONF_ID, CONF_NAME, CONF_SPI_ID, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import gpio_output_pin_expression, setup_component
+from esphome.cpp_types import App
+
+MAX6675Sensor = sensor.sensor_ns.class_('MAX6675Sensor', sensor.PollingSensorComponent,
+                                        spi.SPIDevice)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MAX6675Sensor),
+    cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent),
+    vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for spi_ in get_variable(config[CONF_SPI_ID]):
+        yield
+    for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
+        yield
+    rhs = App.make_max6675_sensor(config[CONF_NAME], spi_, cs,
+                                  config.get(CONF_UPDATE_INTERVAL))
+    max6675 = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(max6675, config)
+    setup_component(max6675, config)
+
+
+BUILD_FLAGS = '-DUSE_MAX6675_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/mhz19.py
+++ b/esphome/components/sensor/mhz19.py
@@ -0,0 +1,55 @@
+import voluptuous as vol
+
+from esphome.components import sensor, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_CO2, CONF_ID, CONF_NAME, CONF_TEMPERATURE, CONF_UART_ID, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['uart']
+
+MHZ19Component = sensor.sensor_ns.class_('MHZ19Component', PollingComponent, uart.UARTDevice)
+MHZ19TemperatureSensor = sensor.sensor_ns.class_('MHZ19TemperatureSensor',
+                                                 sensor.EmptyPollingParentSensor)
+MHZ19CO2Sensor = sensor.sensor_ns.class_('MHZ19CO2Sensor', sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MHZ19Component),
+    cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
+    vol.Required(CONF_CO2): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MHZ19CO2Sensor),
+    })),
+    vol.Optional(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MHZ19TemperatureSensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    for uart_ in get_variable(config[CONF_UART_ID]):
+        yield
+    rhs = App.make_mhz19_sensor(uart_, config[CONF_CO2][CONF_NAME],
+                                config.get(CONF_UPDATE_INTERVAL))
+    mhz19 = Pvariable(config[CONF_ID], rhs)
+    sensor.setup_sensor(mhz19.Pget_co2_sensor(), config[CONF_CO2])
+
+    if CONF_TEMPERATURE in config:
+        sensor.register_sensor(mhz19.Pmake_temperature_sensor(config[CONF_TEMPERATURE][CONF_NAME]),
+                               config[CONF_TEMPERATURE])
+
+    setup_component(mhz19, config)
+
+
+BUILD_FLAGS = '-DUSE_MHZ19'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_CO2, CONF_TEMPERATURE):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret
--- a/esphome/components/sensor/mpu6050.py
+++ b/esphome/components/sensor/mpu6050.py
@@ -0,0 +1,101 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+CONF_ACCEL_X = 'accel_x'
+CONF_ACCEL_Y = 'accel_y'
+CONF_ACCEL_Z = 'accel_z'
+CONF_GYRO_X = 'gyro_x'
+CONF_GYRO_Y = 'gyro_y'
+CONF_GYRO_Z = 'gyro_z'
+
+MPU6050Component = sensor.sensor_ns.class_('MPU6050Component', PollingComponent, i2c.I2CDevice)
+MPU6050AccelSensor = sensor.sensor_ns.class_('MPU6050AccelSensor', sensor.EmptyPollingParentSensor)
+MPU6050GyroSensor = sensor.sensor_ns.class_('MPU6050GyroSensor', sensor.EmptyPollingParentSensor)
+MPU6050TemperatureSensor = sensor.sensor_ns.class_('MPU6050TemperatureSensor',
+                                                   sensor.EmptyPollingParentSensor)
+
+SENSOR_KEYS = [CONF_ACCEL_X, CONF_ACCEL_Y, CONF_ACCEL_Z,
+               CONF_GYRO_X, CONF_GYRO_Y, CONF_GYRO_Z]
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MPU6050Component),
+    vol.Optional(CONF_ADDRESS, default=0x68): cv.i2c_address,
+    vol.Optional(CONF_ACCEL_X): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050AccelSensor),
+    })),
+    vol.Optional(CONF_ACCEL_Y): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050AccelSensor),
+    })),
+    vol.Optional(CONF_ACCEL_Z): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050AccelSensor),
+    })),
+    vol.Optional(CONF_GYRO_X): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050GyroSensor),
+    })),
+    vol.Optional(CONF_GYRO_Y): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050GyroSensor),
+    })),
+    vol.Optional(CONF_GYRO_Z): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050GyroSensor),
+    })),
+    vol.Optional(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MPU6050TemperatureSensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS))
+
+
+def to_code(config):
+    rhs = App.make_mpu6050_sensor(config[CONF_ADDRESS], config.get(CONF_UPDATE_INTERVAL))
+    mpu = Pvariable(config[CONF_ID], rhs)
+    if CONF_ACCEL_X in config:
+        conf = config[CONF_ACCEL_X]
+        rhs = mpu.Pmake_accel_x_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+    if CONF_ACCEL_Y in config:
+        conf = config[CONF_ACCEL_Y]
+        rhs = mpu.Pmake_accel_y_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+    if CONF_ACCEL_Z in config:
+        conf = config[CONF_ACCEL_Z]
+        rhs = mpu.Pmake_accel_z_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+    if CONF_GYRO_X in config:
+        conf = config[CONF_GYRO_X]
+        rhs = mpu.Pmake_gyro_x_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+    if CONF_GYRO_Y in config:
+        conf = config[CONF_GYRO_Y]
+        rhs = mpu.Pmake_gyro_y_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+    if CONF_GYRO_Z in config:
+        conf = config[CONF_GYRO_Z]
+        rhs = mpu.Pmake_gyro_z_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+    if CONF_TEMPERATURE in config:
+        conf = config[CONF_TEMPERATURE]
+        rhs = mpu.Pmake_temperature_sensor(conf[CONF_NAME])
+        sensor.register_sensor(rhs, conf)
+
+    setup_component(mpu, config)
+
+
+BUILD_FLAGS = '-DUSE_MPU6050'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_ACCEL_X, CONF_ACCEL_Y, CONF_ACCEL_Z, CONF_GYRO_X, CONF_GYRO_Y, CONF_GYRO_Z,
+                CONF_TEMPERATURE):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret
--- a/esphome/components/sensor/mqtt_subscribe.py
+++ b/esphome/components/sensor/mqtt_subscribe.py
@@ -0,0 +1,36 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_QOS, CONF_TOPIC
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['mqtt']
+
+MQTTSubscribeSensor = sensor.sensor_ns.class_('MQTTSubscribeSensor', sensor.Sensor, Component)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MQTTSubscribeSensor),
+    vol.Required(CONF_TOPIC): cv.subscribe_topic,
+    vol.Optional(CONF_QOS): cv.mqtt_qos,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_mqtt_subscribe_sensor(config[CONF_NAME], config[CONF_TOPIC])
+    subs = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_QOS in config:
+        add(subs.set_qos(config[CONF_QOS]))
+
+    sensor.setup_sensor(subs, config)
+    setup_component(subs, config)
+
+
+BUILD_FLAGS = '-DUSE_MQTT_SUBSCRIBE_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/ms5611.py
+++ b/esphome/components/sensor/ms5611.py
@@ -0,0 +1,51 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_ID, CONF_NAME, CONF_PRESSURE, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+MS5611Component = sensor.sensor_ns.class_('MS5611Component', PollingComponent, i2c.I2CDevice)
+MS5611TemperatureSensor = sensor.sensor_ns.class_('MS5611TemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+MS5611PressureSensor = sensor.sensor_ns.class_('MS5611PressureSensor',
+                                               sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(MS5611Component),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MS5611TemperatureSensor),
+    })),
+    vol.Required(CONF_PRESSURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(MS5611PressureSensor),
+    })),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_ms5611_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_PRESSURE][CONF_NAME],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    ms5611 = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_ADDRESS in config:
+        add(ms5611.set_address(config[CONF_ADDRESS]))
+
+    sensor.setup_sensor(ms5611.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(ms5611.Pget_pressure_sensor(), config[CONF_PRESSURE])
+    setup_component(ms5611, config)
+
+
+BUILD_FLAGS = '-DUSE_MS5611'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_PRESSURE])]
--- a/esphome/components/sensor/pmsx003.py
+++ b/esphome/components/sensor/pmsx003.py
@@ -0,0 +1,106 @@
+import voluptuous as vol
+
+from esphome.components import sensor, uart
+from esphome.components.uart import UARTComponent
+import esphome.config_validation as cv
+from esphome.const import CONF_FORMALDEHYDE, CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_PM_10_0, \
+    CONF_PM_1_0, CONF_PM_2_5, CONF_TEMPERATURE, CONF_TYPE, CONF_UART_ID
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['uart']
+
+PMSX003Component = sensor.sensor_ns.class_('PMSX003Component', uart.UARTDevice, Component)
+PMSX003Sensor = sensor.sensor_ns.class_('PMSX003Sensor', sensor.Sensor)
+
+CONF_PMSX003 = 'PMSX003'
+CONF_PMS5003T = 'PMS5003T'
+CONF_PMS5003ST = 'PMS5003ST'
+
+PMSX003Type = sensor.sensor_ns.enum('PMSX003Type')
+PMSX003_TYPES = {
+    CONF_PMSX003: PMSX003Type.PMSX003_TYPE_X003,
+    CONF_PMS5003T: PMSX003Type.PMSX003_TYPE_5003T,
+    CONF_PMS5003ST: PMSX003Type.PMSX003_TYPE_5003ST,
+}
+
+SENSORS_TO_TYPE = {
+    CONF_PM_1_0: [CONF_PMSX003],
+    CONF_PM_2_5: [CONF_PMSX003, CONF_PMS5003T, CONF_PMS5003ST],
+    CONF_PM_10_0: [CONF_PMSX003],
+    CONF_TEMPERATURE: [CONF_PMS5003T, CONF_PMS5003ST],
+    CONF_HUMIDITY: [CONF_PMS5003T, CONF_PMS5003ST],
+    CONF_FORMALDEHYDE: [CONF_PMS5003ST],
+}
+
+
+def validate_pmsx003_sensors(value):
+    for key, types in SENSORS_TO_TYPE.items():
+        if key in value and value[CONF_TYPE] not in types:
+            raise vol.Invalid(u"{} does not have {} sensor!".format(value[CONF_TYPE], key))
+    return value
+
+
+PMSX003_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(PMSX003Sensor),
+})
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(PMSX003Component),
+    cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
+    vol.Required(CONF_TYPE): cv.one_of(*PMSX003_TYPES, upper=True),
+
+    vol.Optional(CONF_PM_1_0): cv.nameable(PMSX003_SENSOR_SCHEMA),
+    vol.Optional(CONF_PM_2_5): cv.nameable(PMSX003_SENSOR_SCHEMA),
+    vol.Optional(CONF_PM_10_0): cv.nameable(PMSX003_SENSOR_SCHEMA),
+    vol.Optional(CONF_TEMPERATURE): cv.nameable(PMSX003_SENSOR_SCHEMA),
+    vol.Optional(CONF_HUMIDITY): cv.nameable(PMSX003_SENSOR_SCHEMA),
+    vol.Optional(CONF_FORMALDEHYDE): cv.nameable(PMSX003_SENSOR_SCHEMA),
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSORS_TO_TYPE))
+
+
+def to_code(config):
+    for uart_ in get_variable(config[CONF_UART_ID]):
+        yield
+
+    rhs = App.make_pmsx003(uart_, PMSX003_TYPES[config[CONF_TYPE]])
+    pms = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_PM_1_0 in config:
+        conf = config[CONF_PM_1_0]
+        sensor.register_sensor(pms.make_pm_1_0_sensor(conf[CONF_NAME]), conf)
+
+    if CONF_PM_2_5 in config:
+        conf = config[CONF_PM_2_5]
+        sensor.register_sensor(pms.make_pm_2_5_sensor(conf[CONF_NAME]), conf)
+
+    if CONF_PM_10_0 in config:
+        conf = config[CONF_PM_10_0]
+        sensor.register_sensor(pms.make_pm_10_0_sensor(conf[CONF_NAME]), conf)
+
+    if CONF_TEMPERATURE in config:
+        conf = config[CONF_TEMPERATURE]
+        sensor.register_sensor(pms.make_temperature_sensor(conf[CONF_NAME]), conf)
+
+    if CONF_HUMIDITY in config:
+        conf = config[CONF_HUMIDITY]
+        sensor.register_sensor(pms.make_humidity_sensor(conf[CONF_NAME]), conf)
+
+    if CONF_FORMALDEHYDE in config:
+        conf = config[CONF_FORMALDEHYDE]
+        sensor.register_sensor(pms.make_formaldehyde_sensor(conf[CONF_NAME]), conf)
+
+    setup_component(pms, config)
+
+
+BUILD_FLAGS = '-DUSE_PMSX003'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_PM_1_0, CONF_PM_2_5, CONF_PM_10_0, CONF_TEMPERATURE, CONF_HUMIDITY,
+                CONF_FORMALDEHYDE):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret
--- a/esphome/components/sensor/pulse_counter.py
+++ b/esphome/components/sensor/pulse_counter.py
@@ -0,0 +1,75 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_COUNT_MODE, CONF_FALLING_EDGE, CONF_ID, CONF_INTERNAL_FILTER, \
+    CONF_NAME, CONF_PIN, CONF_RISING_EDGE, CONF_UPDATE_INTERVAL
+from esphome.core import CORE
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App
+
+PulseCounterCountMode = sensor.sensor_ns.enum('PulseCounterCountMode')
+COUNT_MODES = {
+    'DISABLE': PulseCounterCountMode.PULSE_COUNTER_DISABLE,
+    'INCREMENT': PulseCounterCountMode.PULSE_COUNTER_INCREMENT,
+    'DECREMENT': PulseCounterCountMode.PULSE_COUNTER_DECREMENT,
+}
+
+COUNT_MODE_SCHEMA = cv.one_of(*COUNT_MODES, upper=True)
+
+PulseCounterBase = sensor.sensor_ns.class_('PulseCounterBase')
+PulseCounterSensorComponent = sensor.sensor_ns.class_('PulseCounterSensorComponent',
+                                                      sensor.PollingSensorComponent,
+                                                      PulseCounterBase)
+
+
+def validate_internal_filter(value):
+    if CORE.is_esp32:
+        if isinstance(value, int):
+            raise vol.Invalid("Please specify the internal filter in microseconds now "
+                              "(since 1.7.0). For example '17ms'")
+        value = cv.positive_time_period_microseconds(value)
+        if value.total_microseconds > 13:
+            raise vol.Invalid("Maximum internal filter value for ESP32 is 13us")
+        return value
+
+    return cv.positive_time_period_microseconds(value)
+
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(PulseCounterSensorComponent),
+    vol.Required(CONF_PIN): pins.internal_gpio_input_pin_schema,
+    vol.Optional(CONF_COUNT_MODE): vol.Schema({
+        vol.Required(CONF_RISING_EDGE): COUNT_MODE_SCHEMA,
+        vol.Required(CONF_FALLING_EDGE): COUNT_MODE_SCHEMA,
+    }),
+    vol.Optional(CONF_INTERNAL_FILTER): validate_internal_filter,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for pin in gpio_input_pin_expression(config[CONF_PIN]):
+        yield
+    rhs = App.make_pulse_counter_sensor(config[CONF_NAME], pin,
+                                        config.get(CONF_UPDATE_INTERVAL))
+    pcnt = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_COUNT_MODE in config:
+        rising_edge = COUNT_MODES[config[CONF_COUNT_MODE][CONF_RISING_EDGE]]
+        falling_edge = COUNT_MODES[config[CONF_COUNT_MODE][CONF_FALLING_EDGE]]
+        add(pcnt.set_edge_mode(rising_edge, falling_edge))
+    if CONF_INTERNAL_FILTER in config:
+        add(pcnt.set_filter_us(config[CONF_INTERNAL_FILTER]))
+
+    sensor.setup_sensor(pcnt, config)
+    setup_component(pcnt, config)
+
+
+BUILD_FLAGS = '-DUSE_PULSE_COUNTER_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/rotary_encoder.py
+++ b/esphome/components/sensor/rotary_encoder.py
@@ -0,0 +1,57 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_RESOLUTION
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, setup_component
+from esphome.cpp_types import App, Component
+
+RotaryEncoderResolution = sensor.sensor_ns.enum('RotaryEncoderResolution')
+RESOLUTIONS = {
+    '1': RotaryEncoderResolution.ROTARY_ENCODER_1_PULSE_PER_CYCLE,
+    '2': RotaryEncoderResolution.ROTARY_ENCODER_2_PULSES_PER_CYCLE,
+    '4': RotaryEncoderResolution.ROTARY_ENCODER_4_PULSES_PER_CYCLE,
+}
+
+CONF_PIN_A = 'pin_a'
+CONF_PIN_B = 'pin_b'
+CONF_PIN_RESET = 'pin_reset'
+
+RotaryEncoderSensor = sensor.sensor_ns.class_('RotaryEncoderSensor', sensor.Sensor, Component)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(RotaryEncoderSensor),
+    vol.Required(CONF_PIN_A): pins.internal_gpio_input_pin_schema,
+    vol.Required(CONF_PIN_B): pins.internal_gpio_input_pin_schema,
+    vol.Optional(CONF_PIN_RESET): pins.internal_gpio_input_pin_schema,
+    vol.Optional(CONF_RESOLUTION): cv.one_of(*RESOLUTIONS, string=True),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for pin_a in gpio_input_pin_expression(config[CONF_PIN_A]):
+        yield
+    for pin_b in gpio_input_pin_expression(config[CONF_PIN_B]):
+        yield
+    rhs = App.make_rotary_encoder_sensor(config[CONF_NAME], pin_a, pin_b)
+    encoder = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_PIN_RESET in config:
+        for pin_i in gpio_input_pin_expression(config[CONF_PIN_RESET]):
+            yield
+        add(encoder.set_reset_pin(pin_i))
+    if CONF_RESOLUTION in config:
+        resolution = RESOLUTIONS[config[CONF_RESOLUTION]]
+        add(encoder.set_resolution(resolution))
+
+    sensor.setup_sensor(encoder, config)
+    setup_component(encoder, config)
+
+
+BUILD_FLAGS = '-DUSE_ROTARY_ENCODER_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/sht3xd.py
+++ b/esphome/components/sensor/sht3xd.py
@@ -0,0 +1,49 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_HUMIDITY, CONF_ID, CONF_NAME, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+SHT3XDComponent = sensor.sensor_ns.class_('SHT3XDComponent', PollingComponent, i2c.I2CDevice)
+SHT3XDTemperatureSensor = sensor.sensor_ns.class_('SHT3XDTemperatureSensor',
+                                                  sensor.EmptyPollingParentSensor)
+SHT3XDHumiditySensor = sensor.sensor_ns.class_('SHT3XDHumiditySensor',
+                                               sensor.EmptyPollingParentSensor)
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(SHT3XDComponent),
+    vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(SHT3XDTemperatureSensor),
+    })),
+    vol.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(SHT3XDHumiditySensor),
+    })),
+    vol.Optional(CONF_ADDRESS, default=0x44): cv.i2c_address,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_sht3xd_sensor(config[CONF_TEMPERATURE][CONF_NAME],
+                                 config[CONF_HUMIDITY][CONF_NAME],
+                                 config[CONF_ADDRESS],
+                                 config.get(CONF_UPDATE_INTERVAL))
+    sht3xd = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(sht3xd.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_sensor(sht3xd.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    setup_component(sht3xd, config)
+
+
+BUILD_FLAGS = '-DUSE_SHT3XD'
+
+
+def to_hass_config(data, config):
+    return [sensor.core_to_hass_config(data, config[CONF_TEMPERATURE]),
+            sensor.core_to_hass_config(data, config[CONF_HUMIDITY])]
--- a/esphome/components/sensor/tcs34725.py
+++ b/esphome/components/sensor/tcs34725.py
@@ -0,0 +1,113 @@
+# coding=utf-8
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_COLOR_TEMPERATURE, CONF_GAIN, CONF_ID, \
+    CONF_ILLUMINANCE, CONF_INTEGRATION_TIME, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, PollingComponent
+
+DEPENDENCIES = ['i2c']
+
+CONF_RED_CHANNEL = 'red_channel'
+CONF_GREEN_CHANNEL = 'green_channel'
+CONF_BLUE_CHANNEL = 'blue_channel'
+CONF_CLEAR_CHANNEL = 'clear_channel'
+
+TCS34725Component = sensor.sensor_ns.class_('TCS34725Component', PollingComponent,
+                                            i2c.I2CDevice)
+
+TCS34725IntegrationTime = sensor.sensor_ns.enum('TCS34725IntegrationTime')
+TCS34725_INTEGRATION_TIMES = {
+    '2.4ms': TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_2_4MS,
+    '24ms': TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_24MS,
+    '50ms': TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_50MS,
+    '101ms': TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_101MS,
+    '154ms': TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_154MS,
+    '700ms': TCS34725IntegrationTime.TCS34725_INTEGRATION_TIME_700MS,
+}
+
+TCS34725Gain = sensor.sensor_ns.enum('TCS34725Gain')
+TCS34725_GAINS = {
+    '1X': TCS34725Gain.TCS34725_GAIN_1X,
+    '4X': TCS34725Gain.TCS34725_GAIN_4X,
+    '16X': TCS34725Gain.TCS34725_GAIN_16X,
+    '60X': TCS34725Gain.TCS34725_GAIN_60X,
+}
+
+TCS35725IlluminanceSensor = sensor.sensor_ns.class_('TCS35725IlluminanceSensor',
+                                                    sensor.EmptyPollingParentSensor)
+TCS35725ColorTemperatureSensor = sensor.sensor_ns.class_('TCS35725ColorTemperatureSensor',
+                                                         sensor.EmptyPollingParentSensor)
+TCS35725ColorChannelSensor = sensor.sensor_ns.class_('TCS35725ColorChannelSensor',
+                                                     sensor.EmptyPollingParentSensor)
+
+COLOR_CHANNEL_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TCS35725ColorChannelSensor),
+})
+
+SENSOR_KEYS = [CONF_RED_CHANNEL, CONF_GREEN_CHANNEL, CONF_BLUE_CHANNEL,
+               CONF_CLEAR_CHANNEL, CONF_ILLUMINANCE, CONF_COLOR_TEMPERATURE]
+
+PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TCS34725Component),
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+    vol.Optional(CONF_RED_CHANNEL): cv.nameable(COLOR_CHANNEL_SENSOR_SCHEMA),
+    vol.Optional(CONF_GREEN_CHANNEL): cv.nameable(COLOR_CHANNEL_SENSOR_SCHEMA),
+    vol.Optional(CONF_BLUE_CHANNEL): cv.nameable(COLOR_CHANNEL_SENSOR_SCHEMA),
+    vol.Optional(CONF_CLEAR_CHANNEL): cv.nameable(COLOR_CHANNEL_SENSOR_SCHEMA),
+    vol.Optional(CONF_ILLUMINANCE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(TCS35725IlluminanceSensor),
+    })),
+    vol.Optional(CONF_COLOR_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
+        cv.GenerateID(): cv.declare_variable_id(TCS35725ColorTemperatureSensor),
+    })),
+    vol.Optional(CONF_INTEGRATION_TIME): cv.one_of(*TCS34725_INTEGRATION_TIMES, lower=True),
+    vol.Optional(CONF_GAIN): vol.All(vol.Upper, cv.one_of(*TCS34725_GAINS), upper=True),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS))
+
+
+def to_code(config):
+    rhs = App.make_tcs34725(config.get(CONF_UPDATE_INTERVAL))
+    tcs = Pvariable(config[CONF_ID], rhs)
+    if CONF_ADDRESS in config:
+        add(tcs.set_address(config[CONF_ADDRESS]))
+    if CONF_INTEGRATION_TIME in config:
+        add(tcs.set_integration_time(TCS34725_INTEGRATION_TIMES[config[CONF_INTEGRATION_TIME]]))
+    if CONF_GAIN in config:
+        add(tcs.set_gain(TCS34725_GAINS[config[CONF_GAIN]]))
+    if CONF_RED_CHANNEL in config:
+        conf = config[CONF_RED_CHANNEL]
+        sensor.register_sensor(tcs.Pmake_red_sensor(conf[CONF_NAME]), conf)
+    if CONF_GREEN_CHANNEL in config:
+        conf = config[CONF_GREEN_CHANNEL]
+        sensor.register_sensor(tcs.Pmake_green_sensor(conf[CONF_NAME]), conf)
+    if CONF_BLUE_CHANNEL in config:
+        conf = config[CONF_BLUE_CHANNEL]
+        sensor.register_sensor(tcs.Pmake_blue_sensor(conf[CONF_NAME]), conf)
+    if CONF_CLEAR_CHANNEL in config:
+        conf = config[CONF_CLEAR_CHANNEL]
+        sensor.register_sensor(tcs.Pmake_clear_sensor(conf[CONF_NAME]), conf)
+    if CONF_ILLUMINANCE in config:
+        conf = config[CONF_ILLUMINANCE]
+        sensor.register_sensor(tcs.Pmake_illuminance_sensor(conf[CONF_NAME]), conf)
+    if CONF_COLOR_TEMPERATURE in config:
+        conf = config[CONF_COLOR_TEMPERATURE]
+        sensor.register_sensor(tcs.Pmake_color_temperature_sensor(conf[CONF_NAME]), conf)
+
+    setup_component(tcs, config)
+
+
+BUILD_FLAGS = '-DUSE_TCS34725'
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_RED_CHANNEL, CONF_GREEN_CHANNEL, CONF_BLUE_CHANNEL, CONF_CLEAR_CHANNEL,
+                CONF_ILLUMINANCE, CONF_COLOR_TEMPERATURE):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret
--- a/esphome/components/sensor/template.py
+++ b/esphome/components/sensor/template.py
@@ -0,0 +1,57 @@
+import voluptuous as vol
+
+from esphome.automation import ACTION_REGISTRY
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_STATE, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import Action, App, float_, optional
+
+TemplateSensor = sensor.sensor_ns.class_('TemplateSensor', sensor.PollingSensorComponent)
+SensorPublishAction = sensor.sensor_ns.class_('SensorPublishAction', Action)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TemplateSensor),
+    vol.Required(CONF_LAMBDA): cv.lambda_,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_template_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    template = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(template, config)
+    setup_component(template, config)
+
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=optional.template(float_)):
+        yield
+    add(template.set_template(template_))
+
+
+BUILD_FLAGS = '-DUSE_TEMPLATE_SENSOR'
+
+CONF_SENSOR_TEMPLATE_PUBLISH = 'sensor.template.publish'
+SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA = vol.Schema({
+    vol.Required(CONF_ID): cv.use_variable_id(sensor.Sensor),
+    vol.Required(CONF_STATE): cv.templatable(cv.float_),
+})
+
+
+@ACTION_REGISTRY.register(CONF_SENSOR_TEMPLATE_PUBLISH, SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA)
+def sensor_template_publish_to_code(config, action_id, arg_type, template_arg):
+    for var in get_variable(config[CONF_ID]):
+        yield None
+    rhs = var.make_sensor_publish_action(template_arg)
+    type = SensorPublishAction.template(arg_type)
+    action = Pvariable(action_id, rhs, type=type)
+    for template_ in templatable(config[CONF_STATE], arg_type, float_):
+        yield None
+    add(action.set_state(template_))
+    yield action
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/total_daily_energy.py
+++ b/esphome/components/sensor/total_daily_energy.py
@@ -0,0 +1,38 @@
+import voluptuous as vol
+
+from esphome.components import sensor, time
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_TIME_ID
+from esphome.cpp_generator import Pvariable, get_variable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App, Component
+
+DEPENDENCIES = ['time']
+
+CONF_POWER_ID = 'power_id'
+TotalDailyEnergy = sensor.sensor_ns.class_('TotalDailyEnergy', sensor.Sensor, Component)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TotalDailyEnergy),
+    cv.GenerateID(CONF_TIME_ID): cv.use_variable_id(time.RealTimeClockComponent),
+    vol.Required(CONF_POWER_ID): cv.use_variable_id(sensor.Sensor),
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    for time_ in get_variable(config[CONF_TIME_ID]):
+        yield
+    for sens in get_variable(config[CONF_POWER_ID]):
+        yield
+    rhs = App.make_total_daily_energy_sensor(config[CONF_NAME], time_, sens)
+    total_energy = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(total_energy, config)
+    setup_component(total_energy, config)
+
+
+BUILD_FLAGS = '-DUSE_TOTAL_DAILY_ENERGY_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/tsl2561.py
+++ b/esphome/components/sensor/tsl2561.py
@@ -0,0 +1,69 @@
+import voluptuous as vol
+
+from esphome.components import i2c, sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ADDRESS, CONF_GAIN, CONF_ID, CONF_INTEGRATION_TIME, CONF_NAME, \
+    CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+DEPENDENCIES = ['i2c']
+
+TSL2561IntegrationTime = sensor.sensor_ns.enum('TSL2561IntegrationTime')
+INTEGRATION_TIMES = {
+    14: TSL2561IntegrationTime.TSL2561_INTEGRATION_14MS,
+    101: TSL2561IntegrationTime.TSL2561_INTEGRATION_101MS,
+    402: TSL2561IntegrationTime.TSL2561_INTEGRATION_402MS,
+}
+
+TSL2561Gain = sensor.sensor_ns.enum('TSL2561Gain')
+GAINS = {
+    '1X': TSL2561Gain.TSL2561_GAIN_1X,
+    '16X': TSL2561Gain.TSL2561_GAIN_16X,
+}
+
+CONF_IS_CS_PACKAGE = 'is_cs_package'
+
+
+def validate_integration_time(value):
+    value = cv.positive_time_period_milliseconds(value).total_milliseconds
+    if value not in INTEGRATION_TIMES:
+        raise vol.Invalid(u"Unsupported integration time {}.".format(value))
+    return value
+
+
+TSL2561Sensor = sensor.sensor_ns.class_('TSL2561Sensor', sensor.PollingSensorComponent,
+                                        i2c.I2CDevice)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(TSL2561Sensor),
+    vol.Optional(CONF_ADDRESS, default=0x39): cv.i2c_address,
+    vol.Optional(CONF_INTEGRATION_TIME): validate_integration_time,
+    vol.Optional(CONF_GAIN): cv.one_of(*GAINS, upper=True),
+    vol.Optional(CONF_IS_CS_PACKAGE): cv.boolean,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_tsl2561_sensor(config[CONF_NAME], config[CONF_ADDRESS],
+                                  config.get(CONF_UPDATE_INTERVAL))
+    tsl2561 = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_INTEGRATION_TIME in config:
+        add(tsl2561.set_integration_time(INTEGRATION_TIMES[config[CONF_INTEGRATION_TIME]]))
+    if CONF_GAIN in config:
+        add(tsl2561.set_gain(GAINS[config[CONF_GAIN]]))
+    if CONF_IS_CS_PACKAGE in config:
+        add(tsl2561.set_is_cs_package(config[CONF_IS_CS_PACKAGE]))
+
+    sensor.setup_sensor(tsl2561, config)
+    setup_component(tsl2561, config)
+
+
+BUILD_FLAGS = '-DUSE_TSL2561'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/ultrasonic.py
+++ b/esphome/components/sensor/ultrasonic.py
@@ -0,0 +1,48 @@
+import voluptuous as vol
+
+from esphome import pins
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ECHO_PIN, CONF_ID, CONF_NAME, CONF_TIMEOUT_METER, \
+    CONF_TIMEOUT_TIME, CONF_TRIGGER_PIN, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable, add
+from esphome.cpp_helpers import gpio_input_pin_expression, gpio_output_pin_expression, \
+    setup_component
+from esphome.cpp_types import App
+
+UltrasonicSensorComponent = sensor.sensor_ns.class_('UltrasonicSensorComponent',
+                                                    sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(UltrasonicSensorComponent),
+    vol.Required(CONF_TRIGGER_PIN): pins.gpio_output_pin_schema,
+    vol.Required(CONF_ECHO_PIN): pins.internal_gpio_input_pin_schema,
+    vol.Exclusive(CONF_TIMEOUT_METER, 'timeout'): cv.positive_float,
+    vol.Exclusive(CONF_TIMEOUT_TIME, 'timeout'): cv.positive_time_period_microseconds,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}))
+
+
+def to_code(config):
+    for trigger in gpio_output_pin_expression(config[CONF_TRIGGER_PIN]):
+        yield
+    for echo in gpio_input_pin_expression(config[CONF_ECHO_PIN]):
+        yield
+    rhs = App.make_ultrasonic_sensor(config[CONF_NAME], trigger, echo,
+                                     config.get(CONF_UPDATE_INTERVAL))
+    ultrasonic = Pvariable(config[CONF_ID], rhs)
+
+    if CONF_TIMEOUT_TIME in config:
+        add(ultrasonic.set_timeout_us(config[CONF_TIMEOUT_TIME]))
+    elif CONF_TIMEOUT_METER in config:
+        add(ultrasonic.set_timeout_m(config[CONF_TIMEOUT_METER]))
+
+    sensor.setup_sensor(ultrasonic, config)
+    setup_component(ultrasonic, config)
+
+
+BUILD_FLAGS = '-DUSE_ULTRASONIC_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/uptime.py
+++ b/esphome/components/sensor/uptime.py
@@ -0,0 +1,30 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+UptimeSensor = sensor.sensor_ns.class_('UptimeSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(UptimeSensor),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_uptime_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    uptime = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(uptime, config)
+    setup_component(uptime, config)
+
+
+BUILD_FLAGS = '-DUSE_UPTIME_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/wifi_signal.py
+++ b/esphome/components/sensor/wifi_signal.py
@@ -0,0 +1,30 @@
+import voluptuous as vol
+
+from esphome.components import sensor
+import esphome.config_validation as cv
+from esphome.const import CONF_ID, CONF_NAME, CONF_UPDATE_INTERVAL
+from esphome.cpp_generator import Pvariable
+from esphome.cpp_helpers import setup_component
+from esphome.cpp_types import App
+
+WiFiSignalSensor = sensor.sensor_ns.class_('WiFiSignalSensor', sensor.PollingSensorComponent)
+
+PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(WiFiSignalSensor),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
+}).extend(cv.COMPONENT_SCHEMA.schema))
+
+
+def to_code(config):
+    rhs = App.make_wifi_signal_sensor(config[CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    wifi = Pvariable(config[CONF_ID], rhs)
+
+    sensor.setup_sensor(wifi, config)
+    setup_component(wifi, config)
+
+
+BUILD_FLAGS = '-DUSE_WIFI_SIGNAL_SENSOR'
+
+
+def to_hass_config(data, config):
+    return sensor.core_to_hass_config(data, config)
--- a/esphome/components/sensor/xiaomi_miflora.py
+++ b/esphome/components/sensor/xiaomi_miflora.py
@@ -0,0 +1,53 @@
+import voluptuous as vol
+
+from esphome.components import esp32_ble_tracker, sensor
+from esphome.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+    make_address_array
+import esphome.config_validation as cv
+from esphome.const import CONF_BATTERY_LEVEL, CONF_CONDUCTIVITY, CONF_ID, CONF_ILLUMINANCE, \
+    CONF_MAC_ADDRESS, CONF_MOISTURE, CONF_NAME, CONF_TEMPERATURE
+from esphome.cpp_generator import Pvariable, get_variable
+
+DEPENDENCIES = ['esp32_ble_tracker']
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(): cv.declare_variable_id(esp32_ble_tracker.XiaomiDevice),
+    cv.GenerateID(CONF_ESP32_BLE_ID): cv.use_variable_id(ESP32BLETracker),
+    vol.Required(CONF_MAC_ADDRESS): cv.mac_address,
+    vol.Optional(CONF_TEMPERATURE): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+    vol.Optional(CONF_MOISTURE): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+    vol.Optional(CONF_ILLUMINANCE): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+    vol.Optional(CONF_CONDUCTIVITY): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+    vol.Optional(CONF_BATTERY_LEVEL): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+})
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_ESP32_BLE_ID]):
+        yield
+    rhs = hub.make_xiaomi_device(make_address_array(config[CONF_MAC_ADDRESS]))
+    dev = Pvariable(config[CONF_ID], rhs)
+    if CONF_TEMPERATURE in config:
+        conf = config[CONF_TEMPERATURE]
+        sensor.register_sensor(dev.Pmake_temperature_sensor(conf[CONF_NAME]), conf)
+    if CONF_MOISTURE in config:
+        conf = config[CONF_MOISTURE]
+        sensor.register_sensor(dev.Pmake_moisture_sensor(conf[CONF_NAME]), conf)
+    if CONF_ILLUMINANCE in config:
+        conf = config[CONF_ILLUMINANCE]
+        sensor.register_sensor(dev.Pmake_illuminance_sensor(conf[CONF_NAME]), conf)
+    if CONF_CONDUCTIVITY in config:
+        conf = config[CONF_CONDUCTIVITY]
+        sensor.register_sensor(dev.Pmake_conductivity_sensor(conf[CONF_NAME]), conf)
+    if CONF_BATTERY_LEVEL in config:
+        conf = config[CONF_BATTERY_LEVEL]
+        sensor.register_sensor(dev.Pmake_battery_level_sensor(conf[CONF_NAME]), conf)
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_TEMPERATURE, CONF_MOISTURE, CONF_ILLUMINANCE, CONF_CONDUCTIVITY,
+                CONF_BATTERY_LEVEL):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret
--- a/esphome/components/sensor/xiaomi_mijia.py
+++ b/esphome/components/sensor/xiaomi_mijia.py
@@ -0,0 +1,44 @@
+import voluptuous as vol
+
+from esphome.components import esp32_ble_tracker, sensor
+from esphome.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
+    make_address_array
+import esphome.config_validation as cv
+from esphome.const import CONF_BATTERY_LEVEL, CONF_HUMIDITY, CONF_MAC_ADDRESS, CONF_MAKE_ID, \
+    CONF_NAME, CONF_TEMPERATURE
+from esphome.cpp_generator import Pvariable, get_variable
+
+DEPENDENCIES = ['esp32_ble_tracker']
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(esp32_ble_tracker.XiaomiDevice),
+    cv.GenerateID(CONF_ESP32_BLE_ID): cv.use_variable_id(ESP32BLETracker),
+    vol.Required(CONF_MAC_ADDRESS): cv.mac_address,
+    vol.Optional(CONF_TEMPERATURE): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+    vol.Optional(CONF_HUMIDITY): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+    vol.Optional(CONF_BATTERY_LEVEL): cv.nameable(esp32_ble_tracker.XIAOMI_SENSOR_SCHEMA),
+})
+
+
+def to_code(config):
+    for hub in get_variable(config[CONF_ESP32_BLE_ID]):
+        yield
+    rhs = hub.make_xiaomi_device(make_address_array(config[CONF_MAC_ADDRESS]))
+    dev = Pvariable(config[CONF_MAKE_ID], rhs)
+    if CONF_TEMPERATURE in config:
+        conf = config[CONF_TEMPERATURE]
+        sensor.register_sensor(dev.Pmake_temperature_sensor(conf[CONF_NAME]), conf)
+    if CONF_HUMIDITY in config:
+        conf = config[CONF_HUMIDITY]
+        sensor.register_sensor(dev.Pmake_humidity_sensor(conf[CONF_NAME]), conf)
+    if CONF_BATTERY_LEVEL in config:
+        conf = config[CONF_BATTERY_LEVEL]
+        sensor.register_sensor(dev.Pmake_battery_level_sensor(conf[CONF_NAME]), conf)
+
+
+def to_hass_config(data, config):
+    ret = []
+    for key in (CONF_TEMPERATURE, CONF_HUMIDITY, CONF_BATTERY_LEVEL):
+        if key in config:
+            ret.append(sensor.core_to_hass_config(data, config[key]))
+    return ret