Initial Commit 🎉

esphomeyaml/components/sensor/__init__.py

@@ -0,0 +1,100 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.const import CONF_ACCURACY_DECIMALS, CONF_ALPHA, CONF_EXPIRE_AFTER, \
+    CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_FILTERS, CONF_FILTER_NAN, CONF_FILTER_OUT, CONF_ICON, \
+    CONF_ID, CONF_LAMBDA, CONF_MULTIPLY, CONF_NAME, CONF_OFFSET, CONF_SEND_EVERY, \
+    CONF_SLIDING_WINDOW_MOVING_AVERAGE, CONF_UNIT_OF_MEASUREMENT, CONF_WINDOW_SIZE
+from esphomeyaml.helpers import App, ArrayInitializer, MockObj, Pvariable, RawExpression, add, \
+    setup_mqtt_component
+
+PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
+
+})
+
+FILTERS_SCHEMA = vol.All(cv.ensure_list, [vol.Any(
+    # TODO Fix weird voluptuous error messages
+    vol.Schema({vol.Required(CONF_OFFSET): vol.Coerce(float)}),
+    vol.Schema({vol.Required(CONF_MULTIPLY): vol.Coerce(float)}),
+    vol.Schema({vol.Required(CONF_FILTER_OUT): vol.Coerce(float)}),
+    vol.Schema({vol.Required(CONF_FILTER_NAN): None}),
+    vol.Schema({
+        vol.Required(CONF_SLIDING_WINDOW_MOVING_AVERAGE): vol.Schema({
+            vol.Required(CONF_WINDOW_SIZE): cv.positive_not_null_int,
+            vol.Required(CONF_SEND_EVERY): cv.positive_not_null_int,
+        })
+    }),
+    vol.Schema({
+        vol.Required(CONF_EXPONENTIAL_MOVING_AVERAGE): vol.Schema({
+            vol.Required(CONF_ALPHA): cv.positive_float,
+            vol.Required(CONF_SEND_EVERY): cv.positive_not_null_int,
+        })
+    }),
+    vol.Schema({vol.Required(CONF_LAMBDA): cv.string_strict}),
+)])
+
+MQTT_SENSOR_SCHEMA = vol.Schema({
+    vol.Required(CONF_NAME): cv.string,
+    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.Any(None, cv.positive_time_period),
+    vol.Optional(CONF_FILTERS): FILTERS_SCHEMA
+})
+
+MQTT_SENSOR_ID_SCHEMA = MQTT_SENSOR_SCHEMA.extend({
+    cv.GenerateID('mqtt_sensor'): cv.register_variable_id,
+})
+
+OffsetFilter = MockObj('new sensor::OffsetFilter')
+MultiplyFilter = MockObj('new sensor::MultiplyFilter')
+FilterOutValueFilter = MockObj('new sensor::FilterOutValueFilter')
+FilterOutNANFilter = MockObj('new sensor::FilterOutNANFilter')
+SlidingWindowMovingAverageFilter = MockObj('new sensor::SlidingWindowMovingAverageFilter')
+ExponentialMovingAverageFilter = MockObj('new sensor::ExponentialMovingAverageFilter')
+LambdaFilter = MockObj('new sensor::LambdaFilter')
+
+
+def setup_filter(config):
+    if CONF_OFFSET in config:
+        return OffsetFilter(config[CONF_OFFSET])
+    if CONF_MULTIPLY in config:
+        return MultiplyFilter(config[CONF_MULTIPLY])
+    if CONF_FILTER_OUT in config:
+        return FilterOutValueFilter(config[CONF_FILTER_OUT])
+    if CONF_FILTER_NAN in config:
+        return FilterOutNANFilter()
+    if CONF_SLIDING_WINDOW_MOVING_AVERAGE in config:
+        conf = config[CONF_SLIDING_WINDOW_MOVING_AVERAGE]
+        return SlidingWindowMovingAverageFilter(conf[CONF_WINDOW_SIZE], conf[CONF_SEND_EVERY])
+    if CONF_EXPONENTIAL_MOVING_AVERAGE in config:
+        conf = config[CONF_EXPONENTIAL_MOVING_AVERAGE]
+        return ExponentialMovingAverageFilter(conf[CONF_ALPHA], conf[CONF_SEND_EVERY])
+    if CONF_LAMBDA in config:
+        s = '[](float x) -> Optional<float> {{ return {}; }}'.format(config[CONF_LAMBDA])
+        return LambdaFilter(RawExpression(s))
+    raise ValueError("Filter unsupported: {}".format(config))
+
+
+def setup_mqtt_sensor_component(obj, config):
+    if CONF_UNIT_OF_MEASUREMENT in config:
+        add(obj.set_unit_of_measurement(config[CONF_UNIT_OF_MEASUREMENT]))
+    if CONF_ICON in config:
+        add(obj.set_icon(config[CONF_ICON]))
+    if CONF_ACCURACY_DECIMALS in config:
+        add(obj.set_accuracy_decimals(config[CONF_ACCURACY_DECIMALS]))
+    if CONF_EXPIRE_AFTER in config:
+        if config[CONF_EXPIRE_AFTER] is None:
+            add(obj.disable_expire_after())
+        else:
+            add(obj.set_expire_after(config[CONF_EXPIRE_AFTER]))
+    if CONF_FILTERS in config:
+        filters = [setup_filter(x) for x in config[CONF_FILTERS]]
+        add(obj.set_filters(ArrayInitializer(*filters)))
+    setup_mqtt_component(obj, config)
+
+
+def make_mqtt_sensor_for(exp, config):
+    rhs = App.make_mqtt_sensor_for(exp, config[CONF_NAME])
+    mqtt_sensor = Pvariable('sensor::MQTTSensorComponent', config[CONF_ID], rhs)
+    setup_mqtt_sensor_component(mqtt_sensor, config)

