コード例 #1
0

CONF_TUYA_ID = "tuya_id"
CONFIG_SCHEMA = (cv.Schema({
    cv.GenerateID():
    cv.declare_id(Tuya),
    cv.Optional(CONF_TIME_ID):
    cv.use_id(time.RealTimeClock),
    cv.Optional(CONF_IGNORE_MCU_UPDATE_ON_DATAPOINTS):
    cv.ensure_list(cv.uint8_t),
    cv.Optional(CONF_ON_DATAPOINT_UPDATE):
    automation.validate_automation(
        {
            cv.GenerateID(CONF_TRIGGER_ID):
            cv.declare_id(DATAPOINT_TRIGGERS[DPTYPE_ANY]),
            cv.Required(CONF_SENSOR_DATAPOINT):
            cv.uint8_t,
            cv.Optional(CONF_DATAPOINT_TYPE, default=DPTYPE_ANY):
            cv.one_of(*DATAPOINT_TRIGGERS, lower=True),
        },
        extra_validators=assign_declare_id,
    ),
}).extend(cv.COMPONENT_SCHEMA).extend(uart.UART_DEVICE_SCHEMA))


async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
    await uart.register_uart_device(var, config)
    if CONF_TIME_ID in config:
        time_ = await cg.get_variable(config[CONF_TIME_ID])
コード例 #2
0
    if value == 'inf':
        return 1e6

    try:
        value = float(value)
    except ValueError:
        raise cv.Invalid(f"Expected speed as floating point number, got {value}")

    if value <= 0:
        raise cv.Invalid("Speed must be larger than 0 steps/s!")

    return value


STEPPER_SCHEMA = cv.Schema({
    cv.Required(CONF_MAX_SPEED): validate_speed,
    cv.Optional(CONF_ACCELERATION, default='inf'): validate_acceleration,
    cv.Optional(CONF_DECELERATION, default='inf'): validate_acceleration,
})


@coroutine
def setup_stepper_core_(stepper_var, config):
    if CONF_ACCELERATION in config:
        cg.add(stepper_var.set_acceleration(config[CONF_ACCELERATION]))
    if CONF_DECELERATION in config:
        cg.add(stepper_var.set_deceleration(config[CONF_DECELERATION]))
    if CONF_MAX_SPEED in config:
        cg.add(stepper_var.set_max_speed(config[CONF_MAX_SPEED]))

コード例 #3
0
ファイル: __init__.py プロジェクト: krahabb/esphome
        }
    ),
)
async def dfplayer_previous_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])
    return var


@automation.register_action(
    "dfplayer.play",
    PlayFileAction,
    cv.maybe_simple_value(
        {
            cv.GenerateID(): cv.use_id(DFPlayer),
            cv.Required(CONF_FILE): cv.templatable(cv.int_),
            cv.Optional(CONF_LOOP): cv.templatable(cv.boolean),
        },
        key=CONF_FILE,
    ),
)
async def dfplayer_play_to_code(config, action_id, template_arg, args):
    var = cg.new_Pvariable(action_id, template_arg)
    await cg.register_parented(var, config[CONF_ID])
    template_ = await cg.templatable(config[CONF_FILE], args, float)
    cg.add(var.set_file(template_))
    if CONF_LOOP in config:
        template_ = await cg.templatable(config[CONF_LOOP], args, float)
        cg.add(var.set_loop(template_))
    return var
コード例 #4
0
ファイル: sensor.py プロジェクト: penright/esphome
        CONF_B: b,
        CONF_C: c,
    }


CONFIG_SCHEMA = (
    sensor.sensor_schema(
        unit_of_measurement=UNIT_CELSIUS,
        accuracy_decimals=1,
        device_class=DEVICE_CLASS_TEMPERATURE,
        state_class=STATE_CLASS_MEASUREMENT,
    )
    .extend(
        {
            cv.GenerateID(): cv.declare_id(NTC),
            cv.Required(CONF_SENSOR): cv.use_id(sensor.Sensor),
            cv.Required(CONF_CALIBRATION): process_calibration,
        }
    )
    .extend(cv.COMPONENT_SCHEMA)
)


async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
    await sensor.register_sensor(var, config)

    sens = await cg.get_variable(config[CONF_SENSOR])
    cg.add(var.set_sensor(sens))
    calib = config[CONF_CALIBRATION]
コード例 #5
0
ファイル: output.py プロジェクト: mysensors-rus/esphome

def valid_pwm_pin(value):
    num = value[CONF_NUMBER]
    cv.one_of(0, 1, 2, 3, 4, 5, 9, 10, 12, 13, 14, 15, 16)(num)
    return value


