def add_buses():
# uart
from esphome.components.uart import UART_DEVICE_SCHEMA
get_jschema("uart_bus", UART_DEVICE_SCHEMA)
# spi
from esphome.components.spi import spi_device_schema
get_jschema("spi_bus", spi_device_schema(False))
# i2c
from esphome.components.i2c import i2c_device_schema
get_jschema("i2c_bus", i2c_device_schema(None))
ST7789VRef = ST7789V.operator('ref')
CONFIG_SCHEMA = display.FULL_DISPLAY_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(ST7789V),
cv.Required(CONF_RESET_PIN):
pins.gpio_output_pin_schema,
cv.Required(CONF_DC_PIN):
pins.gpio_output_pin_schema,
cv.Required(CONF_CS_PIN):
pins.gpio_output_pin_schema,
cv.Required(CONF_BACKLIGHT_PIN):
pins.gpio_output_pin_schema,
cv.Optional(CONF_BRIGHTNESS, default=1.0):
cv.percentage,
}).extend(cv.polling_component_schema('5s')).extend(spi.spi_device_schema())
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield spi.register_spi_device(var, config)
dc = yield cg.gpio_pin_expression(config[CONF_DC_PIN])
cg.add(var.set_dc_pin(dc))
reset = yield cg.gpio_pin_expression(config[CONF_RESET_PIN])
cg.add(var.set_reset_pin(reset))
bl = yield cg.gpio_pin_expression(config[CONF_BACKLIGHT_PIN])
cg.add(var.set_backlight_pin(bl))
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import spi, pn532
from esphome.const import CONF_ID
AUTO_LOAD = ["pn532"]
CODEOWNERS = ["@OttoWinter", "@jesserockz"]
DEPENDENCIES = ["spi"]
MULTI_CONF = True
pn532_spi_ns = cg.esphome_ns.namespace("pn532_spi")
PN532Spi = pn532_spi_ns.class_("PN532Spi", pn532.PN532, spi.SPIDevice)
CONFIG_SCHEMA = cv.All(
pn532.PN532_SCHEMA.extend({
cv.GenerateID(): cv.declare_id(PN532Spi),
}).extend(spi.spi_device_schema(cs_pin_required=True)))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await pn532.setup_pn532(var, config)
await spi.register_spi_device(var, config)
ST7735 = st7735_ns.class_('ST7735', cg.PollingComponent, spi.SPIDevice)
ST7735Ref = ST7735.operator('ref')
CONFIG_SCHEMA = display.FULL_DISPLAY_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(ST7735),
cv.Required(CONF_RESET_PIN):
pins.gpio_output_pin_schema,
cv.Required(CONF_DC_PIN):
pins.gpio_output_pin_schema,
cv.Required(CONF_CS_PIN):
pins.gpio_output_pin_schema,
cv.Optional(CONF_BRIGHTNESS, default=1.0):
cv.percentage,
}).extend(cv.polling_component_schema('1s')).extend(
spi.spi_device_schema(cs_pin_required=True))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield spi.register_spi_device(var, config)
dc = yield cg.gpio_pin_expression(config[CONF_DC_PIN])
cg.add(var.set_dc_pin(dc))
reset = yield cg.gpio_pin_expression(config[CONF_RESET_PIN])
cg.add(var.set_reset_pin(reset))
if CONF_LAMBDA in config:
lambda_ = yield cg.process_lambda(config[CONF_LAMBDA],
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.components import sensor, spi
from esphome.const import (
CONF_ID,
DEVICE_CLASS_TEMPERATURE,
STATE_CLASS_MEASUREMENT,
UNIT_CELSIUS,
)
max6675_ns = cg.esphome_ns.namespace("max6675")
MAX6675Sensor = max6675_ns.class_("MAX6675Sensor", sensor.Sensor,
cg.PollingComponent, spi.SPIDevice)
CONFIG_SCHEMA = (sensor.sensor_schema(
unit_of_measurement=UNIT_CELSIUS,
accuracy_decimals=1,
device_class=DEVICE_CLASS_TEMPERATURE,
state_class=STATE_CLASS_MEASUREMENT,
).extend({
cv.GenerateID(): cv.declare_id(MAX6675Sensor),
}).extend(cv.polling_component_schema("60s")).extend(spi.spi_device_schema()))
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await spi.register_spi_device(var, config)
await sensor.register_sensor(var, config)
"MAX31855Sensor", sensor.Sensor, cg.PollingComponent, spi.SPIDevice
)
CONFIG_SCHEMA = (
sensor.sensor_schema(UNIT_CELSIUS, ICON_EMPTY, 1, DEVICE_CLASS_TEMPERATURE)
.extend(
{
cv.GenerateID(): cv.declare_id(MAX31855Sensor),
cv.Optional(CONF_REFERENCE_TEMPERATURE): sensor.sensor_schema(
UNIT_CELSIUS,
ICON_EMPTY,
2,
DEVICE_CLASS_TEMPERATURE,
STATE_CLASS_MEASUREMENT,
),
}
)
.extend(cv.polling_component_schema("60s"))
.extend(spi.spi_device_schema())
)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)
await spi.register_spi_device(var, config)
await sensor.register_sensor(var, config)
if CONF_REFERENCE_TEMPERATURE in config:
tc_ref = await sensor.new_sensor(config[CONF_REFERENCE_TEMPERATURE])
cg.add(var.set_reference_sensor(tc_ref))
CONFIG_SCHEMA = cv.All(
display.FULL_DISPLAY_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(WaveshareEPaper),
cv.Required(CONF_DC_PIN):
pins.gpio_output_pin_schema,
cv.Required(CONF_MODEL):
cv.one_of(*MODELS, lower=True),
cv.Optional(CONF_RESET_PIN):
pins.gpio_output_pin_schema,
cv.Optional(CONF_BUSY_PIN):
pins.gpio_input_pin_schema,
cv.Optional(CONF_FULL_UPDATE_EVERY):
cv.uint32_t,
}).extend(cv.polling_component_schema("1s")).extend(
spi.spi_device_schema()),
validate_full_update_every_only_type_a,
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
)
async def to_code(config):
model_type, model = MODELS[config[CONF_MODEL]]
if model_type == "a":
rhs = WaveshareEPaperTypeA.new(model)
var = cg.Pvariable(config[CONF_ID], rhs, WaveshareEPaperTypeA)
elif model_type in ("b", "c"):
rhs = model.new()
var = cg.Pvariable(config[CONF_ID], rhs, model)
else:
raise NotImplementedError()
from esphome.const import CONF_DC_PIN, CONF_ID, CONF_LAMBDA, CONF_PAGES
CODEOWNERS = ["@kbx81"]
AUTO_LOAD = ["ssd1327_base"]
DEPENDENCIES = ["spi"]
ssd1327_spi = cg.esphome_ns.namespace("ssd1327_spi")
SPISSD1327 = ssd1327_spi.class_("SPISSD1327", ssd1327_base.SSD1327,
spi.SPIDevice)
CONFIG_SCHEMA = cv.All(
ssd1327_base.SSD1327_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(SPISSD1327),
cv.Required(CONF_DC_PIN):
pins.gpio_output_pin_schema,
}).extend(cv.COMPONENT_SCHEMA).extend(
spi.spi_device_schema(cs_pin_required=False)),
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
)
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield ssd1327_base.setup_ssd1327(var, config)
yield spi.register_spi_device(var, config)
dc = yield cg.gpio_pin_expression(config[CONF_DC_PIN])
cg.add(var.set_dc_pin(dc))
from esphome import pins
from esphome.components import spi, ssd1351_base
from esphome.const import CONF_DC_PIN, CONF_ID, CONF_LAMBDA, CONF_PAGES
CODEOWNERS = ['@kbx81']
AUTO_LOAD = ['ssd1351_base']
DEPENDENCIES = ['spi']
ssd1351_spi = cg.esphome_ns.namespace('ssd1351_spi')
SPISSD1351 = ssd1351_spi.class_('SPISSD1351', ssd1351_base.SSD1351,
spi.SPIDevice)
CONFIG_SCHEMA = cv.All(
ssd1351_base.SSD1351_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(SPISSD1351),
cv.Required(CONF_DC_PIN):
pins.gpio_output_pin_schema,
}).extend(cv.COMPONENT_SCHEMA).extend(spi.spi_device_schema()),
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA))
def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield ssd1351_base.setup_ssd1351(var, config)
yield spi.register_spi_device(var, config)
dc = yield cg.gpio_pin_expression(config[CONF_DC_PIN])
cg.add(var.set_dc_pin(dc))
}
MCP_MODE = {
"NORMAL": McpMode.CANCTRL_REQOP_NORMAL,
"LOOPBACK": McpMode.CANCTRL_REQOP_LOOPBACK,
"LISTENONLY": McpMode.CANCTRL_REQOP_LISTENONLY,
}
CONFIG_SCHEMA = canbus.CANBUS_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(mcp2515),
cv.Optional(CONF_CLOCK, default="8MHZ"):
cv.enum(CAN_CLOCK, upper=True),
cv.Optional(CONF_MODE, default="NORMAL"):
cv.enum(MCP_MODE, upper=True),
}).extend(spi.spi_device_schema(True))
def to_code(config):
rhs = mcp2515.new()
var = cg.Pvariable(config[CONF_ID], rhs)
yield canbus.register_canbus(var, config)
if CONF_CLOCK in config:
canclock = CAN_CLOCK[config[CONF_CLOCK]]
cg.add(var.set_mcp_clock(canclock))
if CONF_MODE in config:
mode = MCP_MODE[config[CONF_MODE]]
cg.add(var.set_mcp_mode(mode))
yield spi.register_spi_device(var, config)
CONFIG_SCHEMA = cv.All(
display.FULL_DISPLAY_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(WaveshareEPaper),
cv.Required(CONF_DC_PIN):
pins.gpio_output_pin_schema,
cv.Required(CONF_MODEL):
cv.one_of(*MODELS, lower=True),
cv.Optional(CONF_RESET_PIN):
pins.gpio_output_pin_schema,
cv.Optional(CONF_BUSY_PIN):
pins.gpio_input_pin_schema,
cv.Optional(CONF_FULL_UPDATE_EVERY):
cv.uint32_t,
}).extend(cv.polling_component_schema('1s')).extend(
spi.spi_device_schema()), validate_full_update_every_only_type_a,
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA))
def to_code(config):
model_type, model = MODELS[config[CONF_MODEL]]
if model_type == 'a':
rhs = WaveshareEPaperTypeA.new(model)
var = cg.Pvariable(config[CONF_ID], rhs, WaveshareEPaperTypeA)
elif model_type == 'b':
rhs = model.new()
var = cg.Pvariable(config[CONF_ID], rhs, model)
else:
raise NotImplementedError()
yield cg.register_component(var, config)
ILI9341_MODEL = cv.enum(MODELS, upper=True, space="_")
CONFIG_SCHEMA = cv.All(
display.FULL_DISPLAY_SCHEMA.extend({
cv.GenerateID():
cv.declare_id(ili9341),
cv.Required(CONF_MODEL):
ILI9341_MODEL,
cv.Required(CONF_DC_PIN):
pins.gpio_output_pin_schema,
cv.Optional(CONF_RESET_PIN):
pins.gpio_output_pin_schema,
cv.Optional(CONF_LED_PIN):
pins.gpio_output_pin_schema,
}).extend(cv.polling_component_schema("1s")).extend(
spi.spi_device_schema(False)),
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
)
async def to_code(config):
if config[CONF_MODEL] == "M5STACK":
lcd_type = ILI9341M5Stack
if config[CONF_MODEL] == "TFT_2.4":
lcd_type = ILI9341TFT24
rhs = lcd_type.new()
var = cg.Pvariable(config[CONF_ID], rhs)
await cg.register_component(var, config)
await display.register_display(var, config)
await spi.register_spi_device(var, config)
COLOR_PALETTE = cv.one_of("NONE", "GRAYSCALE")
CONFIG_SCHEMA = cv.All(
display.FULL_DISPLAY_SCHEMA.extend(
{
cv.GenerateID(): cv.declare_id(ili9341),
cv.Required(CONF_MODEL): ILI9341_MODEL,
cv.Required(CONF_DC_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_RESET_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_LED_PIN): pins.gpio_output_pin_schema,
cv.Optional(CONF_COLOR_PALETTE, default="NONE"): COLOR_PALETTE,
cv.GenerateID(CONF_RAW_DATA_ID): cv.declare_id(cg.uint8),
}
)
.extend(cv.polling_component_schema("1s"))
.extend(spi.spi_device_schema(False)),
cv.has_at_most_one_key(CONF_PAGES, CONF_LAMBDA),
)
async def to_code(config):
if config[CONF_MODEL] == "M5STACK":
lcd_type = ILI9341M5Stack
if config[CONF_MODEL] == "TFT_2.4":
lcd_type = ILI9341TFT24
rhs = lcd_type.new()
var = cg.Pvariable(config[CONF_ID], rhs)
await cg.register_component(var, config)
await display.register_display(var, config)
await spi.register_spi_device(var, config)