esphomeyaml/components/sensor/adc.py

@@ -0,0 +1,35 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ATTENUATION, CONF_ID, CONF_NAME, CONF_PIN, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, RawExpression, add, variable
+
+ATTENUATION_MODES = {
+    '0db': 'ADC_0db',
+    '2.5db': 'ADC_2_5db',
+    '6db': 'ADC_6db',
+    '11db': 'ADC_11db',
+}
+
+ATTENUATION_MODE_SCHEMA = vol.Any(*list(ATTENUATION_MODES.keys()))
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('adc'): cv.register_variable_id,
+    vol.Required(CONF_PIN): pins.analog_pin,
+    vol.Optional(CONF_ATTENUATION): vol.All(cv.only_on_esp32, ATTENUATION_MODE_SCHEMA),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+}).extend(sensor.MQTT_SENSOR_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_adc_sensor(config[CONF_PIN], config[CONF_NAME],
+                              config.get(CONF_UPDATE_INTERVAL))
+    make = variable('Application::MakeADCSensor', config[CONF_ID], rhs)
+    adc = make.Padc
+    if CONF_ATTENUATION in config:
+        attenuation = ATTENUATION_MODES[config[CONF_ATTENUATION]]
+        add(adc.set_attenuation(RawExpression(attenuation)))
+    sensor.setup_mqtt_sensor_component(make.Pmqtt, config)

esphomeyaml/components/sensor/ads1115.py

@@ -0,0 +1,56 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ADS1115_ID, CONF_GAIN, CONF_MULTIPLEXER, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import get_variable, RawExpression
+
+DEPENDENCIES = ['ads1115']
+
+MUX = {
+    'A0_A1': 'ADS1115_MUX_P0_N1',
+    'A0_A3': 'ADS1115_MUX_P0_N3',
+    'A1_A3': 'ADS1115_MUX_P1_N3',
+    'A2_A3': 'ADS1115_MUX_P2_N3',
+    'A0_GND': 'ADS1115_MUX_P0_NG',
+    'A1_GND': 'ADS1115_MUX_P1_NG',
+    'A2_GND': 'ADS1115_MUX_P2_NG',
+    'A3_GND': 'ADS1115_MUX_P3_NG',
+}
+
+GAIN = {
+    '6.144': 'ADS1115_PGA_6P144',
+    '4.096': 'ADS1115_PGA_6P096',
+    '2.048': 'ADS1115_PGA_2P048',
+    '1.024': 'ADS1115_PGA_1P024',
+    '0.512': 'ADS1115_PGA_0P512',
+    '0.256': 'ADS1115_PGA_0P256',
+}
+
+
+def validate_gain(value):
+    if isinstance(value, float):
+        value = u'{:0.03f}'.format(value)
+    elif not isinstance(value, (str, unicode)):
+        raise vol.Invalid('invalid gain "{}"'.format(value))
+
+    if value not in GAIN:
+        raise vol.Invalid("Invalid gain, options are {}".format(', '.join(GAIN.keys())))
+    return value
+
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_MULTIPLEXER): vol.All(vol.Upper, vol.Any(*list(MUX.keys()))),
+    vol.Required(CONF_GAIN): validate_gain,
+    vol.Optional(CONF_ADS1115_ID): cv.variable_id,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+}).extend(sensor.MQTT_SENSOR_ID_SCHEMA.schema)
+
+
+def to_code(config):
+    hub = get_variable(config.get(CONF_ADS1115_ID), u'sensor::ADS1115Component')
+
+    mux = RawExpression(MUX[config[CONF_MULTIPLEXER]])
+    gain = RawExpression(GAIN[config[CONF_GAIN]])
+    sensor_ = hub.get_sensor(mux, gain, config.get(CONF_UPDATE_INTERVAL))
+    sensor.make_mqtt_sensor_for(sensor_, config)

