def validate_fan_speed(value):
return vol.All(vol.Upper, cv.one_of(*FAN_SPEEDS))(value)
MY9231OutputComponent = output.output_ns.class_('MY9231OutputComponent',
Component)
MY9231_SCHEMA = vol.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):
vol.All(vol.Coerce(int), cv.one_of(8, 12, 14, 16)),
vol.Optional(CONF_UPDATE_ON_BOOT):
vol.Coerce(bool),
}).extend(cv.COMPONENT_SCHEMA.schema)
CONFIG_SCHEMA = vol.All(cv.ensure_list, [MY9231_SCHEMA])
def to_code(config):
for conf in config:
di = None
for di in gpio_output_pin_expression(conf[CONF_DATA_PIN]):
yield
dcki = None
for dcki in gpio_output_pin_expression(conf[CONF_CLOCK_PIN]):
yield
"'1.54in', '2.13in' and '2.90in'.")
return value
PLATFORM_SCHEMA = vol.All(
display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(WaveshareEPaper),
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):
cv.one_of(*MODELS, lower=True),
vol.Optional(CONF_RESET_PIN):
pins.gpio_output_pin_schema,
vol.Optional(CONF_BUSY_PIN):
pins.gpio_input_pin_schema,
vol.Optional(CONF_FULL_UPDATE_EVERY):
cv.uint32_t,
}).extend(cv.COMPONENT_SCHEMA.schema),
validate_full_update_every_only_type_a)
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
if value.upper() == "ALL":
return list(sorted(list(DUMPERS)))
raise vol.Invalid("Not valid dumpers")
CONFIG_SCHEMA = vol.All(cv.ensure_list, [
vol.Schema({
cv.GenerateID():
cv.declare_variable_id(RemoteReceiverComponent),
vol.Required(CONF_PIN):
pins.gpio_input_pin_schema,
vol.Optional(CONF_DUMP, default=[]):
vol.Any(
validate_dumpers_all,
vol.All(cv.ensure_list,
[vol.All(vol.Lower, cv.one_of(*DUMPERS))])),
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,
})
])
def to_code(config):
for conf in config:
pin = None
'2X': sensor.sensor_ns.BMP280_OVERSAMPLING_2X,
'4X': sensor.sensor_ns.BMP280_OVERSAMPLING_4X,
'8X': sensor.sensor_ns.BMP280_OVERSAMPLING_8X,
'16X': sensor.sensor_ns.BMP280_OVERSAMPLING_16X,
}
IIR_FILTER_OPTIONS = {
'OFF': sensor.sensor_ns.BMP280_IIR_FILTER_OFF,
'2X': sensor.sensor_ns.BMP280_IIR_FILTER_2X,
'4X': sensor.sensor_ns.BMP280_IIR_FILTER_4X,
'8X': sensor.sensor_ns.BMP280_IIR_FILTER_8X,
'16X': sensor.sensor_ns.BMP280_IIR_FILTER_16X,
}
BMP280_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
vol.Optional(CONF_OVERSAMPLING): vol.All(vol.Upper, cv.one_of(*OVERSAMPLING_OPTIONS)),
})
MakeBMP280Sensor = Application.MakeBMP280Sensor
PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID(CONF_MAKE_ID): cv.declare_variable_id(MakeBMP280Sensor),
vol.Optional(CONF_ADDRESS, default=0x77): cv.i2c_address,
vol.Required(CONF_TEMPERATURE): cv.nameable(BMP280_OVERSAMPLING_SENSOR_SCHEMA),
vol.Required(CONF_PRESSURE): cv.nameable(BMP280_OVERSAMPLING_SENSOR_SCHEMA),
vol.Optional(CONF_IIR_FILTER): vol.All(vol.Upper, cv.one_of(*IIR_FILTER_OPTIONS)),
vol.Optional(CONF_UPDATE_INTERVAL): cv.update_interval,
})
def to_code(config):
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)
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 = vol.All(vol.Upper, vol.Replace(' ', '_'), cv.one_of(*MODELS))
PLATFORM_SCHEMA = 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,
vol.Optional(CONF_EXTERNAL_VCC):
return PLATFORMIO_ESP32_LUT[value_]
return value
else:
raise NotImplementedError
def default_build_path():
return core.NAME
CONFIG_SCHEMA = vol.Schema({
vol.Required(CONF_NAME):
cv.valid_name,
vol.Required(CONF_PLATFORM):
vol.All(vol.Upper,
cv.one_of('ESP8266', 'ESPRESSIF8266', 'ESP32', 'ESPRESSIF32')),
vol.Required(CONF_BOARD):
validate_board,
vol.Optional(CONF_ESPHOMELIB_VERSION, default='latest'):
ESPHOMELIB_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_BOARD_FLASH_MODE):
vol.All(vol.Lower, cv.one_of(*BUILD_FLASH_MODES)),
vol.Optional(CONF_ON_BOOT):
vol.All(cv.ensure_list, [
automation.validate_automation({
from esphomeyaml.components import sensor
from esphomeyaml.const import CONF_COUNT_MODE, CONF_FALLING_EDGE, CONF_INTERNAL_FILTER, \
CONF_MAKE_ID, CONF_NAME, CONF_PIN, CONF_PULL_MODE, CONF_RISING_EDGE, CONF_UPDATE_INTERVAL, \
ESP_PLATFORM_ESP32
from esphomeyaml.helpers import App, add, global_ns, variable, Application
ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
GPIO_PULL_MODES = {
'PULLUP': global_ns.GPIO_PULLUP_ONLY,
'PULLDOWN': global_ns.GPIO_PULLDOWN_ONLY,
'PULLUP_PULLDOWN': global_ns.GPIO_PULLUP_PULLDOWN,
'FLOATING': global_ns.GPIO_FLOATING,
}
GPIO_PULL_MODE_SCHEMA = vol.All(vol.Upper, cv.one_of(*GPIO_PULL_MODES))
COUNT_MODES = {
'DISABLE': global_ns.PCNT_COUNT_DIS,
'INCREMENT': global_ns.PCNT_COUNT_INC,
'DECREMENT': global_ns.PCNT_COUNT_DEC,
}
COUNT_MODE_SCHEMA = vol.All(vol.Upper, cv.one_of(*COUNT_MODES))
MakePulseCounterSensor = Application.MakePulseCounterSensor
PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID(CONF_MAKE_ID):
cv.declare_variable_id(MakePulseCounterSensor),
vol.Required(CONF_PIN):
'LOW': sensor.sensor_ns.SHT3XD_ACCURACY_LOW,
'MEDIUM': sensor.sensor_ns.SHT3XD_ACCURACY_MEDIUM,
'HIGH': sensor.sensor_ns.SHT3XD_ACCURACY_HIGH,
}
PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID('sht3xd', CONF_MAKE_ID):
cv.register_variable_id,
vol.Required(CONF_TEMPERATURE):
sensor.SENSOR_SCHEMA,
vol.Required(CONF_HUMIDITY):
sensor.SENSOR_SCHEMA,
vol.Optional(CONF_ADDRESS, default=0x44):
cv.i2c_address,
vol.Optional(CONF_ACCURACY):
vol.All(vol.Upper, cv.one_of(*SHT_ACCURACIES)),
vol.Optional(CONF_UPDATE_INTERVAL):
cv.positive_time_period_milliseconds,
})
MakeSHT3XDSensor = Application.MakeSHT3XDSensor
def to_code(config):
rhs = App.make_sht3xd_sensor(config[CONF_TEMPERATURE][CONF_NAME],
config[CONF_HUMIDITY][CONF_NAME],
config.get(CONF_UPDATE_INTERVAL))
sht3xd = variable(MakeSHT3XDSensor, config[CONF_MAKE_ID], rhs)
if CONF_ACCURACY in config:
add(sht3xd.Psht3xd.set_accuracy(SHT_ACCURACIES[config[CONF_ACCURACY]]))
RCSwitchRawTransmitter = remote_ns.RCSwitchRawTransmitter
RCSwitchTypeATransmitter = remote_ns.RCSwitchTypeATransmitter
RCSwitchTypeBTransmitter = remote_ns.RCSwitchTypeBTransmitter
RCSwitchTypeCTransmitter = remote_ns.RCSwitchTypeCTransmitter
RCSwitchTypeDTransmitter = remote_ns.RCSwitchTypeDTransmitter
validate_raw_data = [vol.Any(vol.Coerce(int), cv.time_period_microseconds)]
PLATFORM_SCHEMA = cv.nameable(
switch.SWITCH_PLATFORM_SCHEMA.extend({
vol.Optional(CONF_LG):
vol.Schema({
vol.Required(CONF_DATA):
cv.hex_uint32_t,
vol.Optional(CONF_NBITS, default=28):
vol.All(vol.Coerce(int), cv.one_of(28, 32)),
}),
vol.Optional(CONF_NEC):
vol.Schema({
vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
vol.Required(CONF_COMMAND): cv.hex_uint16_t,
}),
vol.Optional(CONF_SAMSUNG):
vol.Schema({
vol.Required(CONF_DATA): cv.hex_uint32_t,
}),
vol.Optional(CONF_SONY):
vol.Schema({
vol.Required(CONF_DATA):
cv.hex_uint32_t,
vol.Optional(CONF_NBITS, default=12):
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),
cv.GenerateID(CONF_MAKE_ID):
cv.declare_variable_id(MakeTSL2561Sensor),
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))
make_tsl = variable(config[CONF_MAKE_ID], rhs)
tsl2561 = make_tsl.Ptsl2561
if CONF_INTEGRATION_TIME in config:
add(
vol.Optional(CONF_SSID):
cv.ssid,
vol.Optional(CONF_PASSWORD):
validate_password,
vol.Optional(CONF_MANUAL_IP):
STA_MANUAL_IP_SCHEMA,
vol.Optional(CONF_AP):
WIFI_NETWORK_AP,
vol.Optional(CONF_HOSTNAME):
cv.hostname,
vol.Optional(CONF_DOMAIN, default='.local'):
cv.domain_name,
vol.Optional(CONF_REBOOT_TIMEOUT):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_POWER_SAVE_MODE):
cv.one_of(*WIFI_POWER_SAVE_MODES, upper=True),
vol.Optional(CONF_FAST_CONNECT):
cv.boolean,
}), validate)
def safe_ip(ip):
if ip is None:
return IPAddress(0, 0, 0, 0)
return IPAddress(*ip.args)
def manual_ip(config):
if config is None:
return None
return StructInitializer(
SSD1306 = display.display_ns.class_('SSD1306', PollingComponent, 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 = 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,
vol.Optional(CONF_EXTERNAL_VCC): cv.boolean,
}).extend(cv.COMPONENT_SCHEMA.schema)
def to_code(config):
for spi_ in get_variable(config[CONF_SPI_ID]):
yield
def pin_mode(value):
if CORE.is_esp32:
return cv.one_of(*PIN_MODES_ESP32, upper=True)(value)
if CORE.is_esp8266:
return cv.one_of(*PIN_MODES_ESP8266, upper=True)(value)
raise NotImplementedError
'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 = vol.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,
vol.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_CYCLES):
cv.positive_int,
vol.Optional(CONF_RUN_DURATION):
cv.positive_time_period_milliseconds,
}).extend(cv.COMPONENT_SCHEMA.schema)
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),
cv.GenerateID(CONF_MAKE_ID):
cv.declare_variable_id(MakeHX711Sensor),
vol.Required(CONF_DOUT_PIN):
pins.gpio_input_pin_schema,
vol.Required(CONF_CLK_PIN):
pins.gpio_output_pin_schema,
vol.Optional(CONF_GAIN):
vol.All(cv.int_, cv.one_of(*GAINS)),
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))
make = variable(config[CONF_MAKE_ID], rhs)
hx711 = make.Phx711
RCSwitchRawTransmitter)
RCSwitchTypeDTransmitter = remote_ns.class_('RCSwitchTypeDTransmitter',
RCSwitchRawTransmitter)
validate_raw_data = [vol.Any(vol.Coerce(int), cv.time_period_microseconds)]
PLATFORM_SCHEMA = cv.nameable(
switch.SWITCH_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(RemoteTransmitter),
vol.Optional(CONF_LG):
vol.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):
vol.Schema({
vol.Required(CONF_ADDRESS): cv.hex_uint16_t,
vol.Required(CONF_COMMAND): cv.hex_uint16_t,
}),
vol.Optional(CONF_SAMSUNG):
vol.Schema({
vol.Required(CONF_DATA): cv.hex_uint32_t,
}),
vol.Optional(CONF_SONY):
vol.Schema({
vol.Required(CONF_DATA):
cv.hex_uint32_t,
vol.Optional(CONF_NBITS, default=12):
vol.Optional(CONF_DELAYED_ON):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_DELAYED_OFF):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_HEARTBEAT): cv.positive_time_period_milliseconds,
vol.Optional(CONF_LAMBDA): cv.lambda_,
}, cv.has_exactly_one_key(*FILTER_KEYS))
])
BINARY_SENSOR_SCHEMA = cv.MQTT_COMPONENT_SCHEMA.extend({
cv.GenerateID(CONF_MQTT_ID):
cv.declare_variable_id(MQTTBinarySensorComponent),
cv.GenerateID():
cv.declare_variable_id(BinarySensor),
vol.Optional(CONF_DEVICE_CLASS):
vol.All(vol.Lower, cv.one_of(*DEVICE_CLASSES)),
vol.Optional(CONF_FILTERS):
FILTERS_SCHEMA,
vol.Optional(CONF_ON_PRESS):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_variable_id(PressTrigger),
}),
vol.Optional(CONF_ON_RELEASE):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
cv.declare_variable_id(ReleaseTrigger),
}),
vol.Optional(CONF_ON_CLICK):
automation.validate_automation({
cv.GenerateID(CONF_TRIGGER_ID):
CONF_IS_CS_PACKAGE = 'is_cs_package'
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
PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID('tsl2561_sensor', CONF_MAKE_ID): cv.register_variable_id,
vol.Optional(CONF_ADDRESS, default=0x39): cv.i2c_address,
vol.Optional(CONF_INTEGRATION_TIME): validate_integration_time,
vol.Optional(CONF_GAIN): vol.All(vol.Upper, cv.one_of(*GAINS)),
vol.Optional(CONF_IS_CS_PACKAGE): cv.boolean,
vol.Optional(CONF_UPDATE_INTERVAL): cv.positive_time_period_milliseconds,
}).extend(sensor.SENSOR_SCHEMA.schema)
MakeTSL2561Sensor = Application.MakeTSL2561Sensor
def to_code(config):
rhs = App.make_tsl2561_sensor(config[CONF_NAME], config[CONF_ADDRESS],
config.get(CONF_UPDATE_INTERVAL))
make_tsl = variable(MakeTSL2561Sensor, config[CONF_MAKE_ID], rhs)
tsl2561 = make_tsl.Ptsl2561
if CONF_INTEGRATION_TIME in config:
add(tsl2561.set_integration_time(INTEGRATION_TIMES[config[CONF_INTEGRATION_TIME]]))
if CONF_GAIN in config:
from esphomeyaml import config_validation as cv
from esphomeyaml.const import CONF_ID, CONF_SCAN_INTERVAL, ESP_PLATFORM_ESP32, CONF_UUID, CONF_TYPE
from esphomeyaml.helpers import App, Pvariable, add, esphomelib_ns, RawExpression, ArrayInitializer
ESP_PLATFORMS = [ESP_PLATFORM_ESP32]
ESP32BLETracker = esphomelib_ns.ESP32BLETracker
CONF_MAJOR = 'major'
CONF_MINOR = 'minor'
CONFIG_SCHEMA = vol.Schema({
cv.GenerateID():
cv.declare_variable_id(ESP32BLETracker),
vol.Required(CONF_TYPE):
vol.All(vol.Upper, cv.one_of('IBEACON')),
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,
})
def to_code(config):
uuid = config[CONF_UUID].hex
uuid_arr = [
RawExpression('0x{}'.format(uuid[i:i + 2]))
MakeBH1750Sensor = Application.struct('MakeBH1750Sensor')
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),
cv.GenerateID(CONF_MAKE_ID):
cv.declare_variable_id(MakeBH1750Sensor),
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))
make_bh1750 = variable(config[CONF_MAKE_ID], rhs)
bh1750 = make_bh1750.Pbh1750
if CONF_RESOLUTION in config:
add(bh1750.set_resolution(BH1750_RESOLUTIONS[config[CONF_RESOLUTION]]))
sensor.setup_sensor(bh1750, make_bh1750.Pmqtt, config)
setup_component(bh1750, config)
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 = vol.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_ESPHOMELIB_VERSION, default='latest'): ESPHOMELIB_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): vol.Schema({
cv.string_strict: vol.Any([cv.string], cv.string),
}),
vol.Optional(CONF_BOARD_FLASH_MODE): 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_,
}),
vol.Optional(CONF_ON_SHUTDOWN): automation.validate_automation({
'8X': BME280Oversampling.BME280_OVERSAMPLING_8X,
'16X': BME280Oversampling.BME280_OVERSAMPLING_16X,
}
BME280IIRFilter = sensor.sensor_ns.enum('BME280IIRFilter')
IIR_FILTER_OPTIONS = {
'OFF': BME280IIRFilter.BME280_IIR_FILTER_OFF,
'2X': BME280IIRFilter.BME280_IIR_FILTER_2X,
'4X': BME280IIRFilter.BME280_IIR_FILTER_4X,
'8X': BME280IIRFilter.BME280_IIR_FILTER_8X,
'16X': BME280IIRFilter.BME280_IIR_FILTER_16X,
}
BME280_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
vol.Optional(CONF_OVERSAMPLING):
cv.one_of(*OVERSAMPLING_OPTIONS, upper=True),
})
MakeBME280Sensor = Application.struct('MakeBME280Sensor')
BME280TemperatureSensor = sensor.sensor_ns.class_(
'BME280TemperatureSensor', sensor.EmptyPollingParentSensor)
BME280PressureSensor = sensor.sensor_ns.class_('BME280PressureSensor',
sensor.EmptyPollingParentSensor)
BME280HumiditySensor = sensor.sensor_ns.class_('BME280HumiditySensor',
sensor.EmptyPollingParentSensor)
PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID(CONF_MAKE_ID):
cv.declare_variable_id(MakeBME280Sensor),
vol.Optional(CONF_ADDRESS, default=0x77):
cv.i2c_address,
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),
cv.GenerateID(CONF_MAKE_ID):
cv.declare_variable_id(MakeHX711Sensor),
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))
make = variable(config[CONF_MAKE_ID], rhs)
hx711 = make.Phx711
from esphomeyaml.helpers import App, Application, add, global_ns, variable
ATTENUATION_MODES = {
'0db': global_ns.ADC_0db,
'2.5db': global_ns.ADC_2_5db,
'6db': global_ns.ADC_6db,
'11db': global_ns.ADC_11db,
}
PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID('adc', CONF_MAKE_ID):
cv.register_variable_id,
vol.Required(CONF_PIN):
pins.analog_pin,
vol.Optional(CONF_ATTENUATION):
vol.All(cv.only_on_esp32, cv.one_of(*ATTENUATION_MODES)),
vol.Optional(CONF_UPDATE_INTERVAL):
cv.positive_time_period_milliseconds,
}).extend(sensor.SENSOR_SCHEMA.schema)
MakeADCSensor = Application.MakeADCSensor
def to_code(config):
rhs = App.make_adc_sensor(config[CONF_NAME], config[CONF_PIN],
config.get(CONF_UPDATE_INTERVAL))
make = variable(MakeADCSensor, config[CONF_MAKE_ID], rhs)
adc = make.Padc
if CONF_ATTENUATION in config:
add(adc.set_attenuation(ATTENUATION_MODES[config[CONF_ATTENUATION]]))
sensor.setup_sensor(make.Padc, make.Pmqtt, config)
}
IIR_FILTER_OPTIONS = {
'OFF': sensor.sensor_ns.BME680_IIR_FILTER_OFF,
'1X': sensor.sensor_ns.BME680_IIR_FILTER_1X,
'3X': sensor.sensor_ns.BME680_IIR_FILTER_3X,
'7X': sensor.sensor_ns.BME680_IIR_FILTER_7X,
'15X': sensor.sensor_ns.BME680_IIR_FILTER_15X,
'31X': sensor.sensor_ns.BME680_IIR_FILTER_31X,
'63X': sensor.sensor_ns.BME680_IIR_FILTER_63X,
'127X': sensor.sensor_ns.BME680_IIR_FILTER_127X,
}
BME680_OVERSAMPLING_SENSOR_SCHEMA = sensor.SENSOR_SCHEMA.extend({
vol.Optional(CONF_OVERSAMPLING):
vol.All(vol.Upper, cv.one_of(*OVERSAMPLING_OPTIONS)),
})
PLATFORM_SCHEMA = sensor.PLATFORM_SCHEMA.extend({
cv.GenerateID('bme680', CONF_MAKE_ID):
cv.register_variable_id,
vol.Optional(CONF_ADDRESS, default=0x76):
cv.i2c_address,
vol.Required(CONF_TEMPERATURE):
BME680_OVERSAMPLING_SENSOR_SCHEMA,
vol.Required(CONF_PRESSURE):
BME680_OVERSAMPLING_SENSOR_SCHEMA,
vol.Required(CONF_HUMIDITY):
BME680_OVERSAMPLING_SENSOR_SCHEMA,
vol.Required(CONF_GAS_RESISTANCE):
sensor.SENSOR_SCHEMA,
def shorthand_input_pullup_pin(value):
value = input_pullup_pin(value)
return {CONF_NUMBER: value}
I2CDevice = esphomelib_ns.class_('I2CDevice')
PCF8574Component = io_ns.class_('PCF8574Component', Component, I2CDevice)
PCF8574_OUTPUT_PIN_SCHEMA = vol.Schema({
vol.Required(CONF_PCF8574):
cv.use_variable_id(PCF8574Component),
vol.Required(CONF_NUMBER):
vol.Coerce(int),
vol.Optional(CONF_MODE):
cv.one_of("OUTPUT", upper=True),
vol.Optional(CONF_INVERTED, default=False):
cv.boolean,
})
PCF8574_INPUT_PIN_SCHEMA = PCF8574_OUTPUT_PIN_SCHEMA.extend({
vol.Optional(CONF_MODE):
cv.one_of("INPUT", "INPUT_PULLUP", upper=True),
})
def internal_gpio_output_pin_schema(value):
if isinstance(value, dict):
return GPIO_FULL_OUTPUT_PIN_SCHEMA(value)
return shorthand_output_pin(value)
"'1.54in', '2.13in' and '2.90in'.")
return value
PLATFORM_SCHEMA = vol.All(
display.FULL_DISPLAY_PLATFORM_SCHEMA.extend({
cv.GenerateID():
cv.declare_variable_id(None),
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):
vol.All(vol.Lower, cv.one_of(*MODELS)),
vol.Optional(CONF_RESET_PIN):
pins.gpio_output_pin_schema,
vol.Optional(CONF_BUSY_PIN):
pins.gpio_input_pin_schema,
vol.Optional(CONF_FULL_UPDATE_EVERY):
cv.uint32_t,
}), validate_full_update_every_only_type_a)
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
for dc in gpio_output_pin_expression(config[CONF_DC_PIN]):
def validate(value):
if value[CONF_CHIPSET] == 'NEOPIXEL' and CONF_RGB_ORDER in value:
raise vol.Invalid("NEOPIXEL doesn't support RGB order")
return value
MakeFastLEDLight = Application.MakeFastLEDLight
PLATFORM_SCHEMA = cv.nameable(
light.LIGHT_PLATFORM_SCHEMA.extend({
cv.GenerateID(CONF_MAKE_ID):
cv.declare_variable_id(MakeFastLEDLight),
vol.Required(CONF_CHIPSET):
vol.All(vol.Upper, cv.one_of(*TYPES)),
vol.Required(CONF_PIN):
pins.output_pin,
vol.Required(CONF_NUM_LEDS):
cv.positive_not_null_int,
vol.Optional(CONF_MAX_REFRESH_RATE):
cv.positive_time_period_microseconds,
vol.Optional(CONF_RGB_ORDER):
vol.All(vol.Upper, cv.one_of(*RGB_ORDERS)),
vol.Optional(CONF_GAMMA_CORRECT):
cv.positive_float,
vol.Optional(CONF_DEFAULT_TRANSITION_LENGTH):
cv.positive_time_period_milliseconds,
vol.Optional(CONF_POWER_SUPPLY):
cv.use_variable_id(PowerSupplyComponent),
}), validate)
