def validate_wait_until(value):
schema = cv.Schema({
vol.Required(CONF_CONDITION): validate_recursive_condition
})
if isinstance(value, dict) and CONF_CONDITION in value:
return schema(value)
return validate_wait_until({CONF_CONDITION: value})
def validate_data(value):
if isinstance(value, text_type):
return value.encode('utf-8')
if isinstance(value, str):
return value
if isinstance(value, list):
return cv.Schema([cv.hex_uint8_t])(value)
raise vol.Invalid("data must either be a string wrapped in quotes or a list of bytes")
def validator(value):
value = validator_(value)
if extra_validators is not None:
value = cv.Schema([extra_validators])(value)
if single:
if len(value) != 1:
raise vol.Invalid("Cannot have more than 1 automation for templates")
return value[0]
return value
def validate_raw(value):
if isinstance(value, dict):
return cv.Schema({
cv.GenerateID():
cv.declare_variable_id(int32),
vol.Required(CONF_DATA):
[vol.Any(vol.Coerce(int), cv.time_period_microseconds)],
})(value)
return validate_raw({CONF_DATA: value})
def validate_raw(value):
if isinstance(value, dict):
return cv.Schema({
cv.GenerateID(): cv.declare_variable_id(int32),
vol.Required(CONF_DATA): [vol.Any(vol.Coerce(int), cv.time_period_microseconds)],
vol.Optional(CONF_CARRIER_FREQUENCY): vol.All(cv.frequency, vol.Coerce(int)),
})(value)
return validate_raw({
CONF_DATA: value
})
def validate_datapoint(value):
if isinstance(value, dict):
return cv.Schema({
vol.Required(CONF_FROM): cv.float_,
vol.Required(CONF_TO): cv.float_,
})(value)
value = cv.string(value)
if '->' not in value:
raise vol.Invalid("Datapoint mapping must contain '->'")
a, b = value.split('->', 1)
a, b = a.strip(), b.strip()
return validate_datapoint({CONF_FROM: cv.float_(a), CONF_TO: cv.float_(b)})
def validator_(value):
if isinstance(value, list):
try:
# First try as a sequence of actions
return [schema({CONF_THEN: value})]
except vol.Invalid as err:
if err.path and err.path[0] == CONF_THEN:
err.path.pop(0)
# Next try as a sequence of automations
try:
return cv.Schema([schema])(value)
except vol.Invalid as err2:
if 'Unable to find action' in str(err):
raise err2
raise vol.MultipleInvalid([err, err2])
elif isinstance(value, dict):
if CONF_THEN in value:
return [schema(value)]
return [schema({CONF_THEN: value})]
# This should only happen with invalid configs, but let's have a nice error message.
return [schema(value)]
if CONF_OPTIMISTIC in config:
add(template.set_optimistic(config[CONF_OPTIMISTIC]))
if CONF_ASSUMED_STATE in config:
add(template.set_assumed_state(config[CONF_ASSUMED_STATE]))
if CONF_RESTORE_STATE in config:
add(template.set_restore_state(config[CONF_RESTORE_STATE]))
setup_component(template, config)
BUILD_FLAGS = '-DUSE_TEMPLATE_SWITCH'
CONF_SWITCH_TEMPLATE_PUBLISH = 'switch.template.publish'
SWITCH_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
vol.Required(CONF_ID): cv.use_variable_id(switch.Switch),
vol.Required(CONF_STATE): cv.templatable(cv.boolean),
})
@ACTION_REGISTRY.register(CONF_SWITCH_TEMPLATE_PUBLISH, SWITCH_TEMPLATE_PUBLISH_ACTION_SCHEMA)
def switch_template_publish_to_code(config, action_id, template_arg, args):
for var in get_variable(config[CONF_ID]):
yield None
rhs = var.make_switch_publish_action(template_arg)
type = SwitchPublishAction.template(template_arg)
action = Pvariable(action_id, rhs, type=type)
for template_ in templatable(config[CONF_STATE], args, bool_):
yield None
add(action.set_state(template_))
yield action
import voluptuous as vol
from pi4home import automation
import pi4home.config_validation as cv
from pi4home.const import CONF_ID, CONF_INTERVAL
from pi4home.cpp_generator import Pvariable
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import App, PollingComponent, Trigger, pi4home_ns
IntervalTrigger = pi4home_ns.class_('IntervalTrigger', Trigger.template(),
PollingComponent)
CONFIG_SCHEMA = automation.validate_automation(
cv.Schema({
cv.GenerateID():
cv.declare_variable_id(IntervalTrigger),
vol.Required(CONF_INTERVAL):
cv.positive_time_period_milliseconds,
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
for conf in config:
rhs = App.register_component(IntervalTrigger.new(conf[CONF_INTERVAL]))
trigger = Pvariable(conf[CONF_ID], rhs)
setup_component(trigger, conf)
automation.build_automations(trigger, [], conf)
from pi4home.components import binary_sensor, uart
import pi4home.config_validation as cv
from pi4home.const import CONF_ID, CONF_UART_ID
from pi4home.cpp_generator import Pvariable, get_variable
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import App, Component
DEPENDENCIES = ['uart']
RDM6300Component = binary_sensor.binary_sensor_ns.class_(
'RDM6300Component', Component, uart.UARTDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_variable_id(RDM6300Component),
cv.GenerateID(CONF_UART_ID):
cv.use_variable_id(uart.UARTComponent),
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
for uart_ in get_variable(config[CONF_UART_ID]):
yield
rhs = App.make_rdm6300_component(uart_)
var = Pvariable(config[CONF_ID], rhs)
setup_component(var, config)
BUILD_FLAGS = '-DUSE_RDM6300'
setup_component(template, config)
if CONF_LAMBDA in config:
for template_ in process_lambda(
config[CONF_LAMBDA], [],
return_type=optional.template(std_string)):
yield
add(template.set_template(template_))
BUILD_FLAGS = '-DUSE_TEMPLATE_TEXT_SENSOR'
CONF_TEXT_SENSOR_TEMPLATE_PUBLISH = 'text_sensor.template.publish'
TEXT_SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
vol.Required(CONF_ID):
cv.use_variable_id(text_sensor.TextSensor),
vol.Required(CONF_STATE):
cv.templatable(cv.string_strict),
})
@ACTION_REGISTRY.register(CONF_TEXT_SENSOR_TEMPLATE_PUBLISH,
TEXT_SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA)
def text_sensor_template_publish_to_code(config, action_id, template_arg,
args):
for var in get_variable(config[CONF_ID]):
yield None
rhs = var.make_text_sensor_publish_action(template_arg)
type = TextSensorPublishAction.template(template_arg)
action = Pvariable(action_id, rhs, type=type)
for template_ in templatable(config[CONF_STATE], args, std_string):
yield None
from pi4home import pins
import pi4home.config_validation as cv
from pi4home.const import CONF_CLK_PIN, CONF_ID, CONF_MISO_PIN, CONF_MOSI_PIN
from pi4home.cpp_generator import Pvariable, add
from pi4home.cpp_helpers import gpio_input_pin_expression, gpio_output_pin_expression, \
setup_component
from pi4home.cpp_types import App, Component, pi4home_ns
SPIComponent = pi4home_ns.class_('SPIComponent', Component)
SPIDevice = pi4home_ns.class_('SPIDevice')
MULTI_CONF = True
CONFIG_SCHEMA = vol.All(
cv.Schema({
cv.GenerateID(): cv.declare_variable_id(SPIComponent),
vol.Required(CONF_CLK_PIN): pins.gpio_output_pin_schema,
vol.Optional(CONF_MISO_PIN): pins.gpio_input_pin_schema,
vol.Optional(CONF_MOSI_PIN): pins.gpio_output_pin_schema,
}), cv.has_at_least_one_key(CONF_MISO_PIN, CONF_MOSI_PIN))
def to_code(config):
for clk in gpio_output_pin_expression(config[CONF_CLK_PIN]):
yield
rhs = App.init_spi(clk)
spi = Pvariable(config[CONF_ID], rhs)
if CONF_MISO_PIN in config:
for miso in gpio_input_pin_expression(config[CONF_MISO_PIN]):
yield
add(spi.set_miso(miso))
if CONF_MOSI_PIN in config:
for mosi in gpio_input_pin_expression(config[CONF_MOSI_PIN]):
def validate_raw(value):
if isinstance(value, dict):
return cv.Schema({
cv.GenerateID(): cv.declare_variable_id(int32),
vol.Required(CONF_DATA): [vol.Any(vol.Coerce(int), cv.time_period_microseconds)],
vol.Optional(CONF_CARRIER_FREQUENCY): vol.All(cv.frequency, vol.Coerce(int)),
})(value)
return validate_raw({
CONF_DATA: value
})
PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(RemoteTransmitter),
vol.Optional(CONF_JVC): cv.Schema({
vol.Required(CONF_DATA): cv.hex_uint32_t,
}),
vol.Optional(CONF_LG): cv.Schema({
vol.Required(CONF_DATA): cv.hex_uint32_t,
vol.Optional(CONF_NBITS, default=28): cv.one_of(28, 32, int=True),
}),
vol.Optional(CONF_NEC): cv.Schema({
vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
vol.Required(CONF_COMMAND): cv.hex_uint16_t,
}),
vol.Optional(CONF_SAMSUNG): cv.Schema({
vol.Required(CONF_DATA): cv.hex_uint32_t,
}),
vol.Optional(CONF_SONY): cv.Schema({
vol.Required(CONF_DATA): cv.hex_uint32_t,
vol.Optional(CONF_NBITS, default=12): cv.one_of(12, 15, 20, int=True),
from pi4home.cpp_generator import Pvariable, add
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import App, Component, pi4home_ns
ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
CONF_ESP32_BLE_ID = 'esp32_ble_id'
ESP32BLETracker = pi4home_ns.class_('ESP32BLETracker', Component)
XiaomiSensor = pi4home_ns.class_('XiaomiSensor', sensor.Sensor)
XiaomiDevice = pi4home_ns.class_('XiaomiDevice')
XIAOMI_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend(
{cv.GenerateID(): cv.declare_variable_id(XiaomiSensor)})
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_variable_id(ESP32BLETracker),
vol.Optional(CONF_SCAN_INTERVAL):
cv.positive_time_period_seconds,
}).extend(cv.COMPONENT_SCHEMA.schema)
def make_address_array(address):
return [HexInt(i) for i in address.parts]
def to_code(config):
rhs = App.make_esp32_ble_tracker()
ble = Pvariable(config[CONF_ID], rhs)
if CONF_SCAN_INTERVAL in config:
add(ble.set_scan_interval(config[CONF_SCAN_INTERVAL]))
setup_component(ble, config)
import voluptuous as vol
from pi4home.automation import ACTION_REGISTRY, maybe_simple_id
from pi4home.components.power_supply import PowerSupplyComponent
import pi4home.config_validation as cv
from pi4home.const import CONF_ID, CONF_INVERTED, CONF_LEVEL, CONF_MAX_POWER, \
CONF_MIN_POWER, CONF_POWER_SUPPLY
from pi4home.core import CORE
from pi4home.cpp_generator import Pvariable, add, get_variable, templatable
from pi4home.cpp_types import Action, pi4home_ns, float_
PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({})
BINARY_OUTPUT_SCHEMA = cv.Schema({
vol.Optional(CONF_POWER_SUPPLY):
cv.use_variable_id(PowerSupplyComponent),
vol.Optional(CONF_INVERTED):
cv.boolean,
})
BINARY_OUTPUT_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
BINARY_OUTPUT_SCHEMA.schema)
FLOAT_OUTPUT_SCHEMA = BINARY_OUTPUT_SCHEMA.extend({
vol.Optional(CONF_MAX_POWER):
cv.percentage,
vol.Optional(CONF_MIN_POWER):
cv.percentage,
})
FLOAT_OUTPUT_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
FLOAT_OUTPUT_SCHEMA.schema)
raise vol.Invalid(u"Could not find '{}' file. '{}' does not seem to point to an "
u"pi4home-core copy.".format(library_json, value))
return value
def validate_commit(value):
value = cv.string(value)
if re.match(r"^[0-9a-f]{7,}$", value) is None:
raise vol.Invalid("Commit option only accepts commit hashes in hex format.")
return value
PI4HOME_CORE_VERSION_SCHEMA = vol.Any(
validate_simple_pi4home_core_version,
cv.Schema({
vol.Required(CONF_LOCAL): validate_local_pi4home_core_version,
}),
vol.All(
cv.Schema({
vol.Optional(CONF_REPOSITORY, default=LIBRARY_URI_REPO): cv.string,
vol.Optional(CONF_COMMIT): validate_commit,
vol.Optional(CONF_BRANCH): cv.string,
vol.Optional(CONF_TAG): cv.string,
}),
cv.has_at_most_one_key(CONF_COMMIT, CONF_BRANCH, CONF_TAG)
),
)
def validate_platform(value):
value = cv.string(value)
import voluptuous as vol
from pi4home.components import i2c, sensor
import pi4home.config_validation as cv
from pi4home.const import CONF_ADDRESS, CONF_ID
from pi4home.cpp_generator import Pvariable
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import App, Component
DEPENDENCIES = ['i2c']
MULTI_CONF = True
ADS1115Component = sensor.sensor_ns.class_('ADS1115Component', Component,
i2c.I2CDevice)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_variable_id(ADS1115Component),
vol.Required(CONF_ADDRESS):
cv.i2c_address,
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
rhs = App.make_ads1115_component(config[CONF_ADDRESS])
var = Pvariable(config[CONF_ID], rhs)
setup_component(var, config)
BUILD_FLAGS = '-DUSE_ADS1115_SENSOR'
from pi4home import pins
from pi4home.components import sensor
import pi4home.config_validation as cv
from pi4home.const import CONF_ID, CONF_PIN, CONF_UPDATE_INTERVAL
from pi4home.cpp_generator import Pvariable
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import App, PollingComponent
DallasComponent = sensor.sensor_ns.class_('DallasComponent', PollingComponent)
MULTI_CONF = True
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_variable_id(DallasComponent),
vol.Required(CONF_PIN):
pins.input_pin,
vol.Optional(CONF_UPDATE_INTERVAL):
cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
rhs = App.make_dallas_component(config[CONF_PIN],
config.get(CONF_UPDATE_INTERVAL))
var = Pvariable(config[CONF_ID], rhs)
setup_component(var, config)
BUILD_FLAGS = '-DUSE_DALLAS_SENSOR'
import pi4home.config_validation as cv
from pi4home.const import (CONF_BIT_DEPTH, CONF_CLOCK_PIN, CONF_DATA_PIN, CONF_ID,
CONF_NUM_CHANNELS, CONF_NUM_CHIPS, CONF_UPDATE_ON_BOOT)
from pi4home.cpp_generator import Pvariable, add
from pi4home.cpp_helpers import gpio_output_pin_expression, setup_component
from pi4home.cpp_types import App, Component
MY9231OutputComponent = output.output_ns.class_('MY9231OutputComponent', Component)
MULTI_CONF = True
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(MY9231OutputComponent),
vol.Required(CONF_DATA_PIN): pins.gpio_output_pin_schema,
vol.Required(CONF_CLOCK_PIN): pins.gpio_output_pin_schema,
vol.Optional(CONF_NUM_CHANNELS): vol.All(vol.Coerce(int),
vol.Range(3, 1020)),
vol.Optional(CONF_NUM_CHIPS): vol.All(vol.Coerce(int),
vol.Range(1, 255)),
vol.Optional(CONF_BIT_DEPTH): cv.one_of(8, 12, 14, 16, int=True),
vol.Optional(CONF_UPDATE_ON_BOOT): vol.Coerce(bool),
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
for di in gpio_output_pin_expression(config[CONF_DATA_PIN]):
yield
for dcki in gpio_output_pin_expression(config[CONF_CLOCK_PIN]):
yield
rhs = App.make_my9231_component(di, dcki)
my9231 = Pvariable(config[CONF_ID], rhs)
if CONF_NUM_CHANNELS in config:
EFFECTS_SCHEMA = cv.Schema({
vol.Optional(CONF_LAMBDA):
cv.Schema({
vol.Required(CONF_NAME):
cv.string,
vol.Required(CONF_LAMBDA):
cv.lambda_,
vol.Optional(CONF_UPDATE_INTERVAL, default='0ms'):
cv.positive_time_period_milliseconds,
}),
vol.Optional(CONF_RANDOM):
cv.Schema({
cv.GenerateID(CONF_EFFECT_ID):
cv.declare_variable_id(RandomLightEffect),
vol.Optional(CONF_NAME, default="Random"):
cv.string,
vol.Optional(CONF_TRANSITION_LENGTH):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_UPDATE_INTERVAL):
cv.positive_time_period_milliseconds,
}),
vol.Optional(CONF_STROBE):
cv.Schema({
cv.GenerateID(CONF_EFFECT_ID):
cv.declare_variable_id(StrobeLightEffect),
vol.Optional(CONF_NAME, default="Strobe"):
cv.string,
vol.Optional(CONF_COLORS):
vol.All(
cv.ensure_list(
cv.Schema({
vol.Optional(CONF_STATE, default=True):
cv.boolean,
vol.Optional(CONF_BRIGHTNESS, default=1.0):
cv.percentage,
vol.Optional(CONF_RED, default=1.0):
cv.percentage,
vol.Optional(CONF_GREEN, default=1.0):
cv.percentage,
vol.Optional(CONF_BLUE, default=1.0):
cv.percentage,
vol.Optional(CONF_WHITE, default=1.0):
cv.percentage,
vol.Required(CONF_DURATION):
cv.positive_time_period_milliseconds,
}),
cv.has_at_least_one_key(CONF_STATE, CONF_BRIGHTNESS, CONF_RED,
CONF_GREEN, CONF_BLUE, CONF_WHITE)),
vol.Length(min=2)),
}),
vol.Optional(CONF_FLICKER):
cv.Schema({
cv.GenerateID(CONF_EFFECT_ID):
cv.declare_variable_id(FlickerLightEffect),
vol.Optional(CONF_NAME, default="Flicker"):
cv.string,
vol.Optional(CONF_ALPHA):
cv.percentage,
vol.Optional(CONF_INTENSITY):
cv.percentage,
}),
vol.Optional(CONF_ADDRESSABLE_LAMBDA):
cv.Schema({
vol.Required(CONF_NAME):
cv.string,
vol.Required(CONF_LAMBDA):
cv.lambda_,
vol.Optional(CONF_UPDATE_INTERVAL, default='0ms'):
cv.positive_time_period_milliseconds,
}),
vol.Optional(CONF_ADDRESSABLE_RAINBOW):
cv.Schema({
cv.GenerateID(CONF_EFFECT_ID):
cv.declare_variable_id(AddressableRainbowLightEffect),
vol.Optional(CONF_NAME, default="Rainbow"):
cv.string,
vol.Optional(CONF_SPEED):
cv.uint32_t,
vol.Optional(CONF_WIDTH):
cv.uint32_t,
}),
vol.Optional(CONF_ADDRESSABLE_COLOR_WIPE):
cv.Schema({
cv.GenerateID(CONF_EFFECT_ID):
cv.declare_variable_id(AddressableColorWipeEffect),
vol.Optional(CONF_NAME, default="Color Wipe"):
cv.string,
vol.Optional(CONF_COLORS):
cv.ensure_list({
vol.Optional(CONF_RED, default=1.0):
cv.percentage,
vol.Optional(CONF_GREEN, default=1.0):
cv.percentage,
vol.Optional(CONF_BLUE, default=1.0):
cv.percentage,
vol.Optional(CONF_WHITE, default=1.0):
cv.percentage,
vol.Optional(CONF_RANDOM, default=False):
cv.boolean,
vol.Required(CONF_NUM_LEDS):
vol.All(cv.uint32_t, vol.Range(min=1)),
}),
vol.Optional(CONF_ADD_LED_INTERVAL):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_REVERSE):
cv.boolean,
}),
vol.Optional(CONF_ADDRESSABLE_SCAN):
cv.Schema({
cv.GenerateID(CONF_EFFECT_ID):
cv.declare_variable_id(AddressableScanEffect),
vol.Optional(CONF_NAME, default="Scan"):
cv.string,
vol.Optional(CONF_MOVE_INTERVAL):
cv.positive_time_period_milliseconds,
}),
vol.Optional(CONF_ADDRESSABLE_TWINKLE):
cv.Schema({
cv.GenerateID(CONF_EFFECT_ID):
cv.declare_variable_id(AddressableTwinkleEffect),
vol.Optional(CONF_NAME, default="Twinkle"):
cv.string,
vol.Optional(CONF_TWINKLE_PROBABILITY):
cv.percentage,
vol.Optional(CONF_PROGRESS_INTERVAL):
cv.positive_time_period_milliseconds,
}),
vol.Optional(CONF_ADDRESSABLE_RANDOM_TWINKLE):
cv.Schema({
cv.GenerateID(CONF_EFFECT_ID):
cv.declare_variable_id(AddressableRandomTwinkleEffect),
vol.Optional(CONF_NAME, default="Random Twinkle"):
cv.string,
vol.Optional(CONF_TWINKLE_PROBABILITY):
cv.percentage,
vol.Optional(CONF_PROGRESS_INTERVAL):
cv.positive_time_period_milliseconds,
}),
vol.Optional(CONF_ADDRESSABLE_FIREWORKS):
cv.Schema({
cv.GenerateID(CONF_EFFECT_ID):
cv.declare_variable_id(AddressableFireworksEffect),
vol.Optional(CONF_NAME, default="Fireworks"):
cv.string,
vol.Optional(CONF_UPDATE_INTERVAL):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_SPARK_PROBABILITY):
cv.percentage,
vol.Optional(CONF_USE_RANDOM_COLOR):
cv.boolean,
vol.Optional(CONF_FADE_OUT_RATE):
cv.uint8_t,
}),
vol.Optional(CONF_ADDRESSABLE_FLICKER):
cv.Schema({
cv.GenerateID(CONF_EFFECT_ID):
cv.declare_variable_id(AddressableFlickerEffect),
vol.Optional(CONF_NAME, default="Addressable Flicker"):
cv.string,
vol.Optional(CONF_UPDATE_INTERVAL):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_INTENSITY):
cv.percentage,
}),
})
CONF_WAKEUP_PIN_MODE = 'wakeup_pin_mode'
CONF_ESP32_EXT1_WAKEUP = 'esp32_ext1_wakeup'
CONFIG_SCHEMA = cv.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.internal_gpio_input_pin_schema,
validate_pin_number),
vol.Optional(CONF_WAKEUP_PIN_MODE):
vol.All(cv.only_on_esp32, cv.one_of(*WAKEUP_PIN_MODES), upper=True),
vol.Optional(CONF_ESP32_EXT1_WAKEUP):
vol.All(
cv.only_on_esp32,
cv.Schema({
vol.Required(CONF_PINS):
cv.ensure_list(pins.shorthand_input_pin, validate_pin_number),
vol.Required(CONF_MODE):
cv.one_of(*EXT1_WAKEUP_MODES, upper=True),
})),
vol.Optional(CONF_RUN_DURATION):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_RUN_CYCLES):
cv.invalid("The run_cycles option has been removed in 1.11.0 as "
"it was essentially the same as a run_duration of 0s."
"Please use run_duration now.")
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
return config
CONFIG_SCHEMA = vol.All(
cv.Schema({
cv.GenerateID():
cv.declare_variable_id(EthernetComponent),
vol.Required(CONF_TYPE):
cv.one_of(*ETHERNET_TYPES, upper=True),
vol.Required(CONF_MDC_PIN):
pins.output_pin,
vol.Required(CONF_MDIO_PIN):
pins.input_output_pin,
vol.Optional(CONF_CLK_MODE, default='GPIO0_IN'):
cv.one_of(*CLK_MODES, upper=True, space='_'),
vol.Optional(CONF_PHY_ADDR, default=0):
vol.All(cv.int_, vol.Range(min=0, max=31)),
vol.Optional(CONF_POWER_PIN):
pins.gpio_output_pin_schema,
vol.Optional(CONF_MANUAL_IP):
wifi.STA_MANUAL_IP_SCHEMA,
vol.Optional(CONF_DOMAIN, default='.local'):
cv.domain_name,
vol.Optional(CONF_USE_ADDRESS):
cv.string_strict,
vol.Optional('hostname'):
cv.invalid("The hostname option has been removed in 1.11.0"),
}), validate)
def to_code(config):
rhs = App.init_ethernet()
UARTDevice = pi4home_ns.class_('UARTDevice')
MULTI_CONF = True
def validate_rx_pin(value):
value = pins.input_pin(value)
if CORE.is_esp8266 and value >= 16:
raise vol.Invalid(
"Pins GPIO16 and GPIO17 cannot be used as RX pins on ESP8266.")
return value
CONFIG_SCHEMA = vol.All(
cv.Schema({
cv.GenerateID(): cv.declare_variable_id(UARTComponent),
vol.Optional(CONF_TX_PIN): pins.output_pin,
vol.Optional(CONF_RX_PIN): validate_rx_pin,
vol.Required(CONF_BAUD_RATE): cv.positive_int,
}).extend(cv.COMPONENT_SCHEMA.schema),
cv.has_at_least_one_key(CONF_TX_PIN, CONF_RX_PIN))
def to_code(config):
rhs = App.init_uart(config[CONF_BAUD_RATE])
var = Pvariable(config[CONF_ID], rhs)
if CONF_TX_PIN in config:
add(var.set_tx_pin(config[CONF_TX_PIN]))
if CONF_RX_PIN in config:
add(var.set_rx_pin(config[CONF_RX_PIN]))
setup_component(var, config)
CONF_LEVEL
from pi4home.cpp_generator import Pvariable, add, get_variable, templatable
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import App, Component, pi4home_ns, Action, float_
Servo = pi4home_ns.class_('Servo', Component)
ServoWriteAction = pi4home_ns.class_('ServoWriteAction', Action)
MULTI_CONF = True
CONFIG_SCHEMA = cv.Schema({
vol.Required(CONF_ID):
cv.declare_variable_id(Servo),
vol.Required(CONF_OUTPUT):
cv.use_variable_id(FloatOutput),
vol.Optional(CONF_MIN_LEVEL, default='3%'):
cv.percentage,
vol.Optional(CONF_IDLE_LEVEL, default='7.5%'):
cv.percentage,
vol.Optional(CONF_MAX_LEVEL, default='12%'):
cv.percentage,
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
for out in get_variable(config[CONF_OUTPUT]):
yield
rhs = App.register_component(Servo.new(out))
servo = Pvariable(config[CONF_ID], rhs)
add(servo.set_min_level(config[CONF_MIN_LEVEL]))
import voluptuous as vol
import pi4home.config_validation as cv
from pi4home.const import CONF_CSS_URL, CONF_ID, CONF_JS_URL, CONF_PORT
from pi4home.core import CORE
from pi4home.cpp_generator import Pvariable, add
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import App, Component, StoringController, pi4home_ns
WebServer = pi4home_ns.class_('WebServer', Component, StoringController)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID(): cv.declare_variable_id(WebServer),
vol.Optional(CONF_PORT): cv.port,
vol.Optional(CONF_CSS_URL): cv.string,
vol.Optional(CONF_JS_URL): cv.string,
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
rhs = App.init_web_server(config.get(CONF_PORT))
web_server = Pvariable(config[CONF_ID], rhs)
if CONF_CSS_URL in config:
add(web_server.set_css_url(config[CONF_CSS_URL]))
if CONF_JS_URL in config:
add(web_server.set_js_url(config[CONF_JS_URL]))
setup_component(web_server, config)
REQUIRED_BUILD_FLAGS = '-DUSE_WEB_SERVER'
if CORE.is_esp8266 and value[CONF_NUMBER] >= 16:
raise vol.Invalid(
"Pins GPIO16 and GPIO17 cannot be used as pulse counters on ESP8266."
)
return value
PLATFORM_SCHEMA = cv.nameable(
sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(PulseCounterSensorComponent),
vol.Required(CONF_PIN):
validate_pulse_counter_pin,
vol.Optional(CONF_COUNT_MODE):
cv.Schema({
vol.Required(CONF_RISING_EDGE): COUNT_MODE_SCHEMA,
vol.Required(CONF_FALLING_EDGE): COUNT_MODE_SCHEMA,
}),
vol.Optional(CONF_INTERNAL_FILTER):
validate_internal_filter,
vol.Optional(CONF_UPDATE_INTERVAL):
cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
for pin in gpio_input_pin_expression(config[CONF_PIN]):
yield
rhs = App.make_pulse_counter_sensor(config[CONF_NAME], pin,
config.get(CONF_UPDATE_INTERVAL))
pcnt = Pvariable(config[CONF_ID], rhs)
if not isinstance(value, string_types):
raise vol.Invalid("Not valid dumpers")
if value.upper() == "ALL":
return list(sorted(list(DUMPERS)))
raise vol.Invalid("Not valid dumpers")
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_variable_id(RemoteReceiverComponent),
vol.Required(CONF_PIN):
vol.All(pins.internal_gpio_input_pin_schema, pins.validate_has_interrupt),
vol.Optional(CONF_DUMP, default=[]):
vol.Any(validate_dumpers_all,
cv.ensure_list(cv.one_of(*DUMPERS, lower=True))),
vol.Optional(CONF_TOLERANCE):
vol.All(cv.percentage_int, vol.Range(min=0)),
vol.Optional(CONF_BUFFER_SIZE):
cv.validate_bytes,
vol.Optional(CONF_FILTER):
cv.positive_time_period_microseconds,
vol.Optional(CONF_IDLE):
cv.positive_time_period_microseconds,
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
for pin in gpio_input_pin_expression(config[CONF_PIN]):
yield
rhs = App.make_remote_receiver_component(pin)
receiver = Pvariable(config[CONF_ID], rhs)
CONFIG_SCHEMA = cv.Schema({
cv.GenerateID():
cv.declare_variable_id(ESP32Camera),
vol.Required(CONF_NAME):
cv.string,
vol.Required(CONF_DATA_PINS):
vol.All([pins.input_pin], vol.Length(min=8, max=8)),
vol.Required(CONF_VSYNC_PIN):
pins.input_pin,
vol.Required(CONF_HREF_PIN):
pins.input_pin,
vol.Required(CONF_PIXEL_CLOCK_PIN):
pins.input_pin,
vol.Required(CONF_EXTERNAL_CLOCK):
cv.Schema({
vol.Required(CONF_PIN):
pins.output_pin,
vol.Optional(CONF_FREQUENCY, default='20MHz'):
vol.All(cv.frequency, vol.In([20e6, 10e6])),
}),
vol.Required(CONF_I2C_PINS):
cv.Schema({
vol.Required(CONF_SDA): pins.output_pin,
vol.Required(CONF_SCL): pins.output_pin,
}),
vol.Optional(CONF_RESET_PIN):
pins.output_pin,
vol.Optional(CONF_POWER_DOWN_PIN):
pins.output_pin,
vol.Optional(CONF_MAX_FRAMERATE, default='10 fps'):
vol.All(cv.framerate, vol.Range(min=0, min_included=False, max=60)),
vol.Optional(CONF_IDLE_FRAMERATE, default='0.1 fps'):
vol.All(cv.framerate, vol.Range(min=0, max=1)),
vol.Optional(CONF_RESOLUTION, default='640X480'):
cv.one_of(*FRAME_SIZES, upper=True),
vol.Optional(CONF_JPEG_QUALITY, default=10):
vol.All(cv.int_, vol.Range(min=10, max=63)),
vol.Optional(CONF_CONTRAST, default=0):
camera_range_param,
vol.Optional(CONF_BRIGHTNESS, default=0):
camera_range_param,
vol.Optional(CONF_SATURATION, default=0):
camera_range_param,
vol.Optional(CONF_VERTICAL_FLIP, default=True):
cv.boolean,
vol.Optional(CONF_HORIZONTAL_MIRROR, default=True):
cv.boolean,
vol.Optional(CONF_TEST_PATTERN, default=False):
cv.boolean,
}).extend(cv.COMPONENT_SCHEMA.schema)
sensor.setup_sensor(template, config)
setup_component(template, config)
if CONF_LAMBDA in config:
for template_ in process_lambda(config[CONF_LAMBDA], [],
return_type=optional.template(float_)):
yield
add(template.set_template(template_))
BUILD_FLAGS = '-DUSE_TEMPLATE_SENSOR'
CONF_SENSOR_TEMPLATE_PUBLISH = 'sensor.template.publish'
SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
vol.Required(CONF_ID):
cv.use_variable_id(sensor.Sensor),
vol.Required(CONF_STATE):
cv.templatable(cv.float_),
})
@ACTION_REGISTRY.register(CONF_SENSOR_TEMPLATE_PUBLISH,
SENSOR_TEMPLATE_PUBLISH_ACTION_SCHEMA)
def sensor_template_publish_to_code(config, action_id, template_arg, args):
for var in get_variable(config[CONF_ID]):
yield None
rhs = var.make_sensor_publish_action(template_arg)
type = SensorPublishAction.template(template_arg)
action = Pvariable(action_id, rhs, type=type)
for template_ in templatable(config[CONF_STATE], args, float_):
yield None
add(action.set_state(template_))
config[CONF_CLOSE_ACTION])
if CONF_STOP_ACTION in config:
automation.build_automations(var.get_stop_trigger(), [],
config[CONF_STOP_ACTION])
if CONF_OPTIMISTIC in config:
add(var.set_optimistic(config[CONF_OPTIMISTIC]))
if CONF_ASSUMED_STATE in config:
add(var.set_assumed_state(config[CONF_ASSUMED_STATE]))
BUILD_FLAGS = '-DUSE_TEMPLATE_COVER'
CONF_COVER_TEMPLATE_PUBLISH = 'cover.template.publish'
COVER_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.Schema({
vol.Required(CONF_ID):
cv.use_variable_id(cover.Cover),
vol.Required(CONF_STATE):
cv.templatable(cover.validate_cover_state),
})
@ACTION_REGISTRY.register(CONF_COVER_TEMPLATE_PUBLISH,
COVER_TEMPLATE_PUBLISH_ACTION_SCHEMA)
def cover_template_publish_to_code(config, action_id, template_arg, args):
for var in get_variable(config[CONF_ID]):
yield None
rhs = var.make_cover_publish_action(template_arg)
type = CoverPublishAction.template(template_arg)
action = Pvariable(action_id, rhs, type=type)
state = config[CONF_STATE]
if isinstance(state, string_types):
template_ = cover.COVER_STATES[state]
