Bump version to 1.6.2

esphomeyaml/Dockerfile

@@ -31,11 +31,11 @@ RUN /bin/bash -c "if [[ '$BUILD_FROM' = *\"ubuntu\"* ]]; then \
 # * On alpine, only install ESP8266 toolchain
 COPY platformio.ini /pio/platformio.ini
 RUN /bin/bash -c "if [[ '$BUILD_FROM' = *\"ubuntu\"* ]]; then \
-      platformio run -e espressif32 -e espressif8266 -d /pio; exit 0; \
+      platformio run -e espressif32 -e espressif8266 -d /pio; \
     else \
       echo \"\$(head -8 /pio/platformio.ini)\" >/pio/platformio.ini; \
-      platformio run -e espressif8266 -d /pio; exit 0; \
-    fi"
+      platformio run -e espressif8266 -d /pio; \
+    fi"; exit 0
 
 # Install latest esphomeyaml from git
 RUN pip install --no-cache-dir \

esphomeyaml/__main__.py

@@ -102,12 +102,15 @@ def run_miniterm(config, port, escape=False):
 
     with serial.Serial(port, baudrate=baud_rate) as ser:
         while True:
-            line = ser.readline()
+            line = ser.readline().replace('\r', '').replace('\n', '')
             time = datetime.now().time().strftime('[%H:%M:%S]')
-            message = time + line.decode('unicode-escape').replace('\r', '').replace('\n', '')
+            message = time + line
             if escape:
-                message = message.replace('\033', '\\033').encode('ascii', 'replace')
-            print(message)
+                message = message.replace('\033', '\\033')
+            try:
+                print(message)
+            except UnicodeEncodeError:
+                print(message.encode('ascii', 'backslashreplace'))
 
 
 def write_cpp(config):
@@ -205,6 +208,8 @@ def upload_program(config, args, port):
     espota_args = ['espota.py', '--debug', '--progress', '-i', host,
                    '-p', str(ota.get_port(config)), '-f', bin_file,
                    '-a', ota.get_auth(config), '-P', str(host_port)]
+    if args.verbose:
+        espota_args.append('-d')
     return espota.main(espota_args)
 
 

esphomeyaml/automation.py

@@ -205,7 +205,7 @@ def build_action(config, arg_type):
         yield Pvariable(config[CONF_ACTION_ID], rhs, type=type)
     elif CONF_MQTT_PUBLISH in config:
         conf = config[CONF_MQTT_PUBLISH]
-        rhs = App.Pget_mqtt_client().Pmake_publish_action()
+        rhs = App.Pget_mqtt_client().Pmake_publish_action(template_arg)
         type = mqtt.MQTTPublishAction.template(template_arg)
         action = Pvariable(config[CONF_ACTION_ID], rhs, type=type)
         template_ = None
@@ -387,7 +387,7 @@ def build_actions(config, arg_type):
         for action in build_action(conf, arg_type):
             yield None
         actions.append(action)
-    yield ArrayInitializer(*actions)
+    yield ArrayInitializer(*actions, multiline=False)
 
 
 def build_automation_(trigger, arg_type, config):

esphomeyaml/components/binary_sensor/esp32_ble.py

@@ -38,7 +38,7 @@ PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
 
 def to_code(config):
     hub = None
-    for hub in get_variable(CONF_ESP32_BLE_ID):
+    for hub in get_variable(config[CONF_ESP32_BLE_ID]):
         yield
     addr = [HexInt(i) for i in config[CONF_MAC_ADDRESS].parts]
     rhs = hub.make_device(config[CONF_NAME], ArrayInitializer(*addr, multiline=False))

esphomeyaml/components/binary_sensor/gpio.py

@@ -10,7 +10,7 @@ MakeGPIOBinarySensor = Application.MakeGPIOBinarySensor
 
 PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeGPIOBinarySensor),
-    vol.Required(CONF_PIN): pins.GPIO_INPUT_PIN_SCHEMA
+    vol.Required(CONF_PIN): pins.gpio_input_pin_schema
 }).extend(binary_sensor.BINARY_SENSOR_SCHEMA.schema)
 
 

esphomeyaml/components/binary_sensor/template.py

@@ -3,7 +3,7 @@ import voluptuous as vol
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import binary_sensor
 from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME
-from esphomeyaml.helpers import App, Application, process_lambda, variable
+from esphomeyaml.helpers import App, Application, process_lambda, variable, optional, bool_
 
 MakeTemplateBinarySensor = Application.MakeTemplateBinarySensor
 