esphomeyaml/components/sensor/bmp085.py

@@ -0,0 +1,29 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.components.sensor import MQTT_SENSOR_SCHEMA
+from esphomeyaml.const import CONF_ADDRESS, CONF_ID, CONF_NAME, \
+    CONF_PRESSURE, CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, HexIntLiteral, add, variable
+
+DEPENDENCIES = ['i2c']
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('bmp085_sensor'): cv.register_variable_id,
+    vol.Required(CONF_TEMPERATURE): MQTT_SENSOR_SCHEMA,
+    vol.Required(CONF_PRESSURE): MQTT_SENSOR_SCHEMA,
+    vol.Optional(CONF_ADDRESS): cv.i2c_address,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+})
+
+
+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 = variable('Application::MakeBMP085Component', config[CONF_ID], rhs)
+    if CONF_ADDRESS in config:
+        add(bmp.Pbmp.set_address(HexIntLiteral(config[CONF_ADDRESS])))
+    sensor.setup_mqtt_sensor_component(bmp.Pmqtt_temperature, config[CONF_TEMPERATURE])
+    sensor.setup_mqtt_sensor_component(bmp.Pmqtt_pressure, config[CONF_PRESSURE])

esphomeyaml/components/sensor/dallas.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.components.dallas import DALLAS_COMPONENT_CLASS
+from esphomeyaml.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_RESOLUTION, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import HexIntLiteral, get_variable
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    vol.Exclusive(CONF_ADDRESS, 'dallas'): cv.hex_int,
+    vol.Exclusive(CONF_INDEX, 'dallas'): cv.positive_int,
+    vol.Optional(CONF_DALLAS_ID): cv.variable_id,
+    vol.Optional(CONF_RESOLUTION): vol.All(vol.Coerce(int), vol.Range(min=8, max=12)),
+}).extend(sensor.MQTT_SENSOR_ID_SCHEMA.schema)
+
+
+def to_code(config):
+    hub = get_variable(config.get(CONF_DALLAS_ID), DALLAS_COMPONENT_CLASS)
+    update_interval = config.get(CONF_UPDATE_INTERVAL)
+    if CONF_RESOLUTION in config and update_interval is None:
+        update_interval = 10000
+
+    if CONF_ADDRESS in config:
+        address = HexIntLiteral(config[CONF_ADDRESS])
+        sensor_ = hub.Pget_sensor_by_address(address, update_interval,
+                                             config.get(CONF_RESOLUTION))
+    else:
+        sensor_ = hub.Pget_sensor_by_index(config[CONF_INDEX], update_interval,
+                                           config.get(CONF_RESOLUTION))
+    sensor.make_mqtt_sensor_for(sensor_, config)