esp8266_pwm_ns = cg.esphome_ns.namespace("esp8266_pwm")
ESP8266PWM = esp8266_pwm_ns.class_("ESP8266PWM", output.FloatOutput, cg.Component)
SetFrequencyAction = esp8266_pwm_ns.class_("SetFrequencyAction", automation.Action)
validate_frequency = cv.All(cv.frequency, cv.Range(min=1.0e-6))

CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend(
    {
        cv.Required(CONF_ID): cv.declare_id(ESP8266PWM),
        cv.Required(CONF_PIN): cv.All(
            pins.internal_gpio_output_pin_schema, valid_pwm_pin
        ),
        cv.Optional(CONF_FREQUENCY, default="1kHz"): validate_frequency,
    }
).extend(cv.COMPONENT_SCHEMA)


async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
    await output.register_output(var, config)

    pin = await cg.gpio_pin_expression(config[CONF_PIN])
    cg.add(var.set_pin(pin))
コード例 #6
0
ファイル: __init__.py プロジェクト: krahabb/esphome
from esphome.components import sensor
import esphome.config_validation as cv
import esphome.codegen as cg
from esphome.const import CONF_ID, CONF_SENSOR_DATAPOINT
from .. import tuya_ns, CONF_TUYA_ID, Tuya

DEPENDENCIES = ["tuya"]
CODEOWNERS = ["@jesserockz"]

TuyaSensor = tuya_ns.class_("TuyaSensor", sensor.Sensor, cg.Component)

CONFIG_SCHEMA = sensor.SENSOR_SCHEMA.extend(
    {
        cv.GenerateID(): cv.declare_id(TuyaSensor),
        cv.GenerateID(CONF_TUYA_ID): cv.use_id(Tuya),
        cv.Required(CONF_SENSOR_DATAPOINT): cv.uint8_t,
    }
).extend(cv.COMPONENT_SCHEMA)


async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
    await sensor.register_sensor(var, config)

    paren = await cg.get_variable(config[CONF_TUYA_ID])
    cg.add(var.set_tuya_parent(paren))

    cg.add(var.set_sensor_id(config[CONF_SENSOR_DATAPOINT]))
コード例 #7
0
CODEOWNERS = ["@ahpohl"]

DEPENDENCIES = ["esp32_ble_tracker"]
AUTO_LOAD = ["xiaomi_ble"]

xiaomi_lywsd03mmc_ns = cg.esphome_ns.namespace("xiaomi_lywsd03mmc")
XiaomiLYWSD03MMC = xiaomi_lywsd03mmc_ns.class_(
    "XiaomiLYWSD03MMC", esp32_ble_tracker.ESPBTDeviceListener, cg.Component
)

CONFIG_SCHEMA = (
    cv.Schema(
        {
            cv.GenerateID(): cv.declare_id(XiaomiLYWSD03MMC),
            cv.Required(CONF_BINDKEY): cv.bind_key,
            cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
                UNIT_CELSIUS, ICON_EMPTY, 1, DEVICE_CLASS_TEMPERATURE
            ),
            cv.Optional(CONF_HUMIDITY): sensor.sensor_schema(
                UNIT_PERCENT, ICON_EMPTY, 0, DEVICE_CLASS_HUMIDITY
            ),
            cv.Optional(CONF_BATTERY_LEVEL): sensor.sensor_schema(
                UNIT_PERCENT, ICON_EMPTY, 0, DEVICE_CLASS_BATTERY
            ),
        }
    )
    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
    .extend(cv.COMPONENT_SCHEMA)
)
コード例 #8
0
            cv.declare_id(WebServer),
            cv.Optional(CONF_PORT, default=80):
            cv.port,
            cv.Optional(CONF_CSS_URL,
                        default="https://esphome.io/_static/webserver-v1.min.css"):
            cv.string,
            cv.Optional(CONF_CSS_INCLUDE):
            cv.file_,
            cv.Optional(CONF_JS_URL,
                        default="https://esphome.io/_static/webserver-v1.min.js"):
            cv.string,
            cv.Optional(CONF_JS_INCLUDE):
            cv.file_,
            cv.Optional(CONF_AUTH):
            cv.Schema({
                cv.Required(CONF_USERNAME):
                cv.All(cv.string_strict, cv.Length(min=1)),
                cv.Required(CONF_PASSWORD):
                cv.All(cv.string_strict, cv.Length(min=1)),
            }),
            cv.GenerateID(CONF_WEB_SERVER_BASE_ID):
            cv.use_id(web_server_base.WebServerBase),
            cv.Optional(CONF_INCLUDE_INTERNAL, default=False):
            cv.boolean,
            cv.Optional(CONF_OTA, default=True):
            cv.boolean,
        }, ).extend(cv.COMPONENT_SCHEMA),
    cv.only_with_arduino,
)