@@ -15,7 +15,8 @@ PLATFORM_SCHEMA = binary_sensor.PLATFORM_SCHEMA.extend({
 
 def to_code(config):
     template_ = None
-    for template_ in process_lambda(config[CONF_LAMBDA], []):
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=optional.template(bool_)):
         yield
     rhs = App.make_template_binary_sensor(config[CONF_NAME], template_)
     make = variable(config[CONF_MAKE_ID], rhs)

esphomeyaml/components/cover/template.py

@@ -5,7 +5,7 @@ from esphomeyaml import automation
 from esphomeyaml.components import cover
 from esphomeyaml.const import CONF_CLOSE_ACTION, CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, \
     CONF_OPEN_ACTION, CONF_STOP_ACTION, CONF_OPTIMISTIC
-from esphomeyaml.helpers import App, Application, NoArg, add, process_lambda, variable
+from esphomeyaml.helpers import App, Application, NoArg, add, process_lambda, variable, optional
 
 MakeTemplateCover = Application.MakeTemplateCover
 
@@ -25,7 +25,8 @@ def to_code(config):
 
     if CONF_LAMBDA in config:
         template_ = None
-        for template_ in process_lambda(config[CONF_LAMBDA], []):
+        for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                        return_type=optional.template(cover.CoverState)):
             yield
         add(make.Ptemplate_.set_state_lambda(template_))
     if CONF_OPEN_ACTION in config:

esphomeyaml/components/deep_sleep.py

@@ -16,11 +16,21 @@ def validate_pin_number(value):
 
 DeepSleepComponent = esphomelib_ns.DeepSleepComponent
 
