Bump version to 1.5.3

esphomeyaml/components/binary_sensor/gpio.py

@@ -4,7 +4,7 @@ import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.components import binary_sensor
 from esphomeyaml.const import CONF_ID, CONF_INVERTED, CONF_NAME, CONF_PIN
-from esphomeyaml.helpers import App, add, exp_gpio_input_pin, variable
+from esphomeyaml.helpers import App, add, variable, gpio_input_pin_expression
 
 PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
     cv.GenerateID('gpio_binary_sensor'): cv.register_variable_id,
@@ -13,7 +13,8 @@ PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
 
 
 def to_code(config):
-    rhs = App.make_gpio_binary_sensor(config[CONF_NAME], exp_gpio_input_pin(config[CONF_PIN]))
+    rhs = App.make_gpio_binary_sensor(config[CONF_NAME],
+                                      gpio_input_pin_expression(config[CONF_PIN]))
     gpio = variable('Application::MakeGPIOBinarySensor', config[CONF_ID], rhs)
     if CONF_INVERTED in config:
         add(gpio.Pgpio.set_inverted(config[CONF_INVERTED]))

esphomeyaml/components/deep_sleep.py

@@ -1,14 +1,14 @@
 import voluptuous as vol
 
 from esphomeyaml import config_validation as cv, pins
-from esphomeyaml.const import CONF_ID, CONF_RUN_CYCLES, CONF_RUN_DURATION, CONF_SLEEP_DURATION, \
-    CONF_WAKEUP_PIN
-from esphomeyaml.helpers import App, Pvariable, add, exp_gpio_input_pin
+from esphomeyaml.const import CONF_ID, CONF_NUMBER, CONF_RUN_CYCLES, CONF_RUN_DURATION, \
+    CONF_SLEEP_DURATION, CONF_WAKEUP_PIN
+from esphomeyaml.helpers import App, Pvariable, add, gpio_input_pin_expression
 
 
 def validate_pin_number(value):
     valid_pins = [0, 2, 4, 12, 13, 14, 15, 25, 26, 27, 32, 39]
-    if value not in valid_pins:
+    if value[CONF_NUMBER] not in valid_pins:
         raise vol.Invalid(u"Only pins {} support wakeup"
                           u"".format(', '.join(str(x) for x in valid_pins)))
     return value
@@ -17,8 +17,8 @@ def validate_pin_number(value):
 CONFIG_SCHEMA = vol.Schema({
     cv.GenerateID('deep_sleep'): cv.register_variable_id,
     vol.Optional(CONF_SLEEP_DURATION): cv.positive_time_period_milliseconds,
-    vol.Optional(CONF_WAKEUP_PIN): vol.All(cv.only_on_esp32, pins.GPIO_INPUT_PIN_SCHEMA,
-                                           pins.schema_validate_number(validate_pin_number)),
+    vol.Optional(CONF_WAKEUP_PIN): vol.All(cv.only_on_esp32, pins.GPIO_INTERNAL_INPUT_PIN_SCHEMA,
+                                           validate_pin_number),
     vol.Optional(CONF_RUN_CYCLES): cv.positive_int,
     vol.Optional(CONF_RUN_DURATION): cv.positive_time_period_milliseconds,
 })
@@ -30,7 +30,7 @@ def to_code(config):
     if CONF_SLEEP_DURATION in config:
         add(deep_sleep.set_sleep_duration(config[CONF_SLEEP_DURATION]))
     if CONF_WAKEUP_PIN in config:
-        pin = exp_gpio_input_pin(config[CONF_WAKEUP_PIN])
+        pin = gpio_input_pin_expression(config[CONF_WAKEUP_PIN])
         add(deep_sleep.set_wakeup_pin(pin))
     if CONF_RUN_CYCLES in config:
         add(deep_sleep.set_run_cycles(config[CONF_RUN_CYCLES]))

esphomeyaml/components/ir_transmitter.py

@@ -3,7 +3,7 @@ import voluptuous as vol
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.const import CONF_CARRIER_DUTY_PERCENT, CONF_ID, CONF_PIN
-from esphomeyaml.helpers import App, Pvariable, exp_gpio_output_pin
+from esphomeyaml.helpers import App, Pvariable, gpio_output_pin_expression
 
 IR_TRANSMITTER_COMPONENT_CLASS = 'switch_::IRTransmitterComponent'
 