esphomeyaml/components/sensor/dht.py

@@ -0,0 +1,31 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+from esphomeyaml.components.sensor import MQTT_SENSOR_SCHEMA
+from esphomeyaml.const import CONF_HUMIDITY, CONF_ID, CONF_MODEL, CONF_NAME, CONF_PIN, \
+    CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, RawExpression, add, variable
+
+DHT_MODELS = ['AUTO_DETECT', 'DHT11', 'DHT22', 'AM2302', 'RHT03']
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('dht_sensor'): cv.register_variable_id,
+    vol.Required(CONF_PIN): pins.input_output_pin,
+    vol.Required(CONF_TEMPERATURE): MQTT_SENSOR_SCHEMA,
+    vol.Required(CONF_HUMIDITY): MQTT_SENSOR_SCHEMA,
+    vol.Optional(CONF_MODEL): vol.All(vol.Upper, vol.Any(*DHT_MODELS)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+})
+
+
+def to_code(config):
+    rhs = App.make_dht_sensor(config[CONF_PIN], config[CONF_TEMPERATURE][CONF_NAME],
+                              config[CONF_HUMIDITY][CONF_NAME], config.get(CONF_UPDATE_INTERVAL))
+    dht = variable('Application::MakeDHTComponent', config[CONF_ID], rhs)
+    if CONF_MODEL in config:
+        model = RawExpression('DHT::{}'.format(config[CONF_MODEL]))
+        add(dht.Pdht.set_dht_model(model))
+    sensor.setup_mqtt_sensor_component(dht.Pmqtt_temperature, config[CONF_TEMPERATURE])
+    sensor.setup_mqtt_sensor_component(dht.Pmqtt_humidity, config[CONF_HUMIDITY])

esphomeyaml/components/sensor/hdc1080.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.components.sensor import MQTT_SENSOR_SCHEMA
+from esphomeyaml.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, variable
+
+DEPENDENCIES = ['i2c']
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('dht_sensor'): cv.register_variable_id,
+    vol.Required(CONF_TEMPERATURE): MQTT_SENSOR_SCHEMA,
+    vol.Required(CONF_HUMIDITY): MQTT_SENSOR_SCHEMA,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+})
+
+
+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 = variable('Application::MakeHDC1080Component', config[CONF_ID], rhs)
+    sensor.setup_mqtt_sensor_component(hdc1080.Pmqtt_temperature, config[CONF_TEMPERATURE])
+    sensor.setup_mqtt_sensor_component(hdc1080.Pmqtt_humidity, config[CONF_HUMIDITY])

esphomeyaml/components/sensor/htu21d.py

@@ -0,0 +1,26 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml.components import sensor
+from esphomeyaml.components.sensor import MQTT_SENSOR_SCHEMA
+from esphomeyaml.const import CONF_HUMIDITY, CONF_ID, CONF_NAME, CONF_TEMPERATURE, \
+    CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, variable
+
+DEPENDENCIES = ['i2c']
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('htu21d'): cv.register_variable_id,
+    vol.Required(CONF_TEMPERATURE): MQTT_SENSOR_SCHEMA,
+    vol.Required(CONF_HUMIDITY): MQTT_SENSOR_SCHEMA,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+})
+
+
+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 = variable('Application::MakeHTU21DComponent', config[CONF_ID], rhs)
+    sensor.setup_mqtt_sensor_component(htu21d.Pmqtt_temperature, config[CONF_TEMPERATURE])
+    sensor.setup_mqtt_sensor_component(htu21d.Pmqtt_humidity, config[CONF_HUMIDITY])

esphomeyaml/components/sensor/pulse_counter.py