+WAKEUP_PIN_MODES = {
+    'IGNORE': esphomelib_ns.WAKEUP_PIN_MODE_IGNORE,
+    'KEEP_AWAKE': esphomelib_ns.WAKEUP_PIN_MODE_KEEP_AWAKE,
+    'INVERT_WAKEUP': esphomelib_ns.WAKEUP_PIN_MODE_INVERT_WAKEUP,
+}
+
+CONF_WAKEUP_PIN_MODE = 'wakeup_pin_mode'
+
 CONFIG_SCHEMA = vol.Schema({
     cv.GenerateID(): cv.declare_variable_id(DeepSleepComponent),
     vol.Optional(CONF_SLEEP_DURATION): cv.positive_time_period_milliseconds,
-    vol.Optional(CONF_WAKEUP_PIN): vol.All(cv.only_on_esp32, pins.GPIO_INTERNAL_INPUT_PIN_SCHEMA,
+    vol.Optional(CONF_WAKEUP_PIN): vol.All(cv.only_on_esp32, pins.internal_gpio_input_pin_schema,
                                            validate_pin_number),
+    vol.Optional(CONF_WAKEUP_PIN_MODE): vol.All(cv.only_on_esp32, vol.Upper,
+                                                cv.one_of(*WAKEUP_PIN_MODES)),
     vol.Optional(CONF_RUN_CYCLES): cv.positive_int,
     vol.Optional(CONF_RUN_DURATION): cv.positive_time_period_milliseconds,
 })
@@ -36,6 +46,8 @@ def to_code(config):
         for pin in gpio_input_pin_expression(config[CONF_WAKEUP_PIN]):
             yield
         add(deep_sleep.set_wakeup_pin(pin))
+    if CONF_WAKEUP_PIN_MODE in config:
+        add(deep_sleep.set_wakeup_pin_mode(WAKEUP_PIN_MODES[config[CONF_WAKEUP_PIN_MODE]]))
     if CONF_RUN_CYCLES in config:
         add(deep_sleep.set_run_cycles(config[CONF_RUN_CYCLES]))
     if CONF_RUN_DURATION in config:

esphomeyaml/components/esp32_touch.py

@@ -41,7 +41,10 @@ VOLTAGE_ATTENUATION = {
     '0V': global_ns.TOUCH_HVOLT_ATTEN_0V,
 }
 
+ESP32TouchComponent = binary_sensor.binary_sensor_ns.ESP32TouchComponent
+
 CONFIG_SCHEMA = vol.Schema({
+    cv.GenerateID(): cv.declare_variable_id(ESP32TouchComponent),
     vol.Optional(CONF_SETUP_MODE): cv.boolean,
     vol.Optional(CONF_IIR_FILTER): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_SLEEP_DURATION):
@@ -53,8 +56,6 @@ CONFIG_SCHEMA = vol.Schema({
     vol.Optional(CONF_VOLTAGE_ATTENUATION): validate_voltage(VOLTAGE_ATTENUATION),
 })
 
-ESP32TouchComponent = binary_sensor.binary_sensor_ns.ESP32TouchComponent
-
 
 def to_code(config):
     rhs = App.make_esp32_touch_component()
@@ -64,7 +65,7 @@ def to_code(config):
     if CONF_IIR_FILTER in config:
         add(touch.set_iir_filter(config[CONF_IIR_FILTER]))
     if CONF_SLEEP_DURATION in config:
-        sleep_duration = int(config[CONF_SLEEP_DURATION].total_microseconds * 6.6667)
+        sleep_duration = int(config[CONF_SLEEP_DURATION].total_microseconds * 0.15)
         add(touch.set_sleep_duration(sleep_duration))
     if CONF_MEASUREMENT_DURATION in config:
         measurement_duration = int(config[CONF_MEASUREMENT_DURATION].total_microseconds * 0.125)

esphomeyaml/components/i2c.py

@@ -12,7 +12,7 @@ CONFIG_SCHEMA = vol.Schema({
     cv.GenerateID(): cv.declare_variable_id(I2CComponent),
     vol.Required(CONF_SDA, default='SDA'): pins.input_output_pin,
     vol.Required(CONF_SCL, default='SCL'): pins.input_output_pin,
-    vol.Optional(CONF_FREQUENCY): cv.positive_int,
+    vol.Optional(CONF_FREQUENCY): vol.All(cv.frequency, vol.Range(min=0, min_included=False)),
     vol.Optional(CONF_RECEIVE_TIMEOUT): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_SCAN): cv.boolean,
 })

esphomeyaml/components/ir_transmitter.py

@@ -10,7 +10,7 @@ IRTransmitterComponent = switch.switch_ns.namespace('IRTransmitterComponent')
 
 CONFIG_SCHEMA = vol.All(cv.ensure_list, [vol.Schema({
     cv.GenerateID(): cv.declare_variable_id(IRTransmitterComponent),
-    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
+    vol.Required(CONF_PIN): pins.gpio_output_pin_schema,
     vol.Optional(CONF_CARRIER_DUTY_PERCENT): vol.All(vol.Coerce(int),
                                                      vol.Range(min=1, max=100)),
 })])

esphomeyaml/components/mqtt.py

@@ -16,7 +16,7 @@ from esphomeyaml.helpers import App, ArrayInitializer, Pvariable, RawExpression,
 
 def validate_message_just_topic(value):
     value = cv.publish_topic(value)
-    return {CONF_TOPIC: value}
+    return MQTT_MESSAGE_BASE({CONF_TOPIC: value})
 
 
 MQTT_MESSAGE_BASE = vol.Schema({
@@ -74,7 +74,7 @@ CONFIG_SCHEMA = vol.Schema({
     vol.Optional(CONF_ON_MESSAGE): vol.All(cv.ensure_list, [automation.AUTOMATION_SCHEMA.extend({
         cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(MQTTMessageTrigger),
         vol.Required(CONF_TOPIC): cv.publish_topic,
-        vol.Optional(CONF_QOS, 0): cv.mqtt_qos,
+        vol.Optional(CONF_QOS, default=0): cv.mqtt_qos,
     })])
 })
 
@@ -106,13 +106,13 @@ def to_code(config):
         add(mqtt.set_topic_prefix(config[CONF_TOPIC_PREFIX]))
     if CONF_BIRTH_MESSAGE in config:
         birth_message = config[CONF_BIRTH_MESSAGE]
-        if birth_message is None:
+        if not birth_message:
             add(mqtt.disable_birth_message())
         else:
             add(mqtt.set_birth_message(exp_mqtt_message(birth_message)))
     if CONF_WILL_MESSAGE in config:
         will_message = config[CONF_WILL_MESSAGE]
-        if will_message is None:
+        if not will_message:
             add(mqtt.disable_last_will())
         else:
             add(mqtt.set_last_will(exp_mqtt_message(will_message)))
@@ -120,10 +120,10 @@ def to_code(config):
         add(mqtt.set_client_id(config[CONF_CLIENT_ID]))
     if CONF_LOG_TOPIC in config:
         log_topic = config[CONF_LOG_TOPIC]
-        if log_topic is None:
+        if not log_topic:
             add(mqtt.disable_log_message())
         else:
-            add(mqtt.set_log_topic(exp_mqtt_message(log_topic)))
+            add(mqtt.set_log_message_template(exp_mqtt_message(log_topic)))
     if CONF_SSL_FINGERPRINTS in config:
         for fingerprint in config[CONF_SSL_FINGERPRINTS]:
             arr = [RawExpression("0x{}".format(fingerprint[i:i + 2])) for i in range(0, 40, 2)]

esphomeyaml/components/ota.py

@@ -29,6 +29,8 @@ def to_code(config):
     if CONF_PASSWORD in config:
         hash_ = hashlib.md5(config[CONF_PASSWORD].encode()).hexdigest()
         add(ota.set_auth_password_hash(hash_))
+    if CONF_PORT in config:
+        add(ota.set_port(config[CONF_PORT]))
     if config[CONF_SAFE_MODE]:
         add(ota.start_safe_mode())
 

esphomeyaml/components/output/esp8266_pwm.py

@@ -11,7 +11,7 @@ ESP_PLATFORMS = [ESP_PLATFORM_ESP8266]
 
 
 def valid_pwm_pin(value):
-    if value[CONF_NUMBER] >= 16:
+    if value[CONF_NUMBER] > 16:
         raise ESPHomeYAMLError(u"ESP8266: Only pins 0-16 support PWM.")
     return value
 
@@ -20,7 +20,7 @@ ESP8266PWMOutput = output.output_ns.ESP8266PWMOutput
 
 PLATFORM_SCHEMA = output.PLATFORM_SCHEMA.extend({
     vol.Required(CONF_ID): cv.declare_variable_id(ESP8266PWMOutput),
-    vol.Required(CONF_PIN): vol.All(pins.GPIO_INTERNAL_OUTPUT_PIN_SCHEMA, valid_pwm_pin),
+    vol.Required(CONF_PIN): vol.All(pins.internal_gpio_output_pin_schema, valid_pwm_pin),
 }).extend(output.FLOAT_OUTPUT_SCHEMA.schema)
 
 

esphomeyaml/components/output/gpio.py

@@ -10,7 +10,7 @@ GPIOBinaryOutputComponent = output.output_ns.GPIOBinaryOutputComponent
 
 PLATFORM_SCHEMA = output.PLATFORM_SCHEMA.extend({
     vol.Required(CONF_ID): cv.declare_variable_id(GPIOBinaryOutputComponent),
-    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
+    vol.Required(CONF_PIN): pins.gpio_output_pin_schema,
 }).extend(output.BINARY_OUTPUT_SCHEMA.schema)
 
 

esphomeyaml/components/output/ledc.py

@@ -15,7 +15,7 @@ def validate_frequency_bit_depth(obj):
     bit_depth = obj.get(CONF_BIT_DEPTH, 12)
     max_freq = APB_CLOCK_FREQ / (2**bit_depth)
     if frequency > max_freq:
-        raise vol.Invalid('Maximum frequency for bit depth {} is {}'.format(bit_depth, max_freq))
+        raise vol.Invalid('Maximum frequency for bit depth {} is {}Hz'.format(bit_depth, max_freq))
     return obj
 
 

esphomeyaml/components/power_supply.py

@@ -9,7 +9,7 @@ PowerSupplyComponent = esphomelib_ns.PowerSupplyComponent
 
 POWER_SUPPLY_SCHEMA = vol.Schema({
     vol.Required(CONF_ID): cv.declare_variable_id(PowerSupplyComponent),
-    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
+    vol.Required(CONF_PIN): pins.gpio_output_pin_schema,
     vol.Optional(CONF_ENABLE_TIME): cv.positive_time_period_milliseconds,
     vol.Optional(CONF_KEEP_ON_TIME): cv.positive_time_period_milliseconds,
 })

esphomeyaml/components/sensor/__init__.py

@@ -100,7 +100,7 @@ def setup_filter(config):
     elif CONF_FILTER_OUT in config:
         yield FilterOutValueFilter.new(config[CONF_FILTER_OUT])
     elif CONF_FILTER_NAN in config:
-        yield FilterOutNANFilter()
+        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])
@@ -117,7 +117,10 @@ def setup_filter(config):
     elif CONF_DELTA in config:
         yield DeltaFilter.new(config[CONF_DELTA])
     elif CONF_OR in config:
-        yield OrFilter.new(setup_filters(config[CONF_OR]))
+        filters = None
+        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:
@@ -131,7 +134,7 @@ def setup_filters(config):
     for conf in config:
         filter = None
         for filter in setup_filter(conf):
-            yield
+            yield None
         filters.append(filter)
     yield ArrayInitializer(*filters)
 

esphomeyaml/components/sensor/dallas.py

@@ -4,14 +4,14 @@ import esphomeyaml.config_validation as cv
 from esphomeyaml.components import sensor
 from esphomeyaml.components.dallas import DallasComponent
 from esphomeyaml.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_NAME, \
-    CONF_RESOLUTION, CONF_UPDATE_INTERVAL
+    CONF_RESOLUTION
 from esphomeyaml.helpers import HexIntLiteral, get_variable
 
 PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
     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=8, max=12)),