@@ -17,7 +17,7 @@ CONFIG_SCHEMA = vol.All(cv.ensure_list, [vol.Schema({
 
 def to_code(config):
     for conf in config:
-        pin = exp_gpio_output_pin(conf[CONF_PIN])
+        pin = gpio_output_pin_expression(conf[CONF_PIN])
         rhs = App.make_ir_transmitter(pin, conf.get(CONF_CARRIER_DUTY_PERCENT))
         Pvariable(IR_TRANSMITTER_COMPONENT_CLASS, conf[CONF_ID], rhs)
 

esphomeyaml/components/light/fastled_clockless.py

@@ -4,9 +4,10 @@ import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.components import light
 from esphomeyaml.const import CONF_CHIPSET, CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, \
-    CONF_ID, CONF_MAX_REFRESH_RATE, CONF_NAME, CONF_NUM_LEDS, CONF_PIN, CONF_RGB_ORDER
-from esphomeyaml.helpers import App, RawExpression, TemplateArguments, add, setup_mqtt_component, \
-    variable
+    CONF_ID, CONF_MAX_REFRESH_RATE, CONF_NAME, CONF_NUM_LEDS, CONF_PIN, CONF_POWER_SUPPLY, \
+    CONF_RGB_ORDER
+from esphomeyaml.helpers import App, RawExpression, TemplateArguments, add, get_variable, \
+    setup_mqtt_component, variable
 
 TYPES = [
     'NEOPIXEL',
@@ -63,6 +64,7 @@ PLATFORM_SCHEMA = vol.All(light.PLATFORM_SCHEMA.extend({
 
     vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
     vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_POWER_SUPPLY): cv.variable_id,
 }), validate)
 
 
@@ -81,6 +83,10 @@ def to_code(config):
     if CONF_MAX_REFRESH_RATE in config:
         add(fast_led.set_max_refresh_rate(config[CONF_MAX_REFRESH_RATE]))
 
+    if CONF_POWER_SUPPLY in config:
+        power_supply = get_variable(config[CONF_POWER_SUPPLY])
+        add(fast_led.set_power_supply(power_supply))
+
     setup_mqtt_component(make.Pmqtt, config)
     light.setup_light_component(make.Pstate, config)
 

esphomeyaml/components/light/fastled_spi.py

@@ -5,9 +5,9 @@ from esphomeyaml import pins
 from esphomeyaml.components import light
 from esphomeyaml.const import CONF_CHIPSET, CONF_CLOCK_PIN, CONF_DATA_PIN, \
     CONF_DEFAULT_TRANSITION_LENGTH, CONF_GAMMA_CORRECT, CONF_ID, CONF_MAX_REFRESH_RATE, CONF_NAME, \
-    CONF_NUM_LEDS, CONF_RGB_ORDER
-from esphomeyaml.helpers import App, TemplateArguments, add, setup_mqtt_component, variable, \
-    RawExpression
+    CONF_NUM_LEDS, CONF_POWER_SUPPLY, CONF_RGB_ORDER
+from esphomeyaml.helpers import App, RawExpression, TemplateArguments, add, get_variable, \
+    setup_mqtt_component, variable
 
 CHIPSETS = [
     'LPD8806',
@@ -42,6 +42,7 @@ PLATFORM_SCHEMA = light.PLATFORM_SCHEMA.extend({
 
     vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float,
     vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH): cv.positive_time_period_milliseconds,
+    vol.Optional(CONF_POWER_SUPPLY): cv.variable_id,
 })
 
 
@@ -62,6 +63,10 @@ def to_code(config):
     if CONF_MAX_REFRESH_RATE in config:
         add(fast_led.set_max_refresh_rate(config[CONF_MAX_REFRESH_RATE]))
 
+    if CONF_POWER_SUPPLY in config:
+        power_supply = get_variable(config[CONF_POWER_SUPPLY])
+        add(fast_led.set_power_supply(power_supply))
+
     setup_mqtt_component(make.Pmqtt, config)
     light.setup_light_component(make.Pstate, config)
 

esphomeyaml/components/output/esp8266_pwm.py

@@ -2,27 +2,26 @@ import voluptuous as vol
 
 from esphomeyaml import pins
 from esphomeyaml.components import output
-from esphomeyaml.const import CONF_ID, CONF_PIN, ESP_PLATFORM_ESP8266
+from esphomeyaml.const import CONF_ID, CONF_PIN, ESP_PLATFORM_ESP8266, CONF_NUMBER
 from esphomeyaml.core import ESPHomeYAMLError
-from esphomeyaml.helpers import App, Pvariable, exp_gpio_output_pin
+from esphomeyaml.helpers import App, Pvariable, gpio_output_pin_expression
 
 ESP_PLATFORMS = [ESP_PLATFORM_ESP8266]
 
 
 def valid_pwm_pin(value):
-    if value >= 16:
+    if value[CONF_NUMBER] >= 16:
         raise ESPHomeYAMLError(u"ESP8266: Only pins 0-16 support PWM.")
     return value
 
 
 PLATFORM_SCHEMA = output.FLOAT_PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_PIN): vol.All(pins.GPIO_OUTPUT_PIN_SCHEMA,
-                                    pins.schema_validate_number(valid_pwm_pin)),
+    vol.Required(CONF_PIN): vol.All(pins.GPIO_INTERNAL_OUTPUT_PIN_SCHEMA, valid_pwm_pin),
 })
 
 
 def to_code(config):
-    pin = exp_gpio_output_pin(config[CONF_PIN])
+    pin = gpio_output_pin_expression(config[CONF_PIN])
     rhs = App.make_esp8266_pwm_output(pin)
     gpio = Pvariable('output::ESP8266PWMOutput', config[CONF_ID], rhs)
     output.setup_output_platform(gpio, config)

esphomeyaml/components/output/gpio.py

@@ -3,7 +3,7 @@ import voluptuous as vol
 from esphomeyaml import pins
 from esphomeyaml.components import output
 from esphomeyaml.const import CONF_ID, CONF_PIN
-from esphomeyaml.helpers import App, Pvariable, exp_gpio_output_pin
+from esphomeyaml.helpers import App, Pvariable, gpio_output_pin_expression
 
 PLATFORM_SCHEMA = output.PLATFORM_SCHEMA.extend({
     vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
@@ -11,7 +11,7 @@ PLATFORM_SCHEMA = output.PLATFORM_SCHEMA.extend({
 
 
 def to_code(config):
-    pin = exp_gpio_output_pin(config[CONF_PIN])
+    pin = gpio_output_pin_expression(config[CONF_PIN])
     rhs = App.make_gpio_output(pin)
     gpio = Pvariable('output::GPIOBinaryOutputComponent', config[CONF_ID], rhs)
     output.setup_output_platform(gpio, config)

esphomeyaml/components/power_supply.py

@@ -3,7 +3,7 @@ import voluptuous as vol
 import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.const import CONF_ENABLE_TIME, CONF_ID, CONF_KEEP_ON_TIME, CONF_PIN
-from esphomeyaml.helpers import App, Pvariable, add, exp_gpio_output_pin
+from esphomeyaml.helpers import App, Pvariable, add, gpio_output_pin_expression
 
 POWER_SUPPLY_SCHEMA = cv.REQUIRED_ID_SCHEMA.extend({
     vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
@@ -16,7 +16,7 @@ CONFIG_SCHEMA = vol.All(cv.ensure_list, [POWER_SUPPLY_SCHEMA])
 
 def to_code(config):
     for conf in config:
-        pin = exp_gpio_output_pin(conf[CONF_PIN])
+        pin = gpio_output_pin_expression(conf[CONF_PIN])
         rhs = App.make_power_supply(pin)
         psu = Pvariable('PowerSupplyComponent', conf[CONF_ID], rhs)
         if CONF_ENABLE_TIME in conf:

esphomeyaml/components/sensor/__init__.py

@@ -1,10 +1,11 @@
 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_LAMBDA, CONF_MQTT_ID, CONF_MULTIPLY, CONF_NAME, CONF_OFFSET, CONF_SEND_EVERY, \
-    CONF_SLIDING_WINDOW_MOVING_AVERAGE, CONF_UNIT_OF_MEASUREMENT, CONF_WINDOW_SIZE, CONF_ID
+from esphomeyaml.const import CONF_ACCURACY_DECIMALS, CONF_ALPHA, CONF_DEBOUNCE, CONF_DELTA, \
+    CONF_EXPIRE_AFTER, CONF_EXPONENTIAL_MOVING_AVERAGE, CONF_FILTERS, CONF_FILTER_NAN, \
+    CONF_FILTER_OUT, CONF_HEARTBEAT, CONF_ICON, CONF_LAMBDA, CONF_MQTT_ID, CONF_MULTIPLY, \
+    CONF_NAME, CONF_OFFSET, CONF_OR, CONF_SEND_EVERY, CONF_SLIDING_WINDOW_MOVING_AVERAGE, \
+    CONF_THROTTLE, CONF_UNIQUE, CONF_UNIT_OF_MEASUREMENT, CONF_WINDOW_SIZE
 from esphomeyaml.helpers import App, ArrayInitializer, MockObj, Pvariable, RawExpression, add, \
     setup_mqtt_component
 
@@ -12,6 +13,11 @@ PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 })
 
+
+def validate_recursive_filter(value):
+    return FILTERS_SCHEMA(value)
+
+
 FILTERS_SCHEMA = vol.All(cv.ensure_list, [vol.Any(
     vol.Schema({vol.Required(CONF_OFFSET): vol.Coerce(float)}),
     vol.Schema({vol.Required(CONF_MULTIPLY): vol.Coerce(float)}),
@@ -30,6 +36,12 @@ FILTERS_SCHEMA = vol.All(cv.ensure_list, [vol.Any(
         })
     }),
     vol.Schema({vol.Required(CONF_LAMBDA): cv.string_strict}),
+    vol.Schema({vol.Required(CONF_THROTTLE): cv.positive_time_period_milliseconds}),
+    vol.Schema({vol.Required(CONF_DELTA): vol.Coerce(float)}),
+    vol.Schema({vol.Required(CONF_UNIQUE): None}),
+    vol.Schema({vol.Required(CONF_HEARTBEAT): cv.positive_time_period_milliseconds}),
+    vol.Schema({vol.Required(CONF_DEBOUNCE): cv.positive_time_period_milliseconds}),
+    vol.Schema({vol.Required(CONF_OR): validate_recursive_filter}),
 )])
 
 MQTT_SENSOR_SCHEMA = vol.Schema({
@@ -53,6 +65,12 @@ FilterOutNANFilter = MockObj('new sensor::FilterOutNANFilter')
 SlidingWindowMovingAverageFilter = MockObj('new sensor::SlidingWindowMovingAverageFilter')
 ExponentialMovingAverageFilter = MockObj('new sensor::ExponentialMovingAverageFilter')
 LambdaFilter = MockObj('new sensor::LambdaFilter')
+ThrottleFilter = MockObj('new sensor::ThrottleFilter')
+DeltaFilter = MockObj('new sensor::DeltaFilter')
+OrFilter = MockObj('new sensor::OrFilter')
+HeartbeatFilter = MockObj('new sensor::HeartbeatFilter')
+DebounceFilter = MockObj('new sensor::DebounceFilter')
+UniqueFilter = MockObj('new sensor::UniqueFilter')
 
 
 def setup_filter(config):
@@ -73,9 +91,25 @@ def setup_filter(config):
     if CONF_LAMBDA in config:
         s = u'[](float x) -> Optional<float> {{ return {}; }}'.format(config[CONF_LAMBDA])
         return LambdaFilter(RawExpression(s))
+    if CONF_THROTTLE in config:
+        return ThrottleFilter(config[CONF_THROTTLE])
+    if CONF_DELTA in config:
+        return DeltaFilter(config[CONF_DELTA])
+    if CONF_OR in config:
+        return OrFilter(setup_filters(config[CONF_OR]))
+    if CONF_HEARTBEAT in config:
+        return App.register_component(HeartbeatFilter(config[CONF_HEARTBEAT]))
+    if CONF_DEBOUNCE in config:
+        return App.register_component(DebounceFilter(config[CONF_DEBOUNCE]))
+    if CONF_UNIQUE in config:
+        return UniqueFilter()
     raise ValueError(u"Filter unsupported: {}".format(config))
 
 
+def setup_filters(config):
+    return ArrayInitializer(*[setup_filter(x) for x in config])
+
+
 def setup_mqtt_sensor_component(obj, config):
     if CONF_EXPIRE_AFTER in config:
         if config[CONF_EXPIRE_AFTER] is None:
@@ -93,8 +127,7 @@ def setup_sensor(obj, config):
     if CONF_ACCURACY_DECIMALS in config:
         add(obj.set_accuracy_decimals(config[CONF_ACCURACY_DECIMALS]))
     if CONF_FILTERS in config:
-        filters = [setup_filter(x) for x in config[CONF_FILTERS]]
-        add(obj.set_filters(ArrayInitializer(*filters)))
+        add(obj.set_filters(setup_filters(config[CONF_FILTERS])))
 
 
 def register_sensor(var, config):

esphomeyaml/components/sensor/dht.py

@@ -5,7 +5,7 @@ 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, exp_gpio_output_pin
+from esphomeyaml.helpers import App, RawExpression, add, variable, gpio_output_pin_expression
 from esphomeyaml.pins import GPIO_OUTPUT_PIN_SCHEMA
 
 DHT_MODELS = {
@@ -27,7 +27,7 @@ PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
 
 
 def to_code(config):
-    pin = exp_gpio_output_pin(config[CONF_PIN])
+    pin = gpio_output_pin_expression(config[CONF_PIN])
     rhs = App.make_dht_sensor(config[CONF_TEMPERATURE][CONF_NAME],
                               config[CONF_HUMIDITY][CONF_NAME],
                               pin, config.get(CONF_UPDATE_INTERVAL))

esphomeyaml/components/sensor/dht12.py

@@ -0,0 +1,31 @@
+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_time_period_milliseconds,
+})
+
+
+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 = variable('Application::MakeDHT12Sensor', config[CONF_ID], rhs)
+    sensor.setup_sensor(dht.Pdht.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
+    sensor.setup_mqtt_sensor_component(dht.Pmqtt_temperature, config[CONF_TEMPERATURE])
+    sensor.setup_sensor(dht.Pdht.Pget_humidity_sensor(), config[CONF_HUMIDITY])
+    sensor.setup_mqtt_sensor_component(dht.Pmqtt_humidity, config[CONF_HUMIDITY])
+
+
+BUILD_FLAGS = '-DUSE_DHT12_SENSOR'

esphomeyaml/components/sensor/rotary_encoder.py

@@ -0,0 +1,44 @@
+import voluptuous as vol
+
+import esphomeyaml.config_validation as cv
+from esphomeyaml import pins
+from esphomeyaml.components import sensor
+from esphomeyaml.const import CONF_ID, CONF_NAME, CONF_RESOLUTION
+from esphomeyaml.helpers import App, RawExpression, add, gpio_input_pin_expression, variable
+
+RESOLUTIONS = {
+    '1': 'sensor::ROTARY_ENCODER_1_PULSE_PER_CYCLE',
+    '2': 'sensor::ROTARY_ENCODER_2_PULSES_PER_CYCLE',
+    '4': 'sensor::ROTARY_ENCODER_4_PULSES_PER_CYCLE',
+}
+
+CONF_PIN_A = 'pin_a'
+CONF_PIN_B = 'pin_b'
+CONF_PIN_RESET = 'pin_reset'
+
+PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
+    cv.GenerateID('rotary_encoder'): cv.register_variable_id,
+    vol.Required(CONF_PIN_A): pins.GPIO_INTERNAL_INPUT_PIN_SCHEMA,
+    vol.Required(CONF_PIN_B): pins.GPIO_INTERNAL_INPUT_PIN_SCHEMA,
+    vol.Optional(CONF_PIN_RESET): pins.GPIO_INTERNAL_INPUT_PIN_SCHEMA,
+    vol.Optional(CONF_RESOLUTION): vol.All(cv.string, vol.Any(*RESOLUTIONS)),
+}).extend(sensor.MQTT_SENSOR_SCHEMA.schema)
+
+
+def to_code(config):
+    pin_a = gpio_input_pin_expression(config[CONF_PIN_A])
+    pin_b = gpio_input_pin_expression(config[CONF_PIN_B])
+    rhs = App.make_rotary_encoder_sensor(config[CONF_NAME], pin_a, pin_b)
+    make = variable('Application::MakeRotaryEncoderSensor', config[CONF_ID], rhs)
+    encoder = make.Protary_encoder
+    if CONF_PIN_RESET in config:
+        pin_i = gpio_input_pin_expression(config[CONF_PIN_RESET])
+        add(encoder.set_reset_pin(pin_i))
+    if CONF_RESOLUTION in config:
+        resolution = RESOLUTIONS[config[CONF_RESOLUTION]]
+        add(encoder.set_resolution(RawExpression(resolution)))
+    sensor.setup_sensor(encoder, config)
+    sensor.setup_mqtt_sensor_component(make.Pmqtt, config)
+
+
+BUILD_FLAGS = '-DUSE_ROTARY_ENCODER_SENSOR'

esphomeyaml/components/sensor/ultrasonic.py

@@ -5,13 +5,13 @@ 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
+from esphomeyaml.helpers import App, add, variable, gpio_output_pin_expression, \
+    gpio_input_pin_expression
 
 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.Required(CONF_ECHO_PIN): pins.GPIO_INTERNAL_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.positive_time_period_milliseconds,
@@ -19,8 +19,8 @@ PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
 
 
 def to_code(config):
-    trigger = exp_gpio_output_pin(config[CONF_TRIGGER_PIN])
-    echo = exp_gpio_input_pin(config[CONF_ECHO_PIN])
+    trigger = gpio_output_pin_expression(config[CONF_TRIGGER_PIN])
+    echo = gpio_input_pin_expression(config[CONF_ECHO_PIN])
     rhs = App.make_ultrasonic_sensor(config[CONF_NAME], trigger, echo,
                                      config.get(CONF_UPDATE_INTERVAL))
     make = variable('Application::MakeUltrasonicSensor', config[CONF_ID], rhs)

esphomeyaml/components/switch/__init__.py

@@ -1,7 +1,7 @@
 import voluptuous as vol
 
 import esphomeyaml.config_validation as cv
-from esphomeyaml.const import CONF_ICON, CONF_ID, CONF_NAME, CONF_MQTT_ID
+from esphomeyaml.const import CONF_ICON, CONF_INVERTED, CONF_MQTT_ID
 from esphomeyaml.helpers import App, Pvariable, add, setup_mqtt_component
 
 PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
@@ -10,6 +10,7 @@ PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
 
 MQTT_SWITCH_SCHEMA = cv.MQTT_COMMAND_COMPONENT_SCHEMA.extend({
     vol.Optional(CONF_ICON): cv.icon,
+    vol.Optional(CONF_INVERTED): cv.boolean,
 })
 
 MQTT_SWITCH_ID_SCHEMA = MQTT_SWITCH_SCHEMA.extend({
@@ -24,6 +25,8 @@ def setup_mqtt_switch(obj, config):
 def setup_switch(obj, config):
     if CONF_ICON in config:
         add(obj.set_icon(config[CONF_ICON]))
+    if CONF_INVERTED in config:
+        add(obj.set_inverted(config[CONF_INVERTED]))
 
 
 def register_switch(var, config):

esphomeyaml/components/switch/gpio.py

@@ -4,7 +4,7 @@ import esphomeyaml.config_validation as cv
 from esphomeyaml import pins
 from esphomeyaml.components import switch
 from esphomeyaml.const import CONF_ID, CONF_NAME, CONF_PIN
-from esphomeyaml.helpers import App, exp_gpio_output_pin, variable
+from esphomeyaml.helpers import App, variable, gpio_output_pin_expression
 
 PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
     cv.GenerateID('gpio_switch'): cv.register_variable_id,
@@ -13,7 +13,7 @@ PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
 
 
 def to_code(config):
-    rhs = App.make_gpio_switch(config[CONF_NAME], exp_gpio_output_pin(config[CONF_PIN]))
+    rhs = App.make_gpio_switch(config[CONF_NAME], gpio_output_pin_expression(config[CONF_PIN]))
     gpio = variable('Application::MakeGPIOSwitch', config[CONF_ID], rhs)
     switch.setup_switch(gpio.Pswitch_, config)
     switch.setup_mqtt_switch(gpio.Pmqtt, config)

esphomeyaml/components/switch/ir_transmitter.py

@@ -5,7 +5,7 @@ from esphomeyaml.components import switch
 from esphomeyaml.components.ir_transmitter import IR_TRANSMITTER_COMPONENT_CLASS
 from esphomeyaml.const import CONF_ADDRESS, CONF_CARRIER_FREQUENCY, CONF_COMMAND, CONF_DATA, \
     CONF_ID, CONF_IR_TRANSMITTER_ID, CONF_LG, CONF_NAME, CONF_NBITS, CONF_NEC, CONF_PANASONIC, \
-    CONF_RAW, CONF_REPEAT, CONF_SONY, CONF_TIMES, CONF_WAIT_TIME
+    CONF_RAW, CONF_REPEAT, CONF_SONY, CONF_TIMES, CONF_WAIT_TIME, CONF_INVERTED
 from esphomeyaml.core import ESPHomeYAMLError
 from esphomeyaml.helpers import ArrayInitializer, HexIntLiteral, MockObj, Pvariable, get_variable
 
@@ -45,6 +45,7 @@ PLATFORM_SCHEMA = vol.All(switch.PLATFORM_SCHEMA.extend({
         vol.Optional('wait_time_us'): cv.invalid(WAIT_TIME_MESSAGE),
     })),
     vol.Optional(CONF_IR_TRANSMITTER_ID): cv.variable_id,
+    vol.Optional(CONF_INVERTED): cv.invalid("IR Transmitters do not support inverted mode!"),
 }).extend(switch.MQTT_SWITCH_ID_SCHEMA.schema), cv.has_at_least_one_key(*IR_KEYS))
 
 # pylint: disable=invalid-name

esphomeyaml/components/switch/restart.py

@@ -1,10 +1,13 @@
+import voluptuous as vol
+
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import switch
-from esphomeyaml.const import CONF_ID, CONF_NAME
+from esphomeyaml.const import CONF_ID, CONF_NAME, CONF_INVERTED
 from esphomeyaml.helpers import App, variable
 
 PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
     cv.GenerateID('restart_switch'): cv.register_variable_id,
+    vol.Optional(CONF_INVERTED): cv.invalid("Restart switches do not support inverted mode!"),
 }).extend(switch.MQTT_SWITCH_SCHEMA.schema)
 
 

esphomeyaml/components/switch/shutdown.py

@@ -1,10 +1,13 @@
+import voluptuous as vol
+
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import switch
-from esphomeyaml.const import CONF_ID, CONF_NAME
+from esphomeyaml.const import CONF_ID, CONF_NAME, CONF_INVERTED
 from esphomeyaml.helpers import App, variable
 
 PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
     cv.GenerateID('shutdown_switch'): cv.register_variable_id,
+    vol.Optional(CONF_INVERTED): cv.invalid("Shutdown switches do not support inverted mode!"),
 }).extend(switch.MQTT_SWITCH_SCHEMA.schema)
 
 

