BMP280Component = sensor.sensor_ns.class_('BMP280Component', PollingComponent,
i2c.I2CDevice)
BMP280TemperatureSensor = sensor.sensor_ns.class_(
'BMP280TemperatureSensor', sensor.EmptyPollingParentSensor)
BMP280PressureSensor = sensor.sensor_ns.class_('BMP280PressureSensor',
sensor.EmptyPollingParentSensor)
PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(BMP280Component),
vol.Optional(CONF_ADDRESS, default=0x77):
cv.i2c_address,
vol.Required(CONF_TEMPERATURE):
cv.nameable(
BMP280_OVERSAMPLING_SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(BMP280TemperatureSensor),
})),
vol.Required(CONF_PRESSURE):
cv.nameable(
BMP280_OVERSAMPLING_SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(BMP280PressureSensor),
})),
vol.Optional(CONF_IIR_FILTER):
cv.one_of(*IIR_FILTER_OPTIONS, upper=True),
vol.Optional(CONF_UPDATE_INTERVAL):
cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema)
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:
address = HexIntLiteral(config[CONF_ADDRESS])
rhs = hub.Pget_sensor_by_address(config[CONF_NAME], address,
config.get(CONF_RESOLUTION))
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),
vol.Optional(CONF_GREEN_CHANNEL):
cv.nameable(COLOR_CHANNEL_SENSOR_SCHEMA),
vol.Optional(CONF_BLUE_CHANNEL):
cv.nameable(COLOR_CHANNEL_SENSOR_SCHEMA),
vol.Optional(CONF_CLEAR_CHANNEL):
cv.nameable(COLOR_CHANNEL_SENSOR_SCHEMA),
vol.Optional(CONF_ILLUMINANCE):
cv.nameable(
sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(TCS35725IlluminanceSensor),
})),
vol.Optional(CONF_COLOR_TEMPERATURE):
cv.nameable(
sensor.SENSOR_SCHEMA.extend({
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)
BUILD_FLAGS = '-DUSE_BH1750'
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'
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):
cv.nameable(
sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(HMC5883LFieldStrengthSensor),
})),
vol.Optional(CONF_HEADING):
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]):
yield
rhs = App.make_hx711_sensor(config[CONF_NAME], dout_pin, sck_pin,
from pi4home.components import binary_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']
ESP32BLEPresenceDevice = pi4home_ns.class_('ESP32BLEPresenceDevice',
binary_sensor.BinarySensor)
PLATFORM_SCHEMA = cv.nameable(
binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(ESP32BLEPresenceDevice),
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_presence_sensor(
config[CONF_NAME], make_address_array(config[CONF_MAC_ADDRESS]))
binary_sensor.register_binary_sensor(rhs, config)
from pi4home.cpp_generator import Pvariable
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import App, PollingComponent
DEPENDENCIES = ['i2c']
DHT12Component = sensor.sensor_ns.class_('DHT12Component', PollingComponent, i2c.I2CDevice)
DHT12TemperatureSensor = sensor.sensor_ns.class_('DHT12TemperatureSensor',
sensor.EmptyPollingParentSensor)
DHT12HumiditySensor = sensor.sensor_ns.class_('DHT12HumiditySensor',
sensor.EmptyPollingParentSensor)
PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(DHT12Component),
vol.Required(CONF_TEMPERATURE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(DHT12TemperatureSensor),
})),
vol.Required(CONF_HUMIDITY): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(DHT12HumiditySensor),
})),
vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
rhs = App.make_dht12_sensor(config[CONF_TEMPERATURE][CONF_NAME],
config[CONF_HUMIDITY][CONF_NAME],
config.get(CONF_UPDATE_INTERVAL))
dht = Pvariable(config[CONF_ID], rhs)
sensor.setup_sensor(dht.Pget_temperature_sensor(), config[CONF_TEMPERATURE])
IPAddressWiFiInfo = text_sensor.text_sensor_ns.class_('IPAddressWiFiInfo',
text_sensor.TextSensor,
Component)
SSIDWiFiInfo = text_sensor.text_sensor_ns.class_('SSIDWiFiInfo',
text_sensor.TextSensor,
Component)
BSSIDWiFiInfo = text_sensor.text_sensor_ns.class_('BSSIDWiFiInfo',
text_sensor.TextSensor,
Component)
PLATFORM_SCHEMA = text_sensor.PLATFORM_SCHEMA.extend({
vol.Optional(CONF_IP_ADDRESS):
cv.nameable(
text_sensor.TEXT_SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(IPAddressWiFiInfo),
})),
vol.Optional(CONF_SSID):
cv.nameable(
text_sensor.TEXT_SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(SSIDWiFiInfo),
})),
vol.Optional(CONF_BSSID):
cv.nameable(
text_sensor.TEXT_SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(BSSIDWiFiInfo),
})),
})
from pi4home.cpp_helpers import setup_component
from pi4home.cpp_types import Action, App, optional
from pi4home.py_compat import string_types
TemplateCover = cover.cover_ns.class_('TemplateCover', cover.Cover)
CoverPublishAction = cover.cover_ns.class_('CoverPublishAction', Action)
PLATFORM_SCHEMA = cv.nameable(
cover.COVER_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(TemplateCover),
vol.Optional(CONF_LAMBDA):
cv.lambda_,
vol.Optional(CONF_OPTIMISTIC):
cv.boolean,
vol.Optional(CONF_ASSUMED_STATE):
cv.boolean,
vol.Optional(CONF_OPEN_ACTION):
automation.validate_automation(single=True),
vol.Optional(CONF_CLOSE_ACTION):
automation.validate_automation(single=True),
vol.Optional(CONF_STOP_ACTION):
automation.validate_automation(single=True),
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
rhs = App.make_template_cover(config[CONF_NAME])
var = Pvariable(config[CONF_ID], rhs)
cover.setup_cover(var, config)
DEPENDENCIES = ['uart']
CSE7766Component = sensor.sensor_ns.class_('CSE7766Component', PollingComponent, uart.UARTDevice)
CSE7766VoltageSensor = sensor.sensor_ns.class_('CSE7766VoltageSensor',
sensor.EmptySensor)
CSE7766CurrentSensor = sensor.sensor_ns.class_('CSE7766CurrentSensor',
sensor.EmptySensor)
CSE7766PowerSensor = sensor.sensor_ns.class_('CSE7766PowerSensor',
sensor.EmptySensor)
PLATFORM_SCHEMA = vol.All(sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(CSE7766Component),
cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent),
vol.Optional(CONF_VOLTAGE): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(CSE7766VoltageSensor),
})),
vol.Optional(CONF_CURRENT): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(CSE7766CurrentSensor),
})),
vol.Optional(CONF_POWER): cv.nameable(sensor.SENSOR_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(CSE7766PowerSensor),
})),
vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(CONF_VOLTAGE, CONF_CURRENT,
CONF_POWER))
def to_code(config):
for uart_ in get_variable(config[CONF_UART_ID]):
yield
import pi4home.config_validation as cv
from pi4home.const import CONF_CS_PIN, CONF_ID, CONF_NAME, CONF_SPI_ID, CONF_UPDATE_INTERVAL
from pi4home.cpp_generator import Pvariable, get_variable
from pi4home.cpp_helpers import gpio_output_pin_expression, setup_component
from pi4home.cpp_types import App
MAX31855Sensor = sensor.sensor_ns.class_('MAX31855Sensor',
sensor.PollingSensorComponent,
spi.SPIDevice)
PLATFORM_SCHEMA = cv.nameable(
sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(MAX31855Sensor),
cv.GenerateID(CONF_SPI_ID):
cv.use_variable_id(SPIComponent),
vol.Required(CONF_CS_PIN):
pins.gpio_output_pin_schema,
vol.Optional(CONF_UPDATE_INTERVAL):
cv.update_interval,
}).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]):
yield
rhs = App.make_max31855_sensor(config[CONF_NAME], spi_, cs,
config.get(CONF_UPDATE_INTERVAL))
max31855 = Pvariable(config[CONF_ID], rhs)
value = pins.internal_gpio_input_pin_schema(value)
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)
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):
cv.nameable(
sensor.SENSOR_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(MPU6050AccelSensor),
})),
vol.Optional(CONF_GYRO_X):
setup_component
from pi4home.cpp_types import App
CONF_PULSE_TIME = 'pulse_time'
UltrasonicSensorComponent = sensor.sensor_ns.class_('UltrasonicSensorComponent',
sensor.PollingSensorComponent)
PLATFORM_SCHEMA = cv.nameable(sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(UltrasonicSensorComponent),
vol.Required(CONF_TRIGGER_PIN): pins.gpio_output_pin_schema,
vol.Required(CONF_ECHO_PIN): pins.internal_gpio_input_pin_schema,
vol.Optional(CONF_TIMEOUT): cv.distance,
vol.Optional(CONF_PULSE_TIME): cv.positive_time_period_microseconds,
vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
vol.Optional('timeout_meter'): cv.invalid("The timeout_meter option has been renamed "
"to 'timeout'."),
vol.Optional('timeout_time'): cv.invalid("The timeout_time option has been removed. Please "
"use 'timeout'."),
}))
def to_code(config):
for trigger in gpio_output_pin_expression(config[CONF_TRIGGER_PIN]):
yield
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))
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)
def validate_mux(value):
value = cv.string(value).upper()
value = value.replace(' ', '_')
return cv.one_of(*MUX)(value)
ADS1115Sensor = sensor.sensor_ns.class_('ADS1115Sensor', sensor.EmptySensor)
PLATFORM_SCHEMA = cv.nameable(
sensor.SENSOR_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(ADS1115Sensor),
vol.Required(CONF_MULTIPLEXER):
validate_mux,
vol.Required(CONF_GAIN):
validate_gain,
cv.GenerateID(CONF_ADS1115_ID):
cv.use_variable_id(ADS1115Component),
vol.Optional(CONF_UPDATE_INTERVAL):
cv.update_interval,
}))
def to_code(config):
for hub in get_variable(config[CONF_ADS1115_ID]):
yield
mux = MUX[config[CONF_MULTIPLEXER]]
gain = GAIN[config[CONF_GAIN]]
rhs = hub.get_sensor(config[CONF_NAME], mux, gain,
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,
vol.Optional(CONF_EFFECTS):
light.validate_effects(light.ADDRESSABLE_EFFECTS),
}))
def to_code(config):
segments = []
for conf in config[CONF_SEGMENTS]:
from pi4home.components import switch
import pi4home.config_validation as cv
from pi4home.const import CONF_ASSUMED_STATE, CONF_ID, CONF_LAMBDA, CONF_NAME, CONF_OPTIMISTIC, \
CONF_RESTORE_STATE, CONF_STATE, CONF_TURN_OFF_ACTION, CONF_TURN_ON_ACTION
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, Component, bool_, optional
TemplateSwitch = switch.switch_ns.class_('TemplateSwitch', switch.Switch, Component)
SwitchPublishAction = switch.switch_ns.class_('SwitchPublishAction', Action)
PLATFORM_SCHEMA = cv.nameable(switch.SWITCH_PLATFORM_SCHEMA.extend({
cv.GenerateID(): cv.declare_variable_id(TemplateSwitch),
vol.Optional(CONF_LAMBDA): cv.lambda_,
vol.Optional(CONF_OPTIMISTIC): cv.boolean,
vol.Optional(CONF_ASSUMED_STATE): cv.boolean,
vol.Optional(CONF_TURN_OFF_ACTION): automation.validate_automation(single=True),
vol.Optional(CONF_TURN_ON_ACTION): automation.validate_automation(single=True),
vol.Optional(CONF_RESTORE_STATE): cv.boolean,
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
rhs = App.make_template_switch(config[CONF_NAME])
template = Pvariable(config[CONF_ID], rhs)
switch.setup_switch(template, config)
if CONF_LAMBDA in config:
for template_ in process_lambda(config[CONF_LAMBDA], [],
return_type=optional.template(bool_)):
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],
config.get(CONF_UPDATE_INTERVAL))
tsl2561 = Pvariable(config[CONF_ID], rhs)
if CONF_INTEGRATION_TIME in config:
GPIOSwitchRestoreMode = switch.switch_ns.enum('GPIOSwitchRestoreMode')
RESTORE_MODES = {
'RESTORE_DEFAULT_OFF':
GPIOSwitchRestoreMode.GPIO_SWITCH_RESTORE_DEFAULT_OFF,
'RESTORE_DEFAULT_ON': GPIOSwitchRestoreMode.GPIO_SWITCH_RESTORE_DEFAULT_ON,
'ALWAYS_OFF': GPIOSwitchRestoreMode.GPIO_SWITCH_ALWAYS_OFF,
'ALWAYS_ON': GPIOSwitchRestoreMode.GPIO_SWITCH_ALWAYS_ON,
}
PLATFORM_SCHEMA = cv.nameable(
switch.SWITCH_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(GPIOSwitch),
vol.Required(CONF_PIN):
pins.gpio_output_pin_schema,
vol.Optional(CONF_RESTORE_MODE):
cv.one_of(*RESTORE_MODES, upper=True, space='_'),
vol.Optional(CONF_INTERLOCK):
cv.ensure_list(cv.use_variable_id(switch.Switch)),
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
for pin in gpio_output_pin_expression(config[CONF_PIN]):
yield
rhs = App.make_gpio_switch(config[CONF_NAME], pin)
gpio = Pvariable(config[CONF_ID], rhs)
if CONF_RESTORE_MODE in config:
add(gpio.set_restore_mode(RESTORE_MODES[config[CONF_RESTORE_MODE]]))
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'
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),
}),
vol.Optional(CONF_PANASONIC): cv.Schema({
vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
vol.Required(CONF_COMMAND): cv.hex_uint32_t,
}),
vol.Optional(CONF_RC5): cv.Schema({
vol.Required(CONF_ADDRESS): vol.All(cv.hex_int, vol.Range(min=0, max=0x1F)),
vol.Required(CONF_COMMAND): vol.All(cv.hex_int, vol.Range(min=0, max=0x3F)),
}),
vol.Optional(CONF_RAW): validate_raw,
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, cv.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))
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 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)
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):
cv.update_interval,
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
for uart_ in get_variable(config[CONF_UART_ID]):
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)
setup_component(duty, config)
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)
if CONF_LAMBDA in config:
from pi4home.components import light, output
import pi4home.config_validation as cv
from pi4home.const import CONF_DEFAULT_TRANSITION_LENGTH, CONF_EFFECTS, CONF_GAMMA_CORRECT, \
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.FloatOutput),
vol.Optional(CONF_GAMMA_CORRECT):
cv.positive_float,
vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_EFFECTS):
light.validate_effects(light.MONOCHROMATIC_EFFECTS),
}).extend(cv.COMPONENT_SCHEMA.schema))
def to_code(config):
for output_ in get_variable(config[CONF_OUTPUT]):
yield
rhs = App.make_monochromatic_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)