+    vol.Optional(CONF_RESOLUTION): vol.All(vol.Coerce(int), vol.Range(min=9, max=12)),
 }).extend(sensor.SENSOR_SCHEMA.schema), cv.has_at_least_one_key(CONF_ADDRESS, CONF_INDEX))
 
 
@@ -19,17 +19,12 @@ def to_code(config):
     hub = None
     for hub in get_variable(config[CONF_DALLAS_ID]):
         yield
-    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])
-        rhs = hub.Pget_sensor_by_address(config[CONF_NAME], address, update_interval,
-                                         config.get(CONF_RESOLUTION))
+        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],
-                                       update_interval, config.get(CONF_RESOLUTION))
+                                       config.get(CONF_RESOLUTION))
     sensor.register_sensor(rhs, config)
 
 

esphomeyaml/components/sensor/dht.py

@@ -5,7 +5,7 @@ from esphomeyaml.components import sensor
 from esphomeyaml.const import CONF_HUMIDITY, CONF_MAKE_ID, CONF_MODEL, CONF_NAME, CONF_PIN, \
     CONF_TEMPERATURE, CONF_UPDATE_INTERVAL
 from esphomeyaml.helpers import App, Application, add, gpio_output_pin_expression, variable
-from esphomeyaml.pins import GPIO_OUTPUT_PIN_SCHEMA
+from esphomeyaml.pins import gpio_output_pin_schema
 
 DHT_MODELS = {
     'AUTO_DETECT': sensor.sensor_ns.DHT_MODEL_AUTO_DETECT,
@@ -19,7 +19,7 @@ MakeDHTSensor = Application.MakeDHTSensor
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeDHTSensor),
-    vol.Required(CONF_PIN): GPIO_OUTPUT_PIN_SCHEMA,
+    vol.Required(CONF_PIN): gpio_output_pin_schema,
     vol.Required(CONF_TEMPERATURE): sensor.SENSOR_SCHEMA,
     vol.Required(CONF_HUMIDITY): sensor.SENSOR_SCHEMA,
     vol.Optional(CONF_MODEL): vol.All(vol.Upper, cv.one_of(*DHT_MODELS)),