esphomeyaml/config.py

@@ -18,7 +18,7 @@ from esphomeyaml.helpers import App, add, color
 
 _LOGGER = logging.getLogger(__name__)
 
-DEFAULT_LIBRARY_URI = u'https://github.com/OttoWinter/esphomelib.git#v1.5.1'
+DEFAULT_LIBRARY_URI = u'https://github.com/OttoWinter/esphomelib.git#v1.5.3'
 
 BUILD_FLASH_MODES = ['qio', 'qout', 'dio', 'dout']
 

esphomeyaml/config_validation.py

@@ -209,13 +209,6 @@ def time_period_str_colon(value):
     elif not isinstance(value, str):
         raise vol.Invalid(TIME_PERIOD_ERROR.format(value))
 
-    negative_offset = False
-    if value.startswith('-'):
-        negative_offset = True
-        value = value[1:]
-    elif value.startswith('+'):
-        value = value[1:]
-
     try:
         parsed = [int(x) for x in value.split(':')]
     except ValueError:
@@ -229,12 +222,7 @@ def time_period_str_colon(value):
     else:
         raise vol.Invalid(TIME_PERIOD_ERROR.format(value))
 
-    offset = TimePeriod(hours=hour, minutes=minute, seconds=second)
-
-    if negative_offset:
-        offset *= -1
-
-    return offset
+    return TimePeriod(hours=hour, minutes=minute, seconds=second)
 
 
 def time_period_str_unit(value):
