vol.Optional(CONF_CARRIER_FREQUENCY): vol.All(cv.frequency, vol.Coerce(int)),
    })),
    vol.Optional(CONF_RC_SWITCH_RAW): RC_SWITCH_RAW_SCHEMA,
    vol.Optional(CONF_RC_SWITCH_TYPE_A): RC_SWITCH_TYPE_A_SCHEMA,
    vol.Optional(CONF_RC_SWITCH_TYPE_B): RC_SWITCH_TYPE_B_SCHEMA,
    vol.Optional(CONF_RC_SWITCH_TYPE_C): RC_SWITCH_TYPE_C_SCHEMA,
    vol.Optional(CONF_RC_SWITCH_TYPE_D): RC_SWITCH_TYPE_D_SCHEMA,

    vol.Optional(CONF_REPEAT): vol.Any(cv.positive_not_null_int, vol.Schema({
        vol.Required(CONF_TIMES): cv.positive_not_null_int,
        vol.Required(CONF_WAIT_TIME): cv.positive_time_period_microseconds,
    })),
    cv.GenerateID(CONF_REMOTE_TRANSMITTER_ID): cv.use_variable_id(RemoteTransmitterComponent),
    cv.GenerateID(CONF_TRANSMITTER_ID): cv.declare_variable_id(RemoteTransmitter),
    vol.Optional(CONF_INVERTED): cv.invalid("Remote Transmitters do not support inverted mode!"),
}), cv.has_exactly_one_key(*REMOTE_KEYS))


def transmitter_base(full_config):
    name = full_config[CONF_NAME]
    key, config = next((k, v) for k, v in full_config.items() if k in REMOTE_KEYS)

    if key == CONF_LG:
        return LGTransmitter.new(name, config[CONF_DATA], config[CONF_NBITS])
    elif key == CONF_NEC:
        return NECTransmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
    elif key == CONF_PANASONIC:
        return PanasonicTransmitter.new(name, config[CONF_ADDRESS], config[CONF_COMMAND])
    elif key == CONF_SONY:
        return SonyTransmitter.new(name, config[CONF_DATA], config[CONF_NBITS])
    elif key == CONF_RAW:
Beispiel #2
0
            }),
            vol.Optional(CONF_DEEP_SLEEP_PREVENT):
            maybe_simple_id({
                vol.Required(CONF_ID):
                cv.use_variable_id(deep_sleep.DeepSleepComponent),
            }),
            vol.Optional(CONF_IF):
            vol.All(
                {
                    vol.Required(CONF_CONDITION): validate_recursive_condition,
                    vol.Optional(CONF_THEN): validate_recursive_action,
                    vol.Optional(CONF_ELSE): validate_recursive_action,
                }, cv.has_at_least_one_key(CONF_THEN, CONF_ELSE)),
            vol.Optional(CONF_LAMBDA):
            cv.lambda_,
        }, cv.has_exactly_one_key(*ACTION_KEYS))
])

# pylint: disable=invalid-name
DelayAction = esphomelib_ns.DelayAction
LambdaAction = esphomelib_ns.LambdaAction
IfAction = esphomelib_ns.IfAction
Automation = esphomelib_ns.Automation

CONDITIONS_SCHEMA = vol.All(cv.ensure_list, [
    cv.templatable({
        cv.GenerateID(CONF_CONDITION_ID):
        cv.declare_variable_id(None),
        vol.Optional(CONF_AND):
        validate_recursive_condition,
        vol.Optional(CONF_OR):
Beispiel #3
0
        }),
        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 = esphomelib_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
Beispiel #4
0
        vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
        vol.Required(CONF_COMMAND): cv.hex_uint32_t,
    }),
    vol.Optional(CONF_RAW): vol.Any(validate_raw_data, vol.Schema({
        vol.Required(CONF_DATA): validate_raw_data,
        vol.Optional(CONF_CARRIER_FREQUENCY): vol.All(cv.frequency, vol.Coerce(int)),
    })),
    vol.Optional(CONF_REPEAT): vol.Any(cv.positive_not_null_int, vol.Schema({
        vol.Required(CONF_TIMES): cv.positive_not_null_int,
        vol.Required(CONF_WAIT_TIME): cv.positive_time_period_microseconds,
    })),
    cv.GenerateID(CONF_REMOTE_TRANSMITTER_ID): cv.use_variable_id(RemoteTransmitterComponent),
    cv.GenerateID(CONF_TRANSMITTER_ID): cv.declare_variable_id(RemoteTransmitter),

    vol.Optional(CONF_INVERTED): cv.invalid("Remote Transmitters do not support inverted mode!"),
}), cv.has_exactly_one_key(*IR_KEYS))


def transmitter_base(config):
    if CONF_LG in config:
        conf = config[CONF_LG]
        return LGTransmitter.new(config[CONF_NAME], conf[CONF_DATA], conf[CONF_NBITS])
    elif CONF_NEC in config:
        conf = config[CONF_NEC]
        return NECTransmitter.new(config[CONF_NAME], conf[CONF_ADDRESS], conf[CONF_COMMAND])
    elif CONF_PANASONIC in config:
        conf = config[CONF_PANASONIC]
        return PanasonicTransmitter.new(config[CONF_NAME], conf[CONF_ADDRESS], conf[CONF_COMMAND])
    elif CONF_SONY in config:
        conf = config[CONF_SONY]
        return SonyTransmitter.new(config[CONF_NAME], conf[CONF_DATA], conf[CONF_NBITS])