@@ -0,0 +1,58 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_COUNT_MODE, CONF_FALLING_EDGE, CONF_ID, CONF_INTERNAL_FILTER, \
+    CONF_NAME, CONF_PIN, CONF_PULL_MODE, CONF_RISING_EDGE, CONF_UPDATE_INTERVAL, \
+    ESP_PLATFORM_ESP32
+from esphomeyaml.helpers import App, RawExpression, add, variable
+
+ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
+
+GPIO_PULL_MODES = {
+    'PULLUP': 'GPIO_PULLUP_ONLY',
+    'PULLDOWN': 'GPIO_PULLDOWN_ONLY',
+    'PULLUP_PULLDOWN': 'GPIO_PULLUP_PULLDOWN',
+    'FLOATING': 'GPIO_FLOATING',
+}
+
+GPIO_PULL_MODE_SCHEMA = vol.All(vol.Upper, vol.Any(*list(GPIO_PULL_MODES.keys())))
+
+COUNT_MODES = {
+    'DISABLE': 'PCNT_COUNT_DIS',
+    'INCREMENT': 'PCNT_COUNT_INC',
+    'DECREMENT': 'PCNT_COUNT_DEC',
+}
+
+COUNT_MODE_SCHEMA = vol.All(vol.Upper, vol.Any(*list(COUNT_MODES.keys())))
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('pulse_counter'): cv.register_variable_id,
+    vol.Required(CONF_PIN): pins.input_pin,
+    vol.Optional(CONF_PULL_MODE): GPIO_PULL_MODE_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): vol.All(vol.Coerce(int), vol.Range(min=0, max=1023)),
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+}).extend(sensor.MQTT_SENSOR_SCHEMA.schema)
+
+
+def to_code(config):
+    rhs = App.make_pulse_counter_sensor(config[CONF_PIN], config[CONF_NAME],
+                                        config.get(CONF_UPDATE_INTERVAL))
+    make = variable('Application::MakePulseCounter', config[CONF_ID], rhs)
+    pcnt = make.Ppcnt
+    if CONF_PULL_MODE in config:
+        pull_mode = GPIO_PULL_MODES[config[CONF_PULL_MODE]]
+        add(pcnt.set_pull_mode(RawExpression(pull_mode)))
+    if CONF_COUNT_MODE in config:
+        count_mode = config[CONF_COUNT_MODE]
+        rising_edge = COUNT_MODES[count_mode[CONF_RISING_EDGE]]
+        falling_edge = COUNT_MODES[count_mode[CONF_FALLING_EDGE]]
+        add(pcnt.set_edge_mode(RawExpression(rising_edge), RawExpression(falling_edge)))
+    if CONF_INTERNAL_FILTER in config:
+        add(pcnt.set_filter(config[CONF_INTERNAL_FILTER]))
+    sensor.setup_mqtt_sensor_component(make.Pmqtt, config)

esphomeyaml/components/sensor/ultrasonic.py

@@ -0,0 +1,32 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ECHO_PIN, CONF_ID, CONF_NAME, \
+    CONF_TIMEOUT_METER, CONF_TIMEOUT_TIME, CONF_TRIGGER_PIN, CONF_UPDATE_INTERVAL
+from esphomeyaml.helpers import App, add, exp_gpio_input_pin, exp_gpio_output_pin, \
+    variable
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('ultrasonic'): cv.register_variable_id,
+    vol.Required(CONF_TRIGGER_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
+    vol.Required(CONF_ECHO_PIN): pins.GPIO_INPUT_PIN_SCHEMA,
+    vol.Exclusive(CONF_TIMEOUT_METER, 'timeout'): cv.positive_float,
+    vol.Exclusive(CONF_TIMEOUT_TIME, 'timeout'): cv.positive_int,
+    vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_not_null_time_period,
+}).extend(sensor.MQTT_SENSOR_SCHEMA.schema)
+
+
+def to_code(config):
+    trigger = exp_gpio_output_pin(config[CONF_TRIGGER_PIN])
+    echo = exp_gpio_input_pin(config[CONF_ECHO_PIN])
+    rhs = App.make_ultrasonic_sensor(trigger, echo, config[CONF_NAME],
+                                     config.get(CONF_UPDATE_INTERVAL))
+    make = variable('Application::MakeUltrasonicSensor', config[CONF_ID], rhs)
+    ultrasonic = make.Pultrasonic
+    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_mqtt_sensor_component(make.Pmqtt, config)