@@ -277,17 +265,17 @@ def time_period_str_unit(value):
     return TimePeriod(**{kwarg: float(match.group(1))})
 
 
-def time_period_in_milliseconds(value):
+def time_period_in_milliseconds_(value):
     if value.microseconds is not None and value.microseconds != 0:
         raise vol.Invalid("Maximum precision is milliseconds")
     return TimePeriodMilliseconds(**value.as_dict())
 
 
-def time_period_in_microseconds(value):
+def time_period_in_microseconds_(value):
     return TimePeriodMicroseconds(**value.as_dict())
 
 
-def time_period_in_seconds(value):
+def time_period_in_seconds_(value):
     if value.microseconds is not None and value.microseconds != 0:
         raise vol.Invalid("Maximum precision is seconds")
     if value.milliseconds is not None and value.milliseconds != 0:
@@ -297,9 +285,9 @@ def time_period_in_seconds(value):
 
 time_period = vol.Any(time_period_str_unit, time_period_str_colon, time_period_dict)
 positive_time_period = vol.All(time_period, vol.Range(min=TimePeriod()))
-positive_time_period_milliseconds = vol.All(positive_time_period, time_period_in_milliseconds)
-positive_time_period_seconds = vol.All(positive_time_period, time_period_in_seconds)
-positive_time_period_microseconds = vol.All(positive_time_period, time_period_in_microseconds)
+positive_time_period_milliseconds = vol.All(positive_time_period, time_period_in_milliseconds_)
+positive_time_period_seconds = vol.All(positive_time_period, time_period_in_seconds_)
+positive_time_period_microseconds = vol.All(positive_time_period, time_period_in_microseconds_)
 positive_not_null_time_period = vol.All(time_period,
                                         vol.Range(min=TimePeriod(), min_included=False))
 