コード例 #9
0
ファイル: __init__.py プロジェクト: penright/esphome
FRAMEWORK_ESP_IDF = "esp-idf"
FRAMEWORK_ARDUINO = "arduino"
FRAMEWORK_SCHEMA = cv.typed_schema(
    {
        FRAMEWORK_ESP_IDF: ESP_IDF_FRAMEWORK_SCHEMA,
        FRAMEWORK_ARDUINO: ARDUINO_FRAMEWORK_SCHEMA,
    },
    lower=True,
    space="-",
    default_type=FRAMEWORK_ARDUINO,
)

CONFIG_SCHEMA = cv.All(
    cv.Schema({
        cv.Required(CONF_BOARD): cv.string_strict,
        cv.Optional(CONF_VARIANT): cv.one_of(*VARIANTS, upper=True),
        cv.Optional(CONF_FRAMEWORK, default={}): FRAMEWORK_SCHEMA,
    }),
    _detect_variant,
    set_core_data,
)


async def to_code(config):
    cg.add_platformio_option("board", config[CONF_BOARD])
    cg.add_build_flag("-DUSE_ESP32")
    cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
    cg.add_build_flag(f"-DUSE_ESP32_VARIANT_{config[CONF_VARIANT]}")
    cg.add_define("ESPHOME_VARIANT", VARIANT_FRIENDLY[config[CONF_VARIANT]])
コード例 #10
0
ファイル: sensor.py プロジェクト: Andre-Schuiki/esphome_im350
CONF_POWER_USAGE_IN = 'current_power_usage_in'
CONF_POWER_USAGE_OUT = 'current_power_usage_out'
UNIT_VOLT_AMPS_REACTIVE_HOURS = 'varh'
CONF_TEST_DATA = 'test_data'
CONF_USE_TEST_DATA = 'use_test_data'
CONF_DELAY_BEFORE_READING_DATA = 'delay_before_reading_data'
CONF_MAX_WAIT_TIME_FOR_READING_DATA = 'max_wait_time_for_reading_data'
CONF_NTP_SERVER = 'ntp_server'
CONF_NTP_GMT_OFFSET = 'ntp_gmt_offset'
CONF_NTP_DAYLIGHT_OFFSET = 'ntp_daylight_offset'
CONF_INVERT_SERIAL = 'invert_serial'

CONFIG_SCHEMA = cv.Schema({
    cv.GenerateID():
    cv.declare_id(SmartMeterSensorComponent),
    cv.Required(CONF_DECRYPTION_KEY):
    validate_decryption_key,
    cv.Required(CONF_TRIGGER_PIN):
    pins.gpio_output_pin_schema,
    cv.Required(CONF_RX_PIN):
    pins.gpio_output_pin_schema,
    cv.Required(CONF_TX_PIN):
    pins.gpio_output_pin_schema,
    cv.Optional(CONF_INVERT_SERIAL, default=False):
    boolean,
    cv.Optional(CONF_USE_TEST_DATA, default=False):
    boolean,
    cv.Optional(CONF_TEST_DATA):
    validate_test_data,
    cv.Optional(CONF_DELAY_BEFORE_READING_DATA, default=1000):
    int_,
コード例 #11
0
ファイル: __init__.py プロジェクト: yevgenb/esphome-1
DEPENDENCIES = ['i2c']
MULTI_CONF = True

mcp23016_ns = cg.esphome_ns.namespace('mcp23016')
MCP23016GPIOMode = mcp23016_ns.enum('MCP23016GPIOMode')
MCP23016_GPIO_MODES = {
    'INPUT': MCP23016GPIOMode.MCP23016_INPUT,
    'OUTPUT': MCP23016GPIOMode.MCP23016_OUTPUT,
}

MCP23016 = mcp23016_ns.class_('MCP23016', cg.Component, i2c.I2CDevice)
MCP23016GPIOPin = mcp23016_ns.class_('MCP23016GPIOPin', cg.GPIOPin)

CONFIG_SCHEMA = cv.Schema({
    cv.Required(CONF_ID): cv.declare_id(MCP23016),
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x20))


def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    yield cg.register_component(var, config)
    yield i2c.register_i2c_device(var, config)


CONF_MCP23016 = 'mcp23016'
MCP23016_OUTPUT_PIN_SCHEMA = cv.Schema({
    cv.Required(CONF_MCP23016):
    cv.use_id(MCP23016),
    cv.Required(CONF_NUMBER):
    cv.int_,
コード例 #12
0
        sensor.sensor_schema(
            unit_of_measurement=UNIT_MICROGRAMS_PER_CUBIC_METER,
            icon=ICON_CHEMICAL_WEAPON,
            accuracy_decimals=0,
            device_class=DEVICE_CLASS_PM10,
            state_class=STATE_CLASS_MEASUREMENT,
        ),
        cv.Optional(CONF_AQI):
        sensor.sensor_schema(
            unit_of_measurement=UNIT_INDEX,
            icon=ICON_CHEMICAL_WEAPON,
            accuracy_decimals=0,
            device_class=DEVICE_CLASS_AQI,
            state_class=STATE_CLASS_MEASUREMENT,
        ).extend({
            cv.Required(CONF_CALCULATION_TYPE):
            cv.enum(AQI_CALCULATION_TYPE, upper=True),
        }),
    }).extend(cv.polling_component_schema("60s")).extend(
        i2c.i2c_device_schema(0x40)),
    _validate,
    cv.only_with_arduino,
)


async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)

    if CONF_PM_1_0 in config:
