def validate_method(value): if value is None: if CORE.is_esp32: return 'ESP32_I2S_1' if CORE.is_esp8266: return 'ESP8266_DMA' raise NotImplementedError if CORE.is_esp32: return cv.one_of(*ESP32_METHODS, upper=True, space='_')(value) if CORE.is_esp8266: return cv.one_of(*ESP8266_METHODS, upper=True, space='_')(value) raise NotImplementedError
def validate_gain(value): if isinstance(value, float): value = u'{:0.03f}'.format(value) elif not isinstance(value, string_types): raise vol.Invalid('invalid gain "{}"'.format(value)) return cv.one_of(*GAIN)(value)
def validate_rotation(value): value = cv.string(value) if value.endswith(u"°"): value = value[:-1] try: value = int(value) except ValueError: raise vol.Invalid(u"Expected integer for rotation") return cv.one_of(*DISPLAY_ROTATIONS)(value)
def validate_variant(value): value = cv.string(value).upper() if value == 'WS2813': value = 'WS2812X' if value == 'WS2812': value = '800KBPS' if value == 'LC8812': value = 'SK6812' return cv.one_of(*VARIANTS)(value)
}), 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)
import pi4home.config_validation as cv from pi4home.const import CONF_COUNT_MODE, CONF_FALLING_EDGE, CONF_ID, CONF_INTERNAL_FILTER, \ CONF_NAME, CONF_PIN, CONF_RISING_EDGE, CONF_UPDATE_INTERVAL, CONF_NUMBER from pi4home.core import CORE from pi4home.cpp_generator import Pvariable, add from pi4home.cpp_helpers import gpio_input_pin_expression, setup_component from pi4home.cpp_types import App PulseCounterCountMode = sensor.sensor_ns.enum('PulseCounterCountMode') COUNT_MODES = { 'DISABLE': PulseCounterCountMode.PULSE_COUNTER_DISABLE, 'INCREMENT': PulseCounterCountMode.PULSE_COUNTER_INCREMENT, 'DECREMENT': PulseCounterCountMode.PULSE_COUNTER_DECREMENT, } COUNT_MODE_SCHEMA = cv.one_of(*COUNT_MODES, upper=True) PulseCounterBase = sensor.sensor_ns.class_('PulseCounterBase') PulseCounterSensorComponent = sensor.sensor_ns.class_( 'PulseCounterSensorComponent', sensor.PollingSensorComponent, PulseCounterBase) def validate_internal_filter(value): if CORE.is_esp32: if isinstance(value, int): raise vol.Invalid( "Please specify the internal filter in microseconds now " "(since 1.7.0). For example '17ms'") value = cv.positive_time_period_microseconds(value) if value.total_microseconds > 13:
'GRB', 'GBR', 'BRG', 'BGR', ] MakeFastLEDLight = Application.struct('MakeFastLEDLight') 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(MakeFastLEDLight), vol.Required(CONF_CHIPSET): cv.one_of(*CHIPSETS, upper=True), vol.Required(CONF_DATA_PIN): pins.output_pin, vol.Required(CONF_CLOCK_PIN): pins.output_pin, vol.Required(CONF_NUM_LEDS): cv.positive_not_null_int, vol.Optional(CONF_RGB_ORDER): cv.one_of(*RGB_ORDERS, upper=True), vol.Optional(CONF_MAX_REFRESH_RATE): cv.positive_time_period_microseconds, vol.Optional(CONF_GAMMA_CORRECT): cv.positive_float, vol.Optional(CONF_COLOR_CORRECT): vol.All([cv.percentage], vol.Length(min=3, max=3)), vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH):
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) def to_code(config): for pin in gpio_input_pin_expression(config[CONF_PIN]): yield rhs = App.make_remote_receiver_component(pin)
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'
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, config.get(CONF_UPDATE_INTERVAL)) hx711 = Pvariable(config[CONF_ID], rhs)
display.DisplayBuffer) SPISSD1306 = display.display_ns.class_('SPISSD1306', SSD1306, spi.SPIDevice) SSD1306Model = display.display_ns.enum('SSD1306Model') MODELS = { 'SSD1306_128X32': SSD1306Model.SSD1306_MODEL_128_32, 'SSD1306_128X64': SSD1306Model.SSD1306_MODEL_128_64, 'SSD1306_96X16': SSD1306Model.SSD1306_MODEL_96_16, 'SSD1306_64X48': SSD1306Model.SSD1306_MODEL_64_48, 'SH1106_128X32': SSD1306Model.SH1106_MODEL_128_32, 'SH1106_128X64': SSD1306Model.SH1106_MODEL_128_64, 'SH1106_96X16': SSD1306Model.SH1106_MODEL_96_16, 'SH1106_64X48': SSD1306Model.SH1106_MODEL_64_48, } SSD1306_MODEL = cv.one_of(*MODELS, upper=True, space="_") PLATFORM_SCHEMA = vol.All( display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(SPISSD1306), cv.GenerateID(CONF_SPI_ID): cv.use_variable_id(SPIComponent), vol.Required(CONF_CS_PIN): pins.gpio_output_pin_schema, vol.Required(CONF_DC_PIN): pins.gpio_output_pin_schema, vol.Required(CONF_MODEL): SSD1306_MODEL, vol.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
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]])) if CONF_INTERLOCK in config:
return value PMSX003_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(PMSX003Sensor), }) PLATFORM_SCHEMA = vol.All( sensor.PLATFORM_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(PMSX003Component), cv.GenerateID(CONF_UART_ID): cv.use_variable_id(UARTComponent), vol.Required(CONF_TYPE): cv.one_of(*PMSX003_TYPES, upper=True), vol.Optional(CONF_PM_1_0): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_PM_2_5): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_PM_10_0): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_TEMPERATURE): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_HUMIDITY): cv.nameable(PMSX003_SENSOR_SCHEMA), vol.Optional(CONF_FORMALDEHYDE): cv.nameable(PMSX003_SENSOR_SCHEMA), }).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSORS_TO_TYPE))
def fan_turn_off_to_code(config, action_id, template_arg, args): for var in get_variable(config[CONF_ID]): yield None rhs = var.make_turn_off_action(template_arg) type = TurnOffAction.template(template_arg) yield Pvariable(action_id, rhs, type=type) CONF_FAN_TURN_ON = 'fan.turn_on' FAN_TURN_ON_ACTION_SCHEMA = maybe_simple_id({ vol.Required(CONF_ID): cv.use_variable_id(FanState), vol.Optional(CONF_OSCILLATING): cv.templatable(cv.boolean), vol.Optional(CONF_SPEED): cv.templatable(cv.one_of(*FAN_SPEEDS, upper=True)), }) @ACTION_REGISTRY.register(CONF_FAN_TURN_ON, FAN_TURN_ON_ACTION_SCHEMA) def fan_turn_on_to_code(config, action_id, template_arg, args): for var in get_variable(config[CONF_ID]): yield None rhs = var.make_turn_on_action(template_arg) type = TurnOnAction.template(template_arg) action = Pvariable(action_id, rhs, type=type) if CONF_OSCILLATING in config: for template_ in templatable(config[CONF_OSCILLATING], args, bool_): yield None add(action.set_oscillating(template_)) if CONF_SPEED in config:
vol.Required(CONF_STATE): cv.boolean, vol.Optional(CONF_PROTOCOL, default=1): RC_SWITCH_PROTOCOL_SCHEMA, }) RC_SWITCH_TYPE_C_SCHEMA = cv.Schema({ vol.Required(CONF_FAMILY): cv.one_of('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', lower=True), vol.Required(CONF_GROUP): vol.All(cv.uint8_t, vol.Range(min=1, max=4)), vol.Required(CONF_DEVICE): vol.All(cv.uint8_t, vol.Range(min=1, max=4)), vol.Required(CONF_STATE): cv.boolean, vol.Optional(CONF_PROTOCOL, default=1):
PLATFORM_SCHEMA = stepper.STEPPER_PLATFORM_SCHEMA.extend({ vol.Required(CONF_ID): cv.declare_variable_id(ULN2003), vol.Required(CONF_PIN_A): pins.gpio_output_pin_schema, vol.Required(CONF_PIN_B): pins.gpio_output_pin_schema, vol.Required(CONF_PIN_C): pins.gpio_output_pin_schema, vol.Required(CONF_PIN_D): pins.gpio_output_pin_schema, vol.Optional(CONF_SLEEP_WHEN_DONE): cv.boolean, vol.Optional(CONF_STEP_MODE): cv.one_of(*STEP_MODES, upper=True, space='_') }).extend(cv.COMPONENT_SCHEMA.schema) def to_code(config): for pin_a in gpio_output_pin_expression(config[CONF_PIN_A]): yield for pin_b in gpio_output_pin_expression(config[CONF_PIN_B]): yield for pin_c in gpio_output_pin_expression(config[CONF_PIN_C]): yield for pin_d in gpio_output_pin_expression(config[CONF_PIN_D]): yield rhs = App.make_uln2003(pin_a, pin_b, pin_c, pin_d) uln = Pvariable(config[CONF_ID], rhs)
from pi4home.const import CONF_ID, CONF_SCAN_INTERVAL, CONF_TYPE, CONF_UUID, ESP_PLATFORM_ESP32 from pi4home.cpp_generator import Pvariable, RawExpression, add from pi4home.cpp_helpers import setup_component from pi4home.cpp_types import App, Component, pi4home_ns ESP_PLATFORMS = [ESP_PLATFORM_ESP32] CONFLICTS_WITH = ['esp32_ble_tracker'] ESP32BLEBeacon = pi4home_ns.class_('ESP32BLEBeacon', Component) CONF_MAJOR = 'major' CONF_MINOR = 'minor' CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_variable_id(ESP32BLEBeacon), vol.Required(CONF_TYPE): cv.one_of('IBEACON', upper=True), vol.Required(CONF_UUID): cv.uuid, vol.Optional(CONF_MAJOR): cv.uint16_t, vol.Optional(CONF_MINOR): cv.uint16_t, vol.Optional(CONF_SCAN_INTERVAL): cv.positive_time_period_milliseconds, }).extend(cv.COMPONENT_SCHEMA.schema) def to_code(config): uuid = config[CONF_UUID].hex uuid_arr = [RawExpression('0x{}'.format(uuid[i:i + 2])) for i in range(0, len(uuid), 2)] rhs = App.make_esp32_ble_beacon(uuid_arr) ble = Pvariable(config[CONF_ID], rhs) if CONF_MAJOR in config: add(ble.set_major(config[CONF_MAJOR])) if CONF_MINOR in config:
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), }), vol.Optional(CONF_PANASONIC): cv.Schema({ vol.Required(CONF_ADDRESS): cv.hex_uint16_t, vol.Required(CONF_COMMAND): cv.hex_uint32_t,
def validate_mux(value): value = cv.string(value).upper() value = value.replace(' ', '_') return cv.one_of(*MUX)(value)
'int': int32, 'float': float_, 'string': std_string, } CONFIG_SCHEMA = cv.Schema({ cv.GenerateID(): cv.declare_variable_id(APIServer), vol.Optional(CONF_PORT, default=6053): cv.port, vol.Optional(CONF_PASSWORD, default=''): cv.string_strict, vol.Optional(CONF_REBOOT_TIMEOUT): cv.positive_time_period_milliseconds, vol.Optional(CONF_SERVICES): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(UserService), vol.Required(CONF_SERVICE): cv.valid_name, vol.Optional(CONF_VARIABLES, default={}): cv.Schema({ cv.validate_id_name: cv.one_of(*SERVICE_ARG_TYPES, lower=True), }), }), }).extend(cv.COMPONENT_SCHEMA.schema) def to_code(config): rhs = App.init_api_server() api = Pvariable(config[CONF_ID], rhs) if config[CONF_PORT] != 6053: add(api.set_port(config[CONF_PORT])) if config.get(CONF_PASSWORD): add(api.set_password(config[CONF_PASSWORD])) if CONF_REBOOT_TIMEOUT in config: add(api.set_reboot_timeout(config[CONF_REBOOT_TIMEOUT]))
'ANY_HIGH': esp_sleep_ext1_wakeup_mode_t.ESP_EXT1_WAKEUP_ANY_HIGH, } 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.")
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: add(my9231.set_num_channels(config[CONF_NUM_CHANNELS])) if CONF_NUM_CHIPS in config: add(my9231.set_num_chips(config[CONF_NUM_CHIPS]))
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)
raise vol.Invalid("Unfortunately the arduino framework version '{}' is unsupported " "at this time. You can override this by manually using " "espressif32@<platformio version>") if value_ in PLATFORMIO_ESP32_LUT: return PLATFORMIO_ESP32_LUT[value_] return value raise NotImplementedError def default_build_path(): return CORE.name CONFIG_SCHEMA = cv.Schema({ vol.Required(CONF_NAME): cv.valid_name, vol.Required(CONF_PLATFORM): cv.one_of('ESP8266', 'ESPRESSIF8266', 'ESP32', 'ESPRESSIF32', upper=True), vol.Required(CONF_BOARD): validate_board, vol.Optional(CONF_PI4HOME_CORE_VERSION, default='latest'): PI4HOME_CORE_VERSION_SCHEMA, vol.Optional(CONF_ARDUINO_VERSION, default='recommended'): validate_arduino_version, vol.Optional(CONF_USE_CUSTOM_CODE, default=False): cv.boolean, vol.Optional(CONF_BUILD_PATH, default=default_build_path): cv.string, vol.Optional(CONF_PLATFORMIO_OPTIONS): cv.Schema({ cv.string_strict: vol.Any([cv.string], cv.string), }), vol.Optional(CONF_ESP8266_RESTORE_FROM_FLASH): vol.All(cv.only_on_esp8266, cv.boolean), vol.Optional(CONF_BOARD_FLASH_MODE, default='dout'): cv.one_of(*BUILD_FLASH_MODES, lower=True), vol.Optional(CONF_ON_BOOT): automation.validate_automation({ cv.GenerateID(CONF_TRIGGER_ID): cv.declare_variable_id(StartupTrigger), vol.Optional(CONF_PRIORITY): cv.float_, }),
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: add( tsl2561.set_integration_time(
from pi4home.cpp_generator import get_variable DEPENDENCIES = ['apds9960'] APDS9960GestureDirectionBinarySensor = sensor.sensor_ns.class_( 'APDS9960GestureDirectionBinarySensor', binary_sensor.BinarySensor) DIRECTIONS = { 'UP': 'make_up_direction', 'DOWN': 'make_down_direction', 'LEFT': 'make_left_direction', 'RIGHT': 'make_right_direction', } PLATFORM_SCHEMA = cv.nameable( binary_sensor.BINARY_SENSOR_PLATFORM_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(APDS9960GestureDirectionBinarySensor), vol.Required(CONF_DIRECTION): cv.one_of(*DIRECTIONS, upper=True), cv.GenerateID(CONF_APDS9960_ID): cv.use_variable_id(APDS9960) })) def to_code(config): for hub in get_variable(config[CONF_APDS9960_ID]): yield func = getattr(hub, DIRECTIONS[config[CONF_DIRECTION]]) rhs = func(config[CONF_NAME]) binary_sensor.register_binary_sensor(rhs, config)
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'): cv.domain_name, vol.Optional(CONF_USE_ADDRESS):
from pi4home.const import CONF_NAME, CONF_TYPE from pi4home.cpp_generator import get_variable DEPENDENCIES = ['apds9960'] TYPES = { 'CLEAR': 'make_clear_channel', 'RED': 'make_red_channel', 'GREEN': 'make_green_channel', 'BLUE': 'make_blue_channel', 'PROXIMITY': 'make_proximity', } PLATFORM_SCHEMA = cv.nameable( sensor.SENSOR_PLATFORM_SCHEMA.extend({ cv.GenerateID(): cv.declare_variable_id(sensor.Sensor), vol.Required(CONF_TYPE): cv.one_of(*TYPES, upper=True), cv.GenerateID(CONF_APDS9960_ID): cv.use_variable_id(APDS9960) })) def to_code(config): for hub in get_variable(config[CONF_APDS9960_ID]): yield func = getattr(hub, TYPES[config[CONF_TYPE]]) rhs = func(config[CONF_NAME]) sensor.register_sensor(rhs, config)
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({ cv.GenerateID(): cv.declare_variable_id(TCS35725ColorTemperatureSensor), })), vol.Optional(CONF_INTEGRATION_TIME): cv.one_of(*TCS34725_INTEGRATION_TIMES, lower=True), vol.Optional(CONF_GAIN): vol.All(vol.Upper, cv.one_of(*TCS34725_GAINS), upper=True), vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval, }).extend(cv.COMPONENT_SCHEMA.schema), cv.has_at_least_one_key(*SENSOR_KEYS)) def to_code(config): rhs = App.make_tcs34725(config.get(CONF_UPDATE_INTERVAL)) tcs = Pvariable(config[CONF_ID], rhs) if CONF_ADDRESS in config: add(tcs.set_address(config[CONF_ADDRESS])) if CONF_INTEGRATION_TIME in config: add(
'8X': BMP280Oversampling.BMP280_OVERSAMPLING_8X, '16X': BMP280Oversampling.BMP280_OVERSAMPLING_16X, } BMP280IIRFilter = sensor.sensor_ns.enum('BMP280IIRFilter') IIR_FILTER_OPTIONS = { 'OFF': BMP280IIRFilter.BMP280_IIR_FILTER_OFF, '2X': BMP280IIRFilter.BMP280_IIR_FILTER_2X, '4X': BMP280IIRFilter.BMP280_IIR_FILTER_4X, '8X': BMP280IIRFilter.BMP280_IIR_FILTER_8X, '16X': BMP280IIRFilter.BMP280_IIR_FILTER_16X, } BMP280_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({ vol.Optional(CONF_OVERSAMPLING): cv.one_of(*OVERSAMPLING_OPTIONS, upper=True), }) 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):