esphomeyaml/const.py

@@ -2,7 +2,7 @@
 
 MAJOR_VERSION = 1
 MINOR_VERSION = 5
-PATCH_VERSION = '2'
+PATCH_VERSION = '3'
 __short_version__ = '{}.{}'.format(MAJOR_VERSION, MINOR_VERSION)
 __version__ = '{}.{}'.format(__short_version__, PATCH_VERSION)
 
@@ -109,6 +109,12 @@ CONF_WINDOW_SIZE = 'window_size'
 CONF_SEND_EVERY = 'send_every'
 CONF_ALPHA = 'alpha'
 CONF_LAMBDA = 'lambda'
+CONF_THROTTLE = 'throttle'
+CONF_DELTA = 'delta'
+CONF_OR = 'or'
+CONF_UNIQUE = 'unique'
+CONF_HEARTBEAT = 'heartbeat'
+CONF_DEBOUNCE = 'debounce'
 CONF_UPDATE_INTERVAL = 'update_interval'
 CONF_PULL_MODE = 'pull_mode'
 CONF_COUNT_MODE = 'count_mode'

esphomeyaml/helpers.py

@@ -186,15 +186,15 @@ class Literal(Expression):
 
 
 # From https://stackoverflow.com/a/14945195/8924614
-def cpp_string_escape(s, encoding='utf-8'):
-    if isinstance(s, unicode):
-        s = s.encode(encoding)
+def cpp_string_escape(string, encoding='utf-8'):
+    if isinstance(string, unicode):
+        string = string.encode(encoding)
     result = ''