コード例 #13
0
pcf8574_ns = cg.esphome_ns.namespace('pcf8574')
PCF8574GPIOMode = pcf8574_ns.enum('PCF8574GPIOMode')
PCF8674_GPIO_MODES = {
    'INPUT': PCF8574GPIOMode.PCF8574_INPUT,
    'INPUT_PULLUP': PCF8574GPIOMode.PCF8574_INPUT_PULLUP,
    'OUTPUT': PCF8574GPIOMode.PCF8574_OUTPUT,
}

PCF8574Component = pcf8574_ns.class_('PCF8574Component', cg.Component,
                                     i2c.I2CDevice)
PCF8574GPIOPin = pcf8574_ns.class_('PCF8574GPIOPin', cg.GPIOPin)

CONF_PCF8574 = 'pcf8574'
CONF_PCF8575 = 'pcf8575'
CONFIG_SCHEMA = cv.Schema({
    cv.Required(CONF_ID): cv.declare_id(PCF8574Component),
    cv.Optional(CONF_PCF8575, default=False): cv.boolean,
}).extend(cv.COMPONENT_SCHEMA).extend(i2c.i2c_device_schema(0x21))


def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    yield cg.register_component(var, config)
    yield i2c.register_i2c_device(var, config)
    cg.add(var.set_pcf8575(config[CONF_PCF8575]))