esphomeyaml/components/sensor/dht12.py

@@ -24,9 +24,9 @@ def to_code(config):
                                 config.get(CONF_UPDATE_INTERVAL))
     dht = variable(config[CONF_MAKE_ID], rhs)
 
-    sensor.setup_sensor(dht.Pdht.Pget_temperature_sensor(), dht.Pmqtt_temperature,
+    sensor.setup_sensor(dht.Pdht12.Pget_temperature_sensor(), dht.Pmqtt_temperature,
                         config[CONF_TEMPERATURE])
-    sensor.setup_sensor(dht.Pdht.Pget_humidity_sensor(), dht.Pmqtt_humidity,
+    sensor.setup_sensor(dht.Pdht12.Pget_humidity_sensor(), dht.Pmqtt_humidity,
                         config[CONF_HUMIDITY])
 
 

esphomeyaml/components/sensor/max6675.py

@@ -12,9 +12,9 @@ MakeMAX6675Sensor = Application.MakeMAX6675Sensor
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeMAX6675Sensor),
-    vol.Required(CONF_PIN_CS): pins.GPIO_OUTPUT_PIN_SCHEMA,
-    vol.Required(CONF_PIN_CLOCK): pins.GPIO_OUTPUT_PIN_SCHEMA,
-    vol.Optional(CONF_PIN_MISO): pins.GPIO_INPUT_PIN_SCHEMA,
+    vol.Required(CONF_PIN_CS): pins.gpio_output_pin_schema,
+    vol.Required(CONF_PIN_CLOCK): pins.gpio_output_pin_schema,
+    vol.Required(CONF_PIN_MISO): pins.gpio_input_pin_schema,
     vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
 }).extend(sensor.SENSOR_SCHEMA.schema)
 

esphomeyaml/components/sensor/rotary_encoder.py

@@ -20,9 +20,9 @@ MakeRotaryEncoderSensor = Application.MakeRotaryEncoderSensor
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeRotaryEncoderSensor),
-    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.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): vol.All(cv.string, cv.one_of(*RESOLUTIONS)),
 }).extend(sensor.SENSOR_SCHEMA.schema)
 

esphomeyaml/components/sensor/sht3xd.py

@@ -29,6 +29,7 @@ PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
 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 = variable(config[CONF_MAKE_ID], rhs)
 

esphomeyaml/components/sensor/template.py

@@ -3,7 +3,7 @@ import voluptuous as vol
 import esphomeyaml.config_validation as cv
 from esphomeyaml.components import sensor
 from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, CONF_UPDATE_INTERVAL