-    for c in s:
-        if not (32 <= ord(c) < 127) or c in ('\\', '"'):
-            result += '\\%03o' % ord(c)
+    for character in string:
+        if not (32 <= ord(character) < 127) or character in ('\\', '"'):
+            result += '\\%03o' % ord(character)
         else:
-            result += c
+            result += character
     return '"' + result + '"'
 
 
@@ -408,37 +408,34 @@ def get_gpio_pin_number(conf):
     return conf[CONF_NUMBER]
 
 
-def exp_gpio_pin_(obj, conf, default_mode):
-    if isinstance(conf, int):
-        return conf
-
+def generic_gpio_pin_expression_(conf, mock_obj, default_mode):
+    if conf is None:
+        return None
+    number = conf[CONF_NUMBER]
+    inverted = conf.get(CONF_INVERTED)
     if CONF_PCF8574 in conf:
         hub = get_variable(conf[CONF_PCF8574], 'io::PCF8574Component')
         if default_mode == u'INPUT':
-            return hub.make_input_pin(conf[CONF_NUMBER],
-                                      RawExpression('PCF8574_' + conf[CONF_MODE]),
-                                      conf[CONF_INVERTED])
+            mode = conf.get(CONF_MODE, u'INPUT')
+            return hub.make_input_pin(number,
+                                      RawExpression('PCF8574_' + mode),
+                                      inverted)
         elif default_mode == u'OUTPUT':