PCF8574_OUTPUT_PIN_SCHEMA = cv.Schema({
    cv.Required(CONF_PCF8574):
    cv.use_id(PCF8574Component),
    cv.Required(CONF_NUMBER):
コード例 #14
0
ファイル: config.py プロジェクト: micronen/esphome
    return value


def valid_project_name(value: str):
    if value.count(".") != 1:
        raise cv.Invalid("project name needs to have a namespace")

    value = value.replace(" ", "_")

    return value


CONF_ESP8266_RESTORE_FROM_FLASH = "esp8266_restore_from_flash"
CONFIG_SCHEMA = cv.All(
    cv.Schema({
        cv.Required(CONF_NAME):
        cv.valid_name,
        cv.Optional(CONF_COMMENT):
        cv.string,
        cv.Required(CONF_BUILD_PATH):
        cv.string,
        cv.Optional(CONF_PLATFORMIO_OPTIONS, default={}):
        cv.Schema({
            cv.string_strict: cv.Any([cv.string], cv.string),
        }),
        cv.Optional(CONF_ON_BOOT):
        automation.validate_automation({
            cv.GenerateID(CONF_TRIGGER_ID):
            cv.declare_id(StartupTrigger),
            cv.Optional(CONF_PRIORITY, default=600.0):
            cv.float_,
コード例 #15
0
ファイル: binary_sensor.py プロジェクト: yevgenb/esphome-1
                "Valid characters for parts of a UID are 0123456789ABCDEF."
            ) from err
        if x < 0 or x > 255:
            raise cv.Invalid(
                "Valid values for UID parts (separated by '-') are 00 to FF")
    return value


RC522BinarySensor = rc522_ns.class_('RC522BinarySensor',
                                    binary_sensor.BinarySensor)

CONFIG_SCHEMA = binary_sensor.BINARY_SENSOR_SCHEMA.extend({
    cv.GenerateID():
    cv.declare_id(RC522BinarySensor),
    cv.GenerateID(CONF_RC522_ID):
    cv.use_id(RC522),
    cv.Required(CONF_UID):
    validate_uid,
})


@coroutine
def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    yield binary_sensor.register_binary_sensor(var, config)

    hub = yield cg.get_variable(config[CONF_RC522_ID])
    cg.add(hub.register_tag(var))
    addr = [HexInt(int(x, 16)) for x in config[CONF_UID].split('-')]
    cg.add(var.set_uid(addr))
コード例 #16
0
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import light, output
from esphome.const import CONF_OUTPUT_ID, CONF_PIN_A, CONF_PIN_B
from .. import hbridge_ns

CODEOWNERS = ["@DotNetDann"]

HBridgeLightOutput = hbridge_ns.class_("HBridgeLightOutput",
                                       cg.PollingComponent, light.LightOutput)

CONFIG_SCHEMA = light.RGB_LIGHT_SCHEMA.extend({
    cv.GenerateID(CONF_OUTPUT_ID):
    cv.declare_id(HBridgeLightOutput),
    cv.Required(CONF_PIN_A):
    cv.use_id(output.FloatOutput),
    cv.Required(CONF_PIN_B):
    cv.use_id(output.FloatOutput),
})


async def to_code(config):
    var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
    await cg.register_component(var, config)
    await light.register_light(var, config)

    hside = await cg.get_variable(config[CONF_PIN_A])
    cg.add(var.set_pina_pin(hside))
    lside = await cg.get_variable(config[CONF_PIN_B])
    cg.add(var.set_pinb_pin(lside))
コード例 #17
0
ファイル: sensor.py プロジェクト: warthog9/esphome
def validate_pulse_meter_pin(value):
    value = pins.internal_gpio_input_pin_schema(value)
    if CORE.is_esp8266 and value[CONF_NUMBER] >= 16:
        raise cv.Invalid(
            "Pins GPIO16 and GPIO17 cannot be used as pulse counters on ESP8266."
        )
    return value


CONFIG_SCHEMA = sensor.sensor_schema(
    UNIT_PULSES_PER_MINUTE, ICON_PULSE, 2, DEVICE_CLASS_EMPTY,
    STATE_CLASS_MEASUREMENT).extend({
        cv.GenerateID():
        cv.declare_id(PulseMeterSensor),
        cv.Required(CONF_PIN):
        validate_pulse_meter_pin,
        cv.Optional(CONF_INTERNAL_FILTER, default="13us"):
        validate_internal_filter,
        cv.Optional(CONF_TIMEOUT, default="5min"):
        validate_timeout,
        cv.Optional(CONF_TOTAL):
        sensor.sensor_schema(UNIT_PULSES, ICON_PULSE, 0, DEVICE_CLASS_EMPTY,
                             STATE_CLASS_NONE),
    })


async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
    await sensor.register_sensor(var, config)
コード例 #18
0

CONFIG_BASE_COMPONENT_SCHEMA = cv.Schema({
    cv.GenerateID(CONF_NEXTION_ID):
    cv.use_id(Nextion),
    cv.Optional(CONF_BACKGROUND_COLOR):
    cv.use_id(color),
    cv.Optional(CONF_FOREGROUND_COLOR):
    cv.use_id(color),
    cv.Optional(CONF_VISIBLE, default=True):
    cv.boolean,
})

CONFIG_TEXT_COMPONENT_SCHEMA = CONFIG_BASE_COMPONENT_SCHEMA.extend(
    cv.Schema({
        cv.Required(CONF_COMPONENT_NAME): NextionName,
        cv.Optional(CONF_FONT_ID): cv.int_range(min=0, max=255),
    }))

CONFIG_BINARY_SENSOR_SCHEMA = CONFIG_BASE_COMPONENT_SCHEMA.extend(
    cv.Schema({
        cv.Optional(CONF_COMPONENT_NAME): NextionName,
        cv.Optional(CONF_VARIABLE_NAME): NextionName,
    }))

CONFIG_SENSOR_COMPONENT_SCHEMA = CONFIG_BINARY_SENSOR_SCHEMA.extend(
    cv.Schema({
        cv.Optional(CONF_FONT_ID): cv.int_range(min=0, max=255),
    }))

CONFIG_SWITCH_COMPONENT_SCHEMA = CONFIG_SENSOR_COMPONENT_SCHEMA.extend(
コード例 #19
0
ファイル: automation.py プロジェクト: krahabb/esphome
    DimRelativeAction,
    ToggleAction,
    LightState,
    LightControlAction,
    AddressableLightState,
    AddressableSet,
    LightIsOnCondition,
    LightIsOffCondition,
)


@automation.register_action(
    "light.toggle",
    ToggleAction,
    automation.maybe_simple_id({
        cv.Required(CONF_ID):
        cv.use_id(LightState),
        cv.Optional(CONF_TRANSITION_LENGTH):
        cv.templatable(cv.positive_time_period_milliseconds),
    }),
)
async def light_toggle_to_code(config, action_id, template_arg, args):
    paren = await cg.get_variable(config[CONF_ID])
    var = cg.new_Pvariable(action_id, template_arg, paren)
    if CONF_TRANSITION_LENGTH in config:
        template_ = await cg.templatable(config[CONF_TRANSITION_LENGTH], args,
                                         cg.uint32)
        cg.add(var.set_transition_length(template_))
    return var

コード例 #20
0
    "elevation": SensorType.SUN_SENSOR_ELEVATION,
    "azimuth": SensorType.SUN_SENSOR_AZIMUTH,
}

CONFIG_SCHEMA = (
    sensor.sensor_schema(
        unit_of_measurement=UNIT_DEGREES,
        icon=ICON_WEATHER_SUNSET,
        accuracy_decimals=1,
        state_class=STATE_CLASS_NONE,
    )
    .extend(
        {
            cv.GenerateID(): cv.declare_id(SunSensor),
            cv.GenerateID(CONF_SUN_ID): cv.use_id(Sun),
            cv.Required(CONF_TYPE): cv.enum(TYPES, lower=True),
        }
    )
    .extend(cv.polling_component_schema("60s"))
)


async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
    await sensor.register_sensor(var, config)

    cg.add(var.set_type(config[CONF_TYPE]))
    paren = await cg.get_variable(config[CONF_SUN_ID])
    cg.add(var.set_parent(paren))
コード例 #21
0
def validate_full_update_every_only_type_a(value):
    if CONF_FULL_UPDATE_EVERY not in value:
        return value
    if MODELS[value[CONF_MODEL]][0] != 'a':
        raise cv.Invalid(
            "The 'full_update_every' option is only available for models "
            "'1.54in', '2.13in' and '2.90in'.")
    return value


CONFIG_SCHEMA = cv.All(
    display.FULL_DISPLAY_SCHEMA.extend({
        cv.GenerateID():
        cv.declare_id(WaveshareEPaper),
        cv.Required(CONF_DC_PIN):
        pins.gpio_output_pin_schema,
        cv.Required(CONF_MODEL):
        cv.one_of(*MODELS, lower=True),
        cv.Optional(CONF_RESET_PIN):
        pins.gpio_output_pin_schema,
        cv.Optional(CONF_BUSY_PIN):
        pins.gpio_input_pin_schema,
        cv.Optional(CONF_FULL_UPDATE_EVERY):
        cv.uint32_t,
    }).extend(cv.polling_component_schema('1s')).extend(spi.SPI_DEVICE_SCHEMA),
    validate_full_update_every_only_type_a,
    cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA))


def to_code(config):
コード例 #22
0
ファイル: __init__.py プロジェクト: yevgenb/esphome-1
        cv.positive_time_period_milliseconds,
    }),
    cv.Optional(CONF_ON_DOUBLE_CLICK):
    automation.validate_automation({
        cv.GenerateID(CONF_TRIGGER_ID):
        cv.declare_id(DoubleClickTrigger),
        cv.Optional(CONF_MIN_LENGTH, default='50ms'):
        cv.positive_time_period_milliseconds,
        cv.Optional(CONF_MAX_LENGTH, default='350ms'):
        cv.positive_time_period_milliseconds,
    }),
    cv.Optional(CONF_ON_MULTI_CLICK):
    automation.validate_automation({
        cv.GenerateID(CONF_TRIGGER_ID):
        cv.declare_id(MultiClickTrigger),
        cv.Required(CONF_TIMING):
        cv.All([parse_multi_click_timing_str], validate_multi_click_timing),
        cv.Optional(CONF_INVALID_COOLDOWN, default='1s'):
        cv.positive_time_period_milliseconds,
    }),
    cv.Optional(CONF_ON_STATE):
    automation.validate_automation({
        cv.GenerateID(CONF_TRIGGER_ID):
        cv.declare_id(StateTrigger),
    }),
    cv.Optional(CONF_INVERTED):
    cv.invalid("The inverted binary_sensor property has been replaced by the "
               "new 'invert' binary  sensor filter. Please see "
               "https://esphome.io/components/binary_sensor/index.html."),
})
コード例 #23
0
    UNIT_KILOGRAM,
    ICON_SCALE_BATHROOM,
    DEVICE_CLASS_EMPTY,
)