-from esphomeyaml.helpers import App, process_lambda, variable, Application
+from esphomeyaml.helpers import App, process_lambda, variable, Application, float_, optional
 
 MakeTemplateSensor = Application.MakeTemplateSensor
 
@@ -16,7 +16,8 @@ PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
 
 def to_code(config):
     template_ = None
-    for template_ in process_lambda(config[CONF_LAMBDA], []):
+    for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                    return_type=optional.template(float_)):
         yield
     rhs = App.make_template_sensor(config[CONF_NAME], template_,
                                    config.get(CONF_UPDATE_INTERVAL))

esphomeyaml/components/sensor/ultrasonic.py

@@ -12,8 +12,8 @@ MakeUltrasonicSensor = Application.MakeUltrasonicSensor
 
 PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeUltrasonicSensor),
-    vol.Required(CONF_TRIGGER_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
-    vol.Required(CONF_ECHO_PIN): pins.GPIO_INTERNAL_INPUT_PIN_SCHEMA,
+    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.positive_time_period_milliseconds,
@@ -25,7 +25,7 @@ def to_code(config):
     for trigger in gpio_output_pin_expression(config[CONF_TRIGGER_PIN]):
         yield
     echo = None
-    for trigger in gpio_input_pin_expression(config[CONF_ECHO_PIN]):
+    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))

esphomeyaml/components/switch/gpio.py

@@ -10,7 +10,7 @@ MakeGPIOSwitch = Application.MakeGPIOSwitch
 
 PLATFORM_SCHEMA = switch.PLATFORM_SCHEMA.extend({
     cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeGPIOSwitch),
-    vol.Required(CONF_PIN): pins.GPIO_OUTPUT_PIN_SCHEMA,
+    vol.Required(CONF_PIN): pins.gpio_output_pin_schema,
 }).extend(switch.SWITCH_SCHEMA.schema)
 
 

esphomeyaml/components/switch/template.py

@@ -5,7 +5,8 @@ from esphomeyaml import automation
 from esphomeyaml.components import switch
 from esphomeyaml.const import CONF_LAMBDA, CONF_MAKE_ID, CONF_NAME, CONF_TURN_OFF_ACTION, \
     CONF_TURN_ON_ACTION, CONF_OPTIMISTIC
-from esphomeyaml.helpers import App, Application, process_lambda, variable, NoArg, add
+from esphomeyaml.helpers import App, Application, process_lambda, variable, NoArg, add, bool_, \
+    optional
 
 MakeTemplateSwitch = Application.MakeTemplateSwitch
 
@@ -24,7 +25,8 @@ def to_code(config):
 
     if CONF_LAMBDA in config:
         template_ = None
-        for template_ in process_lambda(config[CONF_LAMBDA], []):
+        for template_ in process_lambda(config[CONF_LAMBDA], [],
+                                        return_type=optional.template(bool_)):
             yield
         add(make.Ptemplate_.set_state_lambda(template_))
     if CONF_TURN_OFF_ACTION in config:

esphomeyaml/components/web_server.py

@@ -14,8 +14,8 @@ WebServer = esphomelib_ns.WebServer
 CONFIG_SCHEMA = vol.Schema({
     cv.GenerateID(): cv.declare_variable_id(WebServer),
     vol.Optional(CONF_PORT): cv.port,
-    vol.Optional(CONF_CSS_URL): vol.Url,
-    vol.Optional(CONF_JS_URL): vol.Url,
+    vol.Optional(CONF_CSS_URL): cv.string,
+    vol.Optional(CONF_JS_URL): cv.string,
 })
 
 

esphomeyaml/components/wifi.py

@@ -47,7 +47,7 @@ CONFIG_SCHEMA = vol.Schema({
         vol.Optional(CONF_MANUAL_IP): AP_MANUAL_IP_SCHEMA,
     }),
     vol.Optional(CONF_HOSTNAME): cv.hostname,
-    vol.Required(CONF_DOMAIN, default='.local'): cv.domainname,
+    vol.Optional(CONF_DOMAIN, default='.local'): cv.domainname,
 })
 
 

esphomeyaml/config.json