-            return hub.make_output_pin(conf[CONF_NUMBER], conf[CONF_INVERTED])
+            return hub.make_output_pin(number, inverted)
         else:
             raise ESPHomeYAMLError(u"Unknown default mode {}".format(default_mode))
-
-    if conf.get(CONF_INVERTED) is None:
-        return obj(conf[CONF_NUMBER], RawExpression(conf.get(CONF_MODE, default_mode)))
-    return obj(conf[CONF_NUMBER], RawExpression(conf.get(CONF_MODE, default_mode)),
-               conf[CONF_INVERTED])
+    if len(conf) == 1:
+        return IntLiteral(number)
+    mode = RawExpression(conf.get(CONF_MODE, default_mode))
+    return mock_obj(number, mode, inverted)
 
 
-def exp_gpio_pin(conf):
-    return GPIOPin(conf[CONF_NUMBER], conf[CONF_MODE], conf.get(CONF_INVERTED))
+def gpio_output_pin_expression(conf):
+    return generic_gpio_pin_expression_(conf, GPIOOutputPin, 'OUTPUT')
 
 
-def exp_gpio_output_pin(conf):
-    return exp_gpio_pin_(GPIOOutputPin, conf, u'OUTPUT')
-
-
-def exp_gpio_input_pin(conf):
-    return exp_gpio_pin_(GPIOInputPin, conf, u'INPUT')
+def gpio_input_pin_expression(conf):
+    return generic_gpio_pin_expression_(conf, GPIOInputPin, 'INPUT')
 
 
 def setup_mqtt_component(obj, config):