DEPENDENCIES = ["esp32_ble_tracker"]

xiaomi_miscale_ns = cg.esphome_ns.namespace("xiaomi_miscale")
XiaomiMiscale = xiaomi_miscale_ns.class_("XiaomiMiscale",
                                         esp32_ble_tracker.ESPBTDeviceListener,
                                         cg.Component)

CONFIG_SCHEMA = (cv.Schema({
    cv.GenerateID():
    cv.declare_id(XiaomiMiscale),
    cv.Required(CONF_MAC_ADDRESS):
    cv.mac_address,
    cv.Optional(CONF_WEIGHT):
    sensor.sensor_schema(
        UNIT_KILOGRAM,
        ICON_SCALE_BATHROOM,
        2,
        DEVICE_CLASS_EMPTY,
        STATE_CLASS_MEASUREMENT,
    ),
}).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA).extend(cv.COMPONENT_SCHEMA))


async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
コード例 #24
0
    CONF_MOSI_PIN,
    CONF_SPI_ID,
    CONF_CS_PIN,
)
from esphome.core import coroutine, coroutine_with_priority

CODEOWNERS = ["@esphome/core"]
spi_ns = cg.esphome_ns.namespace("spi")
SPIComponent = spi_ns.class_("SPIComponent", cg.Component)
SPIDevice = spi_ns.class_("SPIDevice")
MULTI_CONF = True