@@ -1,6 +1,6 @@
 {
   "name": "esphomeyaml",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "slug": "esphomeyaml",
   "description": "esphomeyaml HassIO add-on for intelligently managing all your ESP8266/ESP32 devices.",
   "url": "https://esphomelib.com/esphomeyaml/index.html",

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.6.1'
+DEFAULT_LIBRARY_URI = u'https://github.com/OttoWinter/esphomelib.git#v1.6.2'
 
 BUILD_FLASH_MODES = ['qio', 'qout', 'dio', 'dout']
 
@@ -175,7 +175,7 @@ def validate_config(config):
         dependencies = getattr(component, 'DEPENDENCIES', [])
         for dependency in dependencies:
             if dependency not in _ALL_COMPONENTS:
-                result.add_error(u"Component {} requires {}".format(domain, dependency))
+                result.add_error(u"Component {} requires component {}".format(domain, dependency))
                 success = False
         if not success:
             continue
@@ -209,8 +209,8 @@ def validate_config(config):
             dependencies = getattr(platform, 'DEPENDENCIES', [])
             for dependency in dependencies:
                 if dependency not in _ALL_COMPONENTS:
-                    result.add_error(u"Platform {}.{} requires {}".format(domain, p_name,
-                                                                          dependency))
+                    result.add_error(u"Platform {}.{} requires component {}".format(domain, p_name,
+                                                                                    dependency))
                     success = False
             if not success:
                 continue

esphomeyaml/config_validation.py

@@ -547,7 +547,7 @@ MQTT_COMPONENT_SCHEMA = vol.Schema({
     vol.Optional(CONF_RETAIN): boolean,
     vol.Optional(CONF_DISCOVERY): boolean,
     vol.Optional(CONF_STATE_TOPIC): publish_topic,
-    vol.Optional(CONF_AVAILABILITY): MQTT_COMPONENT_AVAILABILITY_SCHEMA,
+    vol.Optional(CONF_AVAILABILITY): vol.Any(None, MQTT_COMPONENT_AVAILABILITY_SCHEMA),
 })
 
 MQTT_COMMAND_COMPONENT_SCHEMA = MQTT_COMPONENT_SCHEMA.extend({

esphomeyaml/const.py

@@ -2,7 +2,7 @@
 
 MAJOR_VERSION = 1
 MINOR_VERSION = 6
-PATCH_VERSION = '1'
+PATCH_VERSION = '2'
 __short_version__ = '{}.{}'.format(MAJOR_VERSION, MINOR_VERSION)
 __version__ = '{}.{}'.format(__short_version__, PATCH_VERSION)
 

esphomeyaml/dashboard/templates/index.html

@@ -571,7 +571,7 @@
     inst._setSelectedStates();
     return inst.getSelectedValues()[0];
   };
-  setInterval(fetchSerialPorts, 2500);
+  setInterval(fetchSerialPorts, 5000);
   fetchSerialPorts(true);
 
   const logsModalElem = document.getElementById("modal-logs");

esphomeyaml/helpers.py

@@ -456,7 +456,6 @@ def flush_tasks():
             _TASKS.append((task, domain))
         except StopIteration:
             _LOGGER.debug(" -> %s finished", domain)
-            pass
 
 
 def add(expression, require=True):
@@ -484,7 +483,7 @@ class MockObj(Expression):
             obj.requires.append(self)
             return obj
         next_op = u'.'
-        if attr.startswith(u'P') and self.op != '::':
+        if attr.startswith(u'P') and self.op not in ['::', '']:
             attr = attr[1:]
             next_op = u'->'
         if attr.startswith(u'_'):
@@ -605,8 +604,11 @@ def setup_mqtt_component(obj, config):
         add(obj.set_custom_command_topic(config[CONF_COMMAND_TOPIC]))
     if CONF_AVAILABILITY in config:
         availability = config[CONF_AVAILABILITY]
-        add(obj.set_availability(availability[CONF_TOPIC], availability[CONF_PAYLOAD_AVAILABLE],
-                                 availability[CONF_PAYLOAD_NOT_AVAILABLE]))
+        if not availability:
+            add(obj.disable_availability())
+        else:
+            add(obj.set_availability(availability[CONF_TOPIC], availability[CONF_PAYLOAD_AVAILABLE],
+                                     availability[CONF_PAYLOAD_NOT_AVAILABLE]))
 
 
 # shlex's quote for Python 2.7

esphomeyaml/mqtt.py

@@ -10,7 +10,7 @@ from esphomeyaml import core
 from esphomeyaml.const import CONF_BROKER, CONF_DISCOVERY_PREFIX, CONF_ESPHOMEYAML, \
     CONF_LOG_TOPIC, \
     CONF_MQTT, CONF_NAME, CONF_PASSWORD, CONF_PORT, CONF_TOPIC_PREFIX, \
-    CONF_USERNAME
+    CONF_USERNAME, CONF_TOPIC
 from esphomeyaml.helpers import color
 
 _LOGGER = logging.getLogger(__name__)
@@ -45,7 +45,7 @@ def show_logs(config, topic=None, username=None, password=None, client_id=None,
     elif CONF_MQTT in config:
         conf = config[CONF_MQTT]
         if CONF_LOG_TOPIC in conf:
-            topic = config[CONF_MQTT][CONF_LOG_TOPIC]
+            topic = config[CONF_MQTT][CONF_LOG_TOPIC][CONF_TOPIC]
         elif CONF_TOPIC_PREFIX in config[CONF_MQTT]:
             topic = config[CONF_MQTT][CONF_TOPIC_PREFIX] + u'/debug'
         else:
@@ -57,10 +57,13 @@ def show_logs(config, topic=None, username=None, password=None, client_id=None,
 
     def on_message(client, userdata, msg):
         time = datetime.now().time().strftime(u'[%H:%M:%S]')
-        message = msg.payload.decode('utf-8')
+        message = time + msg.payload
         if escape:
             message = message.replace('\033', '\\033')
-        print(time + message)
+        try:
+            print(message)
+        except UnicodeEncodeError:
+            print(message.encode('ascii', 'backslashreplace'))
 
     return initialize(config, [topic], on_message, username, password, client_id)
 

esphomeyaml/pins.py

@@ -205,18 +205,38 @@ def shorthand_input_pin(value):
 PCF8574_OUTPUT_PIN_SCHEMA = vol.Schema({
     vol.Required(CONF_PCF8574): cv.use_variable_id(pcf8574.PCF8574Component),
     vol.Required(CONF_NUMBER): vol.Coerce(int),
-    vol.Optional(CONF_MODE): vol.All(vol.Upper, "OUTPUT"),
+    vol.Optional(CONF_MODE): vol.All(vol.Upper, cv.one_of("OUTPUT")),
     vol.Optional(CONF_INVERTED, default=False): cv.boolean,
 })
 
 PCF8574_INPUT_PIN_SCHEMA = PCF8574_OUTPUT_PIN_SCHEMA.extend({
-    vol.Optional(CONF_MODE): vol.All(vol.Upper, vol.Any("INPUT", "INPUT_PULLUP")),
+    vol.Optional(CONF_MODE): vol.All(vol.Upper, cv.one_of("INPUT", "INPUT_PULLUP")),
 })
 
-GPIO_INTERNAL_OUTPUT_PIN_SCHEMA = vol.Any(shorthand_output_pin, GPIO_FULL_OUTPUT_PIN_SCHEMA)
 
-GPIO_OUTPUT_PIN_SCHEMA = vol.Any(PCF8574_OUTPUT_PIN_SCHEMA, GPIO_INTERNAL_OUTPUT_PIN_SCHEMA)
+def internal_gpio_output_pin_schema(value):
+    if isinstance(value, dict):
+        return GPIO_FULL_OUTPUT_PIN_SCHEMA(value)
+    return shorthand_output_pin(value)
 
-GPIO_INTERNAL_INPUT_PIN_SCHEMA = vol.Any(shorthand_input_pin, GPIO_FULL_INPUT_PIN_SCHEMA)
 
-GPIO_INPUT_PIN_SCHEMA = vol.Any(PCF8574_INPUT_PIN_SCHEMA, GPIO_INTERNAL_INPUT_PIN_SCHEMA)
+def gpio_output_pin_schema(value):
+    if isinstance(value, dict):
+        if CONF_PCF8574 in value:
+            return PCF8574_OUTPUT_PIN_SCHEMA(value)
+        return GPIO_FULL_OUTPUT_PIN_SCHEMA(value)
+    return shorthand_output_pin(value)
+
+
+def internal_gpio_input_pin_schema(value):
+    if isinstance(value, dict):
+        return GPIO_FULL_INPUT_PIN_SCHEMA(value)
+    return shorthand_input_pin(value)
+
+
+def gpio_input_pin_schema(value):
+    if isinstance(value, dict):
+        if CONF_PCF8574 in value:
+            return PCF8574_INPUT_PIN_SCHEMA(value)
+        return GPIO_FULL_INPUT_PIN_SCHEMA(value)
+    return shorthand_input_pin(value)

esphomeyaml/yaml_util.py

@@ -48,8 +48,9 @@ def load_yaml(fname):
         with codecs.open(fname, encoding='utf-8') as conf_file:
             return yaml.load(conf_file, Loader=SafeLineLoader) or OrderedDict()
     except yaml.YAMLError as exc:
-        _LOGGER.error(exc)
         raise ESPHomeYAMLError(exc)
+    except IOError as exc:
+        raise ESPHomeYAMLError(u"Error accessing file {}: {}".format(fname, exc))
     except UnicodeDecodeError as exc:
         _LOGGER.error(u"Unable to read file %s: %s", fname, exc)
         raise ESPHomeYAMLError(exc)