def validate_recursive_action(value):
is_list = isinstance(value, list)
if not is_list:
value = [value]
for i, item in enumerate(value):
path = [i] if is_list else []
item = copy.deepcopy(item)
if not isinstance(item, dict):
raise vol.Invalid(u"Action must consist of key-value mapping! Got {}".format(item),
path)
key = next((x for x in item if x != CONF_ACTION_ID), None)
if key is None:
raise vol.Invalid(u"Key missing from action! Got {}".format(item), path)
if key not in ACTION_REGISTRY:
raise vol.Invalid(u"Unable to find action with the name '{}', is the component loaded?"
u"".format(key), path + [key])
item.setdefault(CONF_ACTION_ID, None)
key2 = next((x for x in item if x not in (CONF_ACTION_ID, key)), None)
if key2 is not None:
raise vol.Invalid(u"Cannot have two actions in one item. Key '{}' overrides '{}'! "
u"Did you forget to indent the block inside the action?"
u"".format(key, key2), path)
validator = ACTION_REGISTRY[key][0]
try:
action = validator(item[key] or {})
except vol.Invalid as err:
err.prepend(path)
raise err
value[i] = {
CONF_ACTION_ID: cv.declare_variable_id(Action)(item[CONF_ACTION_ID]),
key: action,
}
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
})
from pi4home.components.uart import UARTComponent
import pi4home.config_validation as cv
from pi4home.const import CONF_ID, CONF_LAMBDA, CONF_UART_ID
from pi4home.cpp_generator import Pvariable, add, get_variable, process_lambda
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import App, PollingComponent, void
DEPENDENCIES = ['uart']
Nextion = display.display_ns.class_('Nextion', PollingComponent,
uart.UARTDevice)
NextionRef = Nextion.operator('ref')
PLATFORM_SCHEMA = display.BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(Nextion),
cv.GenerateID(CONF_UART_ID):
cv.use_variable_id(UARTComponent),
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
for uart_ in get_variable(config[CONF_UART_ID]):
yield
rhs = App.make_nextion(uart_)
nextion = Pvariable(config[CONF_ID], rhs)
if CONF_LAMBDA in config:
for lambda_ in process_lambda(config[CONF_LAMBDA],
[(NextionRef, 'it')],
return_type=void):
'1X': TCS34725Gain.TCS34725_GAIN_1X,
'4X': TCS34725Gain.TCS34725_GAIN_4X,
'16X': TCS34725Gain.TCS34725_GAIN_16X,
'60X': TCS34725Gain.TCS34725_GAIN_60X,
}
TCS35725IlluminanceSensor = sensor.sensor_ns.class_(
'TCS35725IlluminanceSensor', sensor.EmptyPollingParentSensor)
TCS35725ColorTemperatureSensor = sensor.sensor_ns.class_(
'TCS35725ColorTemperatureSensor', sensor.EmptyPollingParentSensor)
TCS35725ColorChannelSensor = sensor.sensor_ns.class_(
'TCS35725ColorChannelSensor', sensor.EmptyPollingParentSensor)
COLOR_CHANNEL_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(TCS35725ColorChannelSensor),
})
SENSOR_KEYS = [
CONF_RED_CHANNEL, CONF_GREEN_CHANNEL, CONF_BLUE_CHANNEL,
CONF_CLEAR_CHANNEL, CONF_ILLUMINANCE, CONF_COLOR_TEMPERATURE
]
PLATFORM_SCHEMA = vol.All(
sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(TCS34725Component),
vol.Optional(CONF_ADDRESS):
cv.i2c_address,
vol.Optional(CONF_RED_CHANNEL):
cv.nameable(COLOR_CHANNEL_SENSOR_SCHEMA),
'rc_switch': remote_ns.class_('RCSwitchDumper', RemoteReceiveDumper),
'rc5': remote_ns.class_('RC5Dumper', RemoteReceiveDumper),
}
def validate_dumpers_all(value):
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)
try:
import pytz
return convert_tz(pytz.timezone(value))
except Exception: # pylint: disable=broad-except
return value
TIME_PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_TIMEZONE, default=detect_tz):
validate_tz,
vol.Optional(CONF_ON_TIME):
automation.validate_automation(
{
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_variable_id(CronTrigger),
vol.Optional(CONF_SECONDS): validate_cron_seconds,
vol.Optional(CONF_MINUTES): validate_cron_minutes,
vol.Optional(CONF_HOURS): validate_cron_hours,
vol.Optional(CONF_DAYS_OF_MONTH): validate_cron_days_of_month,
vol.Optional(CONF_MONTHS): validate_cron_months,
vol.Optional(CONF_DAYS_OF_WEEK): validate_cron_days_of_week,
vol.Optional(CONF_CRON): validate_cron_raw,
}, validate_cron_keys),
})
def setup_time_core_(time_var, config):
add(time_var.set_timezone(config[CONF_TIMEZONE]))
for conf in config.get(CONF_ON_TIME, []):
import voluptuous as vol
from pi4home.components import sensor
import pi4home.config_validation as cv
from pi4home.const import CONF_ENTITY_ID, CONF_ID, CONF_NAME
from pi4home.cpp_generator import Pvariable
from pi4home.cpp_types import App
DEPENDENCIES = ['api']
HomeassistantSensor = sensor.sensor_ns.class_('HomeassistantSensor',
sensor.Sensor)
PLATFORM_SCHEMA = cv.nameable(
sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(HomeassistantSensor),
vol.Required(CONF_ENTITY_ID):
cv.entity_id,
}))
def to_code(config):
rhs = App.make_homeassistant_sensor(config[CONF_NAME],
config[CONF_ENTITY_ID])
subs = Pvariable(config[CONF_ID], rhs)
sensor.setup_sensor(subs, config)
BUILD_FLAGS = '-DUSE_HOMEASSISTANT_SENSOR'
from pi4home.components import text_sensor
import pi4home.config_validation as cv
from pi4home.const import CONF_ID, CONF_NAME
from pi4home.cpp_generator import Pvariable
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import App, Component
VersionTextSensor = text_sensor.text_sensor_ns.class_('VersionTextSensor',
text_sensor.TextSensor,
Component)
PLATFORM_SCHEMA = cv.nameable(
text_sensor.TEXT_SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(VersionTextSensor),
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
rhs = App.make_version_text_sensor(config[CONF_NAME])
sens = Pvariable(config[CONF_ID], rhs)
text_sensor.setup_text_sensor(sens, config)
setup_component(sens, config)
BUILD_FLAGS = '-DUSE_VERSION_TEXT_SENSOR'
from pi4home import config_validation as cv
from pi4home.components import sensor
from pi4home.const import CONF_ID, CONF_SCAN_INTERVAL, ESP_PLATFORM_ESP32
from pi4home.core import HexInt
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()
import voluptuous as vol
from pi4home.components import light, output
import pi4home.config_validation as cv
from pi4home.const import CONF_EFFECTS, CONF_MAKE_ID, CONF_NAME, CONF_OUTPUT
from pi4home.cpp_generator import get_variable, variable
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import App
PLATFORM_SCHEMA = cv.nameable(
light.LIGHT_PLATFORM_SCHEMA.extend({
cv.GenerateID(CONF_MAKE_ID):
cv.declare_variable_id(light.MakeLight),
vol.Required(CONF_OUTPUT):
cv.use_variable_id(output.BinaryOutput),
vol.Optional(CONF_EFFECTS):
light.validate_effects(light.BINARY_EFFECTS),
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
for output_ in get_variable(config[CONF_OUTPUT]):
yield
rhs = App.make_binary_light(config[CONF_NAME], output_)
light_struct = variable(config[CONF_MAKE_ID], rhs)
light.setup_light(light_struct.Pstate, config)
setup_component(light_struct.Pstate, config)
MPU6050AccelSensor = sensor.sensor_ns.class_('MPU6050AccelSensor',
sensor.EmptyPollingParentSensor)
MPU6050GyroSensor = sensor.sensor_ns.class_('MPU6050GyroSensor',
sensor.EmptyPollingParentSensor)
MPU6050TemperatureSensor = sensor.sensor_ns.class_(
'MPU6050TemperatureSensor', sensor.EmptyPollingParentSensor)
SENSOR_KEYS = [
CONF_ACCEL_X, CONF_ACCEL_Y, CONF_ACCEL_Z, CONF_GYRO_X, CONF_GYRO_Y,
CONF_GYRO_Z
]
PLATFORM_SCHEMA = vol.All(
sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(MPU6050Component),
vol.Optional(CONF_ADDRESS, default=0x68):
cv.i2c_address,
vol.Optional(CONF_ACCEL_X):
cv.nameable(
sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(MPU6050AccelSensor),
})),
vol.Optional(CONF_ACCEL_Y):
cv.nameable(
sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(MPU6050AccelSensor),
})),
vol.Optional(CONF_ACCEL_Z):
from pi4home import pins
from pi4home.components import sensor
import pi4home.config_validation as cv
from pi4home.const import CONF_ID, CONF_NAME, CONF_PIN, CONF_UPDATE_INTERVAL
from pi4home.cpp_generator import Pvariable
from pi4home.cpp_helpers import gpio_input_pin_expression, setup_component
from pi4home.cpp_types import App
DutyCycleSensor = sensor.sensor_ns.class_('DutyCycleSensor',
sensor.PollingSensorComponent)
PLATFORM_SCHEMA = cv.nameable(
sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(DutyCycleSensor),
vol.Required(CONF_PIN):
vol.All(pins.internal_gpio_input_pin_schema,
pins.validate_has_interrupt),
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_duty_cycle_sensor(config[CONF_NAME], pin,
config.get(CONF_UPDATE_INTERVAL))
duty = Pvariable(config[CONF_ID], rhs)
sensor.setup_sensor(duty, config)
from pi4home.components import sensor
from pi4home.components.esp32_ble_tracker import CONF_ESP32_BLE_ID, ESP32BLETracker, \
make_address_array
import pi4home.config_validation as cv
from pi4home.const import CONF_MAC_ADDRESS, CONF_NAME
from pi4home.cpp_generator import get_variable
from pi4home.cpp_types import pi4home_ns
DEPENDENCIES = ['esp32_ble_tracker']
ESP32BLERSSISensor = pi4home_ns.class_('ESP32BLERSSISensor', sensor.Sensor)
PLATFORM_SCHEMA = cv.nameable(
sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(ESP32BLERSSISensor),
vol.Required(CONF_MAC_ADDRESS):
cv.mac_address,
cv.GenerateID(CONF_ESP32_BLE_ID):
cv.use_variable_id(ESP32BLETracker)
}))
def to_code(config):
for hub in get_variable(config[CONF_ESP32_BLE_ID]):
yield
rhs = hub.make_rssi_sensor(config[CONF_NAME],
make_address_array(config[CONF_MAC_ADDRESS]))
sensor.register_sensor(rhs, config)
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({
import pi4home.config_validation as cv
from pi4home.const import CONF_CS_PIN, CONF_ID, CONF_INTENSITY, CONF_LAMBDA, CONF_NUM_CHIPS, \
CONF_SPI_ID
from pi4home.cpp_generator import Pvariable, add, get_variable, process_lambda
from pi4home.cpp_helpers import gpio_output_pin_expression, setup_component
from pi4home.cpp_types import App, PollingComponent, void
DEPENDENCIES = ['spi']
MAX7219Component = display.display_ns.class_('MAX7219Component',
PollingComponent, spi.SPIDevice)
MAX7219ComponentRef = MAX7219Component.operator('ref')
PLATFORM_SCHEMA = display.BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(MAX7219Component),
cv.GenerateID(CONF_SPI_ID):
cv.use_variable_id(SPIComponent),
vol.Required(CONF_CS_PIN):
pins.gpio_output_pin_schema,
vol.Optional(CONF_NUM_CHIPS):
vol.All(cv.uint8_t, vol.Range(min=1)),
vol.Optional(CONF_INTENSITY):
vol.All(cv.uint8_t, vol.Range(min=0, max=15)),
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
for spi_ in get_variable(config[CONF_SPI_ID]):
yield
for cs in gpio_output_pin_expression(config[CONF_CS_PIN]):
from pi4home.components import binary_sensor
import pi4home.config_validation as cv
from pi4home.const import CONF_ID, CONF_NAME
from pi4home.cpp_generator import Pvariable
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import App, Component
StatusBinarySensor = binary_sensor.binary_sensor_ns.class_(
'StatusBinarySensor', binary_sensor.BinarySensor, Component)
PLATFORM_SCHEMA = cv.nameable(
binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(StatusBinarySensor),
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
rhs = App.make_status_binary_sensor(config[CONF_NAME])
status = Pvariable(config[CONF_ID], rhs)
binary_sensor.setup_binary_sensor(status, config)
setup_component(status, config)
BUILD_FLAGS = '-DUSE_STATUS_BINARY_SENSOR'
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'
def validate(config):
if CONF_USE_ADDRESS not in config:
if CONF_MANUAL_IP in config:
use_address = str(config[CONF_MANUAL_IP][CONF_STATIC_IP])
else:
use_address = CORE.name + config[CONF_DOMAIN]
config[CONF_USE_ADDRESS] = use_address
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'):
def validate_range(value):
value = cv.string(value)
if value.endswith(u'µT') or value.endswith('uT'):
value = value[:-2]
return cv.one_of(*HMC5883L_RANGES, int=True)(value)
SENSOR_KEYS = [
CONF_FIELD_STRENGTH_X, CONF_FIELD_STRENGTH_Y, CONF_FIELD_STRENGTH_Z,
CONF_HEADING
]
PLATFORM_SCHEMA = vol.All(
sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(HMC5883LComponent),
vol.Optional(CONF_ADDRESS):
cv.i2c_address,
vol.Optional(CONF_FIELD_STRENGTH_X):
cv.nameable(
sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(HMC5883LFieldStrengthSensor),
})),
vol.Optional(CONF_FIELD_STRENGTH_Y):
cv.nameable(
sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(HMC5883LFieldStrengthSensor),
})),
vol.Optional(CONF_FIELD_STRENGTH_Z):
import voluptuous as vol
from pi4home.components import sensor
from pi4home.components.dallas import DallasComponent
import pi4home.config_validation as cv
from pi4home.const import CONF_ADDRESS, CONF_DALLAS_ID, CONF_INDEX, CONF_NAME, \
CONF_RESOLUTION
from pi4home.cpp_generator import HexIntLiteral, get_variable
DallasTemperatureSensor = sensor.sensor_ns.class_(
'DallasTemperatureSensor', sensor.EmptyPollingParentSensor)
PLATFORM_SCHEMA = cv.nameable(
sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(DallasTemperatureSensor),
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=9, max=12)),
}), cv.has_at_least_one_key(CONF_ADDRESS, CONF_INDEX))
def to_code(config):
for hub in get_variable(config[CONF_DALLAS_ID]):
yield
if CONF_ADDRESS in config:
PartitionLightOutput = light.light_ns.class_('PartitionLightOutput',
AddressableLight)
MakePartitionLight = Application.struct('MakePartitionLight')
def validate_from_to(value):
if value[CONF_FROM] > value[CONF_TO]:
raise vol.Invalid(u"From ({}) must not be larger than to ({})"
u"".format(value[CONF_FROM], value[CONF_TO]))
return value
PLATFORM_SCHEMA = cv.nameable(
light.LIGHT_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(light.AddressableLightState),
cv.GenerateID(CONF_MAKE_ID):
cv.declare_variable_id(MakePartitionLight),
vol.Required(CONF_SEGMENTS):
vol.All(
cv.ensure_list(
{
vol.Required(CONF_ID):
cv.use_variable_id(light.AddressableLightState),
vol.Required(CONF_FROM):
cv.positive_int,
vol.Required(CONF_TO):
cv.positive_int,
}, validate_from_to), vol.Length(min=1)),
vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH):
cv.positive_time_period_milliseconds,
from pi4home.cpp_generator import Pvariable, get_variable
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import App, PollingComponent
DEPENDENCIES = ['uart']
MHZ19Component = sensor.sensor_ns.class_('MHZ19Component', PollingComponent,
uart.UARTDevice)
MHZ19TemperatureSensor = sensor.sensor_ns.class_(
'MHZ19TemperatureSensor', sensor.EmptyPollingParentSensor)
MHZ19CO2Sensor = sensor.sensor_ns.class_('MHZ19CO2Sensor',
sensor.EmptyPollingParentSensor)
PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(MHZ19Component),
cv.GenerateID(CONF_UART_ID):
cv.use_variable_id(UARTComponent),
vol.Required(CONF_CO2):
cv.nameable(
sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(MHZ19CO2Sensor),
})),
vol.Optional(CONF_TEMPERATURE):
cv.nameable(
sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(MHZ19TemperatureSensor),
})),
vol.Optional(CONF_UPDATE_INTERVAL):
HX711Sensor = sensor.sensor_ns.class_('HX711Sensor',
sensor.PollingSensorComponent)
CONF_DOUT_PIN = 'dout_pin'
HX711Gain = sensor.sensor_ns.enum('HX711Gain')
GAINS = {
128: HX711Gain.HX711_GAIN_128,
32: HX711Gain.HX711_GAIN_32,
64: HX711Gain.HX711_GAIN_64,
}
PLATFORM_SCHEMA = cv.nameable(
sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(HX711Sensor),
vol.Required(CONF_DOUT_PIN):
pins.gpio_input_pin_schema,
vol.Required(CONF_CLK_PIN):
pins.gpio_output_pin_schema,
vol.Optional(CONF_GAIN):
cv.one_of(*GAINS, int=True),
vol.Optional(CONF_UPDATE_INTERVAL):
cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
for dout_pin in gpio_input_pin_expression(config[CONF_DOUT_PIN]):
yield
for sck_pin in gpio_input_pin_expression(config[CONF_CLK_PIN]):
if value[1] > 4:
raise vol.Invalid("LCD displays can't have more than 4 rows")
return value
def validate_pin_length(value):
if len(value) != 4 and len(value) != 8:
raise vol.Invalid(
"LCD Displays can either operate in 4-pin or 8-pin mode,"
"not {}-pin mode".format(len(value)))
return value
PLATFORM_SCHEMA = display.BASIC_DISPLAY_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(GPIOLCDDisplay),
vol.Required(CONF_DIMENSIONS):
validate_lcd_dimensions,
vol.Required(CONF_DATA_PINS):
vol.All([pins.gpio_output_pin_schema], validate_pin_length),
vol.Required(CONF_ENABLE_PIN):
pins.gpio_output_pin_schema,
vol.Required(CONF_RS_PIN):
pins.gpio_output_pin_schema,
vol.Optional(CONF_RW_PIN):
pins.gpio_output_pin_schema,
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
rhs = App.make_gpio_lcd_display(config[CONF_DIMENSIONS][0],
def validate_integration_time(value):
value = cv.positive_time_period_milliseconds(value).total_milliseconds
if value not in INTEGRATION_TIMES:
raise vol.Invalid(u"Unsupported integration time {}.".format(value))
return value
TSL2561Sensor = sensor.sensor_ns.class_('TSL2561Sensor',
sensor.PollingSensorComponent,
i2c.I2CDevice)
PLATFORM_SCHEMA = cv.nameable(
sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(TSL2561Sensor),
vol.Optional(CONF_ADDRESS, default=0x39):
cv.i2c_address,
vol.Optional(CONF_INTEGRATION_TIME):
validate_integration_time,
vol.Optional(CONF_GAIN):
cv.one_of(*GAINS, upper=True),
vol.Optional(CONF_IS_CS_PACKAGE):
cv.boolean,
vol.Optional(CONF_UPDATE_INTERVAL):
cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
rhs = App.make_tsl2561_sensor(config[CONF_NAME], config[CONF_ADDRESS],
from pi4home.components.output import FloatOutput
import pi4home.config_validation as cv
from pi4home.const import CONF_ID, CONF_IDLE_LEVEL, CONF_MAX_LEVEL, CONF_MIN_LEVEL, CONF_OUTPUT, \
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
import voluptuous as vol
from pi4home.components import output
import pi4home.config_validation as cv
from pi4home.const import CONF_ID, CONF_LAMBDA, CONF_OUTPUTS, CONF_TYPE
from pi4home.cpp_generator import process_lambda, variable
from pi4home.cpp_types import std_vector
CustomBinaryOutputConstructor = output.output_ns.class_(
'CustomBinaryOutputConstructor')
CustomFloatOutputConstructor = output.output_ns.class_(
'CustomFloatOutputConstructor')
BINARY_SCHEMA = output.PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(CustomBinaryOutputConstructor),
vol.Required(CONF_LAMBDA):
cv.lambda_,
vol.Required(CONF_TYPE):
'binary',
vol.Required(CONF_OUTPUTS):
cv.ensure_list(
output.BINARY_OUTPUT_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(output.BinaryOutput),
})),
})
FLOAT_SCHEMA = output.PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(CustomFloatOutputConstructor),
from pi4home.automation import ACTION_REGISTRY
from pi4home.components import sensor
import pi4home.config_validation as cv
from pi4home.const import CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_STATE, CONF_UPDATE_INTERVAL
from pi4home.cpp_generator import Pvariable, add, get_variable, process_lambda, templatable
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import Action, App, float_, optional
TemplateSensor = sensor.sensor_ns.class_('TemplateSensor',
sensor.PollingSensorComponent)
SensorPublishAction = sensor.sensor_ns.class_('SensorPublishAction', Action)
PLATFORM_SCHEMA = cv.nameable(
sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(TemplateSensor),
vol.Optional(CONF_LAMBDA):
cv.lambda_,
vol.Optional(CONF_UPDATE_INTERVAL):
cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
rhs = App.make_template_sensor(config[CONF_NAME],
config.get(CONF_UPDATE_INTERVAL))
template = Pvariable(config[CONF_ID], rhs)
sensor.setup_sensor(template, config)
setup_component(template, config)
from pi4home.cpp_types import App
DEPENDENCIES = ['i2c']
BH1750Resolution = sensor.sensor_ns.enum('BH1750Resolution')
BH1750_RESOLUTIONS = {
4.0: BH1750Resolution.BH1750_RESOLUTION_4P0_LX,
1.0: BH1750Resolution.BH1750_RESOLUTION_1P0_LX,
0.5: BH1750Resolution.BH1750_RESOLUTION_0P5_LX,
}
BH1750Sensor = sensor.sensor_ns.class_('BH1750Sensor', sensor.PollingSensorComponent,
i2c.I2CDevice)
PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(BH1750Sensor),
vol.Optional(CONF_ADDRESS, default=0x23): cv.i2c_address,
vol.Optional(CONF_RESOLUTION): vol.All(cv.positive_float, cv.one_of(*BH1750_RESOLUTIONS)),
vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
rhs = App.make_bh1750_sensor(config[CONF_NAME], config[CONF_ADDRESS],
config.get(CONF_UPDATE_INTERVAL))
bh1750 = Pvariable(config[CONF_ID], rhs)
if CONF_RESOLUTION in config:
add(bh1750.set_resolution(BH1750_RESOLUTIONS[config[CONF_RESOLUTION]]))
sensor.setup_sensor(bh1750, config)
setup_component(bh1750, config)