CONFIG_SCHEMA = cv.All(
    cv.Schema({
        cv.GenerateID(): cv.declare_id(SPIComponent),
        cv.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema,
        cv.Optional(CONF_MISO_PIN): pins.gpio_input_pin_schema,
        cv.Optional(CONF_MOSI_PIN): pins.gpio_output_pin_schema,
    }),
    cv.has_at_least_one_key(CONF_MISO_PIN, CONF_MOSI_PIN),
)


@coroutine_with_priority(1.0)
def to_code(config):
    cg.add_global(spi_ns.using)
    var = cg.new_Pvariable(config[CONF_ID])
    yield cg.register_component(var, config)

    clk = yield cg.gpio_pin_expression(config[CONF_CLK_PIN])
    cg.add(var.set_clk(clk))
コード例 #25
0
def register_addressable_effect(name, effect_type, default_name, schema,
                                *extra_validators):
    # addressable effect can be used only in addressable
    ADDRESSABLE_EFFECTS.append(name)

    return register_effect(name, effect_type, default_name, schema,
                           *extra_validators)


@register_binary_effect(
    "lambda",
    LambdaLightEffect,
    "Lambda",
    {
        cv.Required(CONF_LAMBDA): cv.lambda_,
        cv.Optional(CONF_UPDATE_INTERVAL, default="0ms"): cv.update_interval,
    },
)
async def lambda_effect_to_code(config, effect_id):
    lambda_ = await cg.process_lambda(config[CONF_LAMBDA],
                                      [(bool, "initial_run")],
                                      return_type=cg.void)
    return cg.new_Pvariable(effect_id, config[CONF_NAME], lambda_,
                            config[CONF_UPDATE_INTERVAL])