esphomeyaml/pins.py

@@ -177,35 +177,44 @@ def pin_mode(value):
     raise vol.Invalid(u"Invalid ESP platform.")
 
 
+GPIO_FULL_OUTPUT_PIN_SCHEMA = vol.Schema({
+    vol.Required(CONF_NUMBER): output_pin,
+    vol.Optional(CONF_MODE): pin_mode,
+    vol.Optional(CONF_INVERTED): cv.boolean,
+})
+
+GPIO_FULL_INPUT_PIN_SCHEMA = vol.Schema({
+    vol.Required(CONF_NUMBER): output_pin,
+    vol.Optional(CONF_MODE): pin_mode,
+    vol.Optional(CONF_INVERTED): cv.boolean,
+})
+
+
+def shorthand_output_pin(value):
+    value = output_pin(value)
+    return {CONF_NUMBER: value}
+
+
+def shorthand_input_pin(value):
+    value = input_pin(value)
+    return {CONF_NUMBER: value}
+
+
 PCF8574_OUTPUT_PIN_SCHEMA = vol.Schema({
     vol.Required(CONF_PCF8574): cv.variable_id,
     vol.Required(CONF_NUMBER): vol.Coerce(int),
+    vol.Optional(CONF_MODE): vol.All(vol.Upper, "OUTPUT"),
     vol.Optional(CONF_INVERTED, default=False): cv.boolean,
 })
 
 PCF8574_INPUT_PIN_SCHEMA = PCF8574_OUTPUT_PIN_SCHEMA.extend({
-    vol.Optional(CONF_MODE, default='INPUT'): vol.All(vol.Upper, vol.Any("INPUT", "INPUT_PULLUP")),
+    vol.Optional(CONF_MODE): vol.All(vol.Upper, vol.Any("INPUT", "INPUT_PULLUP")),
 })
 
-GPIO_OUTPUT_PIN_SCHEMA = vol.Any(output_pin, PCF8574_OUTPUT_PIN_SCHEMA, vol.Schema({
-    vol.Required(CONF_NUMBER): output_pin,
-    vol.Optional(CONF_MODE): pin_mode,
-    vol.Optional(CONF_INVERTED): cv.boolean,
-}))
+GPIO_INTERNAL_OUTPUT_PIN_SCHEMA = vol.Any(shorthand_output_pin, GPIO_FULL_OUTPUT_PIN_SCHEMA)
 
-GPIO_INPUT_PIN_SCHEMA = vol.Any(input_pin, PCF8574_INPUT_PIN_SCHEMA, vol.Schema({
-    vol.Required(CONF_NUMBER): input_pin,
-    vol.Optional(CONF_MODE): pin_mode,
-    vol.Optional(CONF_INVERTED): cv.boolean,
-}))
+GPIO_OUTPUT_PIN_SCHEMA = vol.Any(PCF8574_OUTPUT_PIN_SCHEMA, GPIO_INTERNAL_OUTPUT_PIN_SCHEMA)
 
+GPIO_INTERNAL_INPUT_PIN_SCHEMA = vol.Any(shorthand_input_pin, GPIO_FULL_INPUT_PIN_SCHEMA)
 
-def schema_validate_number(validator):
-    def valid(value):
-        if isinstance(value, dict):
-            value[CONF_NUMBER] = validator(value[CONF_NUMBER])
-        else:
-            value = validator(value)
-        return value
-
-    return valid
+GPIO_INPUT_PIN_SCHEMA = vol.Any(PCF8574_INPUT_PIN_SCHEMA, GPIO_INTERNAL_INPUT_PIN_SCHEMA)

esphomeyaml/writer.py

@@ -30,7 +30,7 @@ void setup() {
 
 void loop() {
   App.loop();
-  delay(1);
+  delay(16);
 }
 """)