@register_binary_effect(
    "automation",
    AutomationLightEffect,
    "Automation",
コード例 #26
0
ファイル: media_player.py プロジェクト: micronen/esphome
INTERNAL_DAC_OPTIONS = {
    "left": i2s_dac_mode_t.I2S_DAC_CHANNEL_LEFT_EN,
    "right": i2s_dac_mode_t.I2S_DAC_CHANNEL_RIGHT_EN,
    "stereo": i2s_dac_mode_t.I2S_DAC_CHANNEL_BOTH_EN,
}

EXTERNAL_DAC_OPTIONS = ["mono", "stereo"]

CONFIG_SCHEMA = cv.All(
    cv.typed_schema(
        {
            "internal":
            cv.Schema({
                cv.GenerateID():
                cv.declare_id(I2SAudioMediaPlayer),
                cv.Required(CONF_MODE):
                cv.enum(INTERNAL_DAC_OPTIONS, lower=True),
            }).extend(media_player.MEDIA_PLAYER_SCHEMA).extend(
                cv.COMPONENT_SCHEMA),
            "external":
            cv.Schema({
                cv.GenerateID():
                cv.declare_id(I2SAudioMediaPlayer),
                cv.Required(CONF_I2S_DOUT_PIN):
                pins.internal_gpio_output_pin_number,
                cv.Required(CONF_I2S_BCLK_PIN):
                pins.internal_gpio_output_pin_number,
                cv.Required(CONF_I2S_LRCLK_PIN):
                pins.internal_gpio_output_pin_number,
                cv.Optional(CONF_MUTE_PIN):
                pins.gpio_output_pin_schema,
コード例 #27
0
ファイル: sensor.py プロジェクト: warthog9/esphome
CONF_STORE_BASELINE = "store_baseline"
CONF_VOC_BASELINE = "voc_baseline"

CONFIG_SCHEMA = (sensor.sensor_schema(
    UNIT_EMPTY, ICON_RADIATOR, 0, DEVICE_CLASS_EMPTY,
    STATE_CLASS_MEASUREMENT).extend({
        cv.GenerateID():
        cv.declare_id(SGP40Component),
        cv.Optional(CONF_STORE_BASELINE, default=True):
        cv.boolean,
        cv.Optional(CONF_VOC_BASELINE):
        cv.hex_uint16_t,
        cv.Optional(CONF_COMPENSATION):
        cv.Schema(
            {
                cv.Required(CONF_HUMIDITY_SOURCE): cv.use_id(sensor.Sensor),
                cv.Required(CONF_TEMPERATURE_SOURCE): cv.use_id(sensor.Sensor),
            }, ),
    }).extend(cv.polling_component_schema("60s")).extend(
        i2c.i2c_device_schema(0x59)))


async def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    await cg.register_component(var, config)
    await i2c.register_i2c_device(var, config)
    await sensor.register_sensor(var, config)

    if CONF_COMPENSATION in config:
        compensation_config = config[CONF_COMPENSATION]
        sens = await cg.get_variable(compensation_config[CONF_HUMIDITY_SOURCE])
コード例 #28
0
    UNIT_PARTS_PER_BILLION, CONF_TEMPERATURE, CONF_HUMIDITY, ICON_PERIODIC_TABLE_CO2

DEPENDENCIES = ['i2c']

ccs811_ns = cg.esphome_ns.namespace('ccs811')
CCS811Component = ccs811_ns.class_('CCS811Component', cg.PollingComponent,
                                   i2c.I2CDevice)

CONF_ECO2 = 'eco2'
CONF_TVOC = 'tvoc'
CONF_BASELINE = 'baseline'

CONFIG_SCHEMA = cv.Schema({
    cv.GenerateID():
    cv.declare_id(CCS811Component),
    cv.Required(CONF_ECO2):
    sensor.sensor_schema(UNIT_PARTS_PER_MILLION, ICON_PERIODIC_TABLE_CO2, 0),
    cv.Required(CONF_TVOC):
    sensor.sensor_schema(UNIT_PARTS_PER_BILLION, ICON_RADIATOR, 0),
    cv.Optional(CONF_BASELINE):
    cv.hex_uint16_t,
    cv.Optional(CONF_TEMPERATURE):
    cv.use_id(sensor.Sensor),
    cv.Optional(CONF_HUMIDITY):
    cv.use_id(sensor.Sensor),
}).extend(cv.polling_component_schema('60s')).extend(
    i2c.i2c_device_schema(0x5A))


def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
コード例 #29
0
from esphome import pins, core
from esphome.components import output
import esphome.config_validation as cv
import esphome.codegen as cg
from esphome.const import CONF_ID, CONF_PIN, CONF_PERIOD

slow_pwm_ns = cg.esphome_ns.namespace("slow_pwm")
SlowPWMOutput = slow_pwm_ns.class_("SlowPWMOutput", output.FloatOutput,
                                   cg.Component)

CONFIG_SCHEMA = output.FLOAT_OUTPUT_SCHEMA.extend({
    cv.Required(CONF_ID):
    cv.declare_id(SlowPWMOutput),
    cv.Required(CONF_PIN):
    pins.gpio_output_pin_schema,
    cv.Required(CONF_PERIOD):
    cv.All(
        cv.positive_time_period_milliseconds,
        cv.Range(min=core.TimePeriod(milliseconds=100)),
    ),
}).extend(cv.COMPONENT_SCHEMA)


def to_code(config):
    var = cg.new_Pvariable(config[CONF_ID])
    yield cg.register_component(var, config)
    yield output.register_output(var, config)

    pin = yield cg.gpio_pin_expression(config[CONF_PIN])
    cg.add(var.set_pin(pin))
    cg.add(var.set_period(config[CONF_PERIOD]))
コード例 #30
0
ファイル: __init__.py プロジェクト: warthog9/esphome
        cg.add(var.set_device_class(config[CONF_DEVICE_CLASS]))

    if CONF_MQTT_ID in config:
        mqtt_ = cg.new_Pvariable(config[CONF_MQTT_ID], var)
        await mqtt.register_mqtt_component(mqtt_, config)


async def register_cover(var, config):
    if not CORE.has_id(config[CONF_ID]):
        var = cg.Pvariable(config[CONF_ID], var)
    cg.add(cg.App.register_cover(var))
    await setup_cover_core_(var, config)


COVER_ACTION_SCHEMA = maybe_simple_id({
    cv.Required(CONF_ID): cv.use_id(Cover),
})


@automation.register_action("cover.open", OpenAction, COVER_ACTION_SCHEMA)
async def cover_open_to_code(config, action_id, template_arg, args):
    paren = await cg.get_variable(config[CONF_ID])
    return cg.new_Pvariable(action_id, template_arg, paren)


@automation.register_action("cover.close", CloseAction, COVER_ACTION_SCHEMA)
async def cover_close_to_code(config, action_id, template_arg, args):
    paren = await cg.get_variable(config[CONF_ID])
    return cg.new_Pvariable(action_id, template_arg, paren)