esphome Namespace Reference

Namespaces
namespace	a01nyub
namespace	a02yyuw
namespace	a4988
namespace	absolute_humidity
namespace	ac_dimmer
namespace	adalight
namespace	adc
namespace	adc128s102
namespace	addressable_light
namespace	ade7880
namespace	ade7953_base
namespace	ade7953_i2c
namespace	ade7953_spi
namespace	ads1115
namespace	ads1118
namespace	ags10
namespace	aht10
namespace	aic3204
namespace	airthings_ble
namespace	airthings_wave_base
namespace	airthings_wave_mini
namespace	airthings_wave_plus
namespace	alarm_control_panel
namespace	alpha3
namespace	am2315c
namespace	am2320
namespace	am43
namespace	analog_threshold
namespace	animation
namespace	anova
namespace	apds9306
namespace	apds9960
namespace	api
namespace	aqi
namespace	as3935
namespace	as3935_i2c
namespace	as3935_spi
namespace	as5600
namespace	as7341
namespace	async_tcp
namespace	at581x
namespace	atc_mithermometer
namespace	atm90e26
namespace	atm90e32
namespace	audio
namespace	audio_adc
namespace	audio_dac
namespace	audio_file
namespace	audio_http
namespace	axs15231
namespace	b_parasite
namespace	ballu
namespace	bang_bang
namespace	bedjet
namespace	beken_spi_led_strip
namespace	bh1750
namespace	bh1900nux
namespace	binary
namespace	binary_sensor
namespace	binary_sensor_map
namespace	bl0906
namespace	bl0939
namespace	bl0940
namespace	bl0942
namespace	ble_client
namespace	ble_nus
namespace	ble_presence
namespace	ble_rssi
namespace	ble_scanner
namespace	bluetooth_proxy
namespace	bm8563
namespace	bme280_base
namespace	bme280_i2c
namespace	bme280_spi
namespace	bme680
namespace	bme680_bsec
namespace	bme68x_bsec2
namespace	bme68x_bsec2_i2c
namespace	bmi160
namespace	bmp085
namespace	bmp280_base
namespace	bmp280_i2c
namespace	bmp280_spi
namespace	bmp3xx_base
namespace	bmp3xx_i2c
namespace	bmp3xx_spi
namespace	bmp581_base
namespace	bmp581_i2c
namespace	bmp581_spi
namespace	bp1658cj
namespace	bp5758d
namespace	bthome_mithermometer
namespace	button
namespace	bytebuffer
namespace	camera
namespace	camera_encoder
namespace	canbus
namespace	cap1188
namespace	captive_portal
namespace	cc1101
namespace	ccs811
namespace	cd74hc4067
namespace	ch422g
namespace	ch423
namespace	chsc6x
namespace	climate
namespace	climate_ir
namespace	climate_ir_lg
namespace	cm1106
namespace	color_temperature
namespace	combination
namespace	coolix
namespace	copy
namespace	cover
namespace	cs5460a
namespace	cse7761
namespace	cse7766
namespace	cst226
namespace	cst816
namespace	ct_clamp
namespace	current_based
namespace	cwww
namespace	dac7678
namespace	daikin
namespace	daikin_arc
namespace	daikin_brc
namespace	dallas_temp
namespace	daly_bms
namespace	dashboard_import
namespace	datetime
namespace	debug
namespace	deep_sleep
namespace	delonghi
namespace	demo
namespace	dew_point
namespace	dfplayer
namespace	dfrobot_sen0395
namespace	dht
namespace	dht12
namespace	display
namespace	display_menu_base
namespace	dlms_meter
namespace	dps310
namespace	ds1307
namespace	ds2484
namespace	dsmr
namespace	duty_cycle
namespace	duty_time_sensor
namespace	e131
namespace	ee895
namespace	ektf2232
namespace	emc2101
namespace	emmeti
namespace	emontx
namespace	endstop
namespace	ens160_base
namespace	ens160_i2c
namespace	ens160_spi
namespace	ens210
namespace	epaper_spi
namespace	es7210
namespace	es7243e
namespace	es8156
namespace	es8311
namespace	es8388
namespace	esp32
namespace	esp32_ble
namespace	esp32_ble_beacon
namespace	esp32_ble_client
namespace	esp32_ble_server
namespace	esp32_ble_tracker
namespace	esp32_camera
namespace	esp32_camera_web_server
namespace	esp32_can
namespace	esp32_dac
namespace	esp32_hosted
namespace	esp32_improv
namespace	esp32_rmt_led_strip
namespace	esp32_touch
namespace	esp8266
namespace	esp8266_pwm
namespace	esp_ldo
namespace	espnow
namespace	ethernet
namespace	ethernet_info
namespace	event
namespace	exposure_notifications
namespace	ezo
namespace	ezo_pmp
namespace	factory_reset
namespace	fan
namespace	fastled_base
namespace	feedback
namespace	fingerprint_grow
namespace	font
namespace	fs3000
namespace	ft5x06
namespace	ft63x6
namespace	fujitsu_general
namespace	gcja5
namespace	gdk101
namespace	gl_r01_i2c
namespace	globals
namespace	gp2y1010au0f
namespace	gp8403
namespace	gpio
namespace	gpio_expander
namespace	gps
namespace	graph
namespace	graphical_display_menu
namespace	gree
namespace	grove_gas_mc_v2
namespace	grove_tb6612fng
namespace	growatt_solar
namespace	gt911
namespace	haier
namespace	havells_solar
namespace	hbridge
namespace	hc8
namespace	hdc1080
namespace	hdc2010
namespace	hdc2080
namespace	hdc302x
namespace	he60r
namespace	heatpumpir
namespace	hitachi_ac344
namespace	hitachi_ac424
namespace	hlk_fm22x
namespace	hlw8012
namespace	hlw8032
namespace	hm3301
namespace	hmac_md5
namespace	hmac_sha256
namespace	hmc5883l
namespace	homeassistant
namespace	honeywell_hih_i2c
namespace	honeywellabp
namespace	honeywellabp2_i2c
namespace	host
namespace	hrxl_maxsonar_wr
namespace	hte501
namespace	http_request
namespace	htu21d
namespace	htu31d
namespace	hub75
namespace	hx711
namespace	hydreon_rgxx
namespace	hyt271
namespace	i2c
namespace	i2c_device
namespace	i2s_audio
namespace	iaqcore
namespace	ili9xxx
namespace	image
namespace	improv_base
namespace	improv_serial
namespace	ina219
namespace	ina226
namespace	ina260
namespace	ina2xx_base
namespace	ina2xx_i2c
namespace	ina2xx_spi
namespace	ina3221
namespace	infrared
namespace	inkbird_ibsth1_mini
namespace	inkplate
namespace	integration
namespace	internal
	RP2040 wakeable delay uses file-scope state (alarm callback + flag) — defined in wake_rp2040.cpp.
namespace	internal_temperature
namespace	interval
namespace	ir_rf_proxy
namespace	jsn_sr04t
namespace	json
namespace	kamstrup_kmp
namespace	key_collector
namespace	key_provider
namespace	kmeteriso
namespace	kuntze
namespace	lc709203f
namespace	lcd_base
namespace	lcd_gpio
namespace	lcd_menu
namespace	lcd_pcf8574
namespace	ld2410
namespace	ld2412
namespace	ld2420
namespace	ld2450
namespace	ld24xx
namespace	ledc
namespace	libretiny
namespace	libretiny_pwm
namespace	light
namespace	lightwaverf
namespace	lilygo_t5_47
namespace	lm75b
namespace	lock
namespace	logger
namespace	lps22
namespace	ltr390
namespace	ltr501
namespace	ltr_als_ps
namespace	lvgl
namespace	m5stack_8angle
namespace	mapping
namespace	matrix_keypad
namespace	max17043
namespace	max31855
namespace	max31856
namespace	max31865
namespace	max44009
namespace	max6675
namespace	max6956
namespace	max7219
namespace	max7219digit
namespace	max9611
namespace	mcp23008
namespace	mcp23016
namespace	mcp23017
namespace	mcp23s08
namespace	mcp23s17
namespace	mcp23x08_base
namespace	mcp23x17_base
namespace	mcp23xxx_base
namespace	mcp2515
namespace	mcp3008
namespace	mcp3204
namespace	mcp3221
namespace	mcp4461
namespace	mcp4725
namespace	mcp4728
namespace	mcp47a1
namespace	mcp9600
namespace	mcp9808
namespace	md5
namespace	mdns
namespace	media_player
namespace	media_source
namespace	mhz19
namespace	micro_wake_word
namespace	micronova
namespace	microphone
namespace	mics_4514
namespace	midea
namespace	midea_ir
namespace	mipi_dsi
namespace	mipi_rgb
namespace	mipi_spi
namespace	mitsubishi
namespace	mitsubishi_cn105
namespace	mixer_speaker
namespace	mlx90393
namespace	mlx90614
namespace	mmc5603
namespace	mmc5983
namespace	modbus
namespace	modbus_controller
namespace	modbus_server
namespace	monochromatic
namespace	mopeka_ble
namespace	mopeka_pro_check
namespace	mopeka_std_check
namespace	mpl3115a2
namespace	mpr121
namespace	mpu6050
namespace	mpu6886
namespace	mqtt
namespace	mqtt_subscribe
namespace	ms5611
namespace	ms8607
namespace	msa3xx
namespace	my9231
namespace	nau7802
namespace	neopixelbus
namespace	network
namespace	nextion
namespace	nfc
namespace	noblex
namespace	npi19
namespace	nrf52
namespace	ntc
namespace	number
namespace	one_wire
namespace	online_image
namespace	opentherm
namespace	openthread
namespace	openthread_info
namespace	opt3001
namespace	ota
namespace	output
namespace	packet_transport
	Providing packet encoding functions for exchanging data with a remote host.
namespace	partition
namespace	pca6416a
namespace	pca9554
namespace	pca9685
namespace	pcd8544
namespace	pcf85063
namespace	pcf8563
namespace	pcf8574
namespace	pi4ioe5v6408
namespace	pid
namespace	pipsolar
namespace	pm1006
namespace	pm2005
namespace	pmsa003i
namespace	pmsx003
namespace	pmwcs3
namespace	pn532
namespace	pn532_i2c
namespace	pn532_spi
namespace	pn7150
namespace	pn7150_i2c
namespace	pn7160
namespace	pn7160_i2c
namespace	pn7160_spi
namespace	power_supply
namespace	preferences
namespace	prometheus
namespace	psram
namespace	pulse_counter
namespace	pulse_meter
namespace	pulse_width
namespace	pvvx_mithermometer
namespace	pylontech
namespace	pzem004t
namespace	pzemac
namespace	pzemdc
namespace	qmc5883l
namespace	qmp6988
namespace	qr_code
namespace	qspi_dbi
namespace	qwiic_pir
namespace	radio_frequency
namespace	radon_eye_ble
namespace	radon_eye_rd200
namespace	rc522
namespace	rc522_i2c
namespace	rc522_spi
	Library based on https://github.com/miguelbalboa/rfid and adapted to ESPHome by @glmnet.
namespace	rd03d
namespace	rdm6300
namespace	remote_base
namespace	remote_receiver
namespace	remote_transmitter
namespace	resampler
namespace	resistance
namespace	restart
namespace	rf_bridge
namespace	rgb
namespace	rgbct
namespace	rgbw
namespace	rgbww
namespace	ring_buffer
namespace	rotary_encoder
namespace	rp2040
namespace	rp2040_ble
namespace	rp2040_pio_led_strip
namespace	rp2040_pwm
namespace	rpi_dpi_rgb
namespace	rtttl
namespace	runtime_image
namespace	runtime_stats
namespace	ruuvi_ble
namespace	ruuvitag
namespace	rx8130
namespace	safe_mode
namespace	scd30
namespace	scd4x
namespace	script
namespace	sdl
namespace	sdm_meter
namespace	sdp3x
namespace	sds011
namespace	seeed_mr24hpc1
namespace	seeed_mr60bha2
namespace	seeed_mr60fda2
namespace	selec_meter
namespace	select
namespace	sen0321_sensor
namespace	sen21231_sensor
namespace	sen5x
namespace	sen6x
namespace	sendspin_
namespace	senseair
namespace	sensirion_common
namespace	sensor
namespace	serial_proxy
namespace	servo
namespace	setup_priority
	Default setup priorities for components of different types.
namespace	sfa30
namespace	sgp30
namespace	sgp4x
namespace	sha256
namespace	shelly_dimmer
namespace	sht3xd
namespace	sht4x
namespace	shtcx
namespace	shutdown
namespace	sigma_delta_output
namespace	sim800l
namespace	slow_pwm
namespace	sm10bit_base
namespace	sm16716
namespace	sm2135
namespace	sm2235
namespace	sm2335
namespace	sm300d2
namespace	sml
namespace	smt100
namespace	sn74hc165
namespace	sn74hc595
namespace	sntp
namespace	socket
namespace	sonoff_d1
namespace	sound_level
namespace	spa06_base
namespace	spa06_i2c
namespace	spa06_spi
namespace	speaker
namespace	speaker_source
namespace	speed
namespace	spi
	Implementation of SPI Controller mode.
namespace	spi_device
namespace	spi_led_strip
namespace	split_buffer
namespace	sprinkler
namespace	sps30
namespace	ssd1306_base
namespace	ssd1306_i2c
namespace	ssd1306_spi
namespace	ssd1322_base
namespace	ssd1322_spi
namespace	ssd1325_base
namespace	ssd1325_spi
namespace	ssd1327_base
namespace	ssd1327_i2c
namespace	ssd1327_spi
namespace	ssd1331_base
namespace	ssd1331_spi
namespace	ssd1351_base
namespace	ssd1351_spi
namespace	st7567_base
namespace	st7567_i2c
namespace	st7567_spi
namespace	st7701s
namespace	st7735
namespace	st7789v
namespace	st7920
namespace	statsd
namespace	status
namespace	status_led
namespace	stepper
namespace	sts3x
namespace	stts22h
namespace	sun
namespace	sun_gtil2
namespace	switch_
namespace	sx126x
namespace	sx127x
namespace	sx1509
	Here you'll find the Arduino code used to interface with the SX1509 I2C 16 I/O expander.
namespace	sy6970
namespace	syslog
namespace	t6615
namespace	tc74
namespace	tca9548a
namespace	tca9555
namespace	tcl112
namespace	tcs34725
namespace	tee501
namespace	teleinfo
namespace	tem3200
namespace	template_
namespace	text
namespace	text_sensor
namespace	thermopro_ble
namespace	thermostat
namespace	time
namespace	time_based
namespace	tinyusb
namespace	tlc59208f
namespace	tlc5947
namespace	tlc5971
namespace	tm1621
namespace	tm1637
namespace	tm1638
namespace	tm1651
namespace	tmp102
namespace	tmp1075
namespace	tmp117
namespace	tof10120
namespace	tormatic
	This file implements the UART protocol spoken over the on-board Micro-USB (Type B) connector of Tormatic and Novoferm gates manufactured as of 2016.
namespace	toshiba
namespace	total_daily_energy
namespace	touchscreen
namespace	tsl2561
namespace	tsl2591
namespace	tt21100
namespace	ttp229_bsf
namespace	ttp229_lsf
namespace	tuya
namespace	tx20
namespace	uart
namespace	udp
namespace	ufire_ec
namespace	ufire_ise
namespace	uln2003
namespace	ultrasonic
namespace	update
namespace	uponor_smatrix
namespace	uptime
namespace	usb_cdc_acm
namespace	usb_host
namespace	usb_uart
namespace	valve
namespace	vbus
namespace	veml3235
namespace	veml7700
namespace	version
namespace	vl53l0x
namespace	voice_assistant
namespace	voltage_sampler
namespace	wake_on_lan
namespace	watchdog
namespace	water_heater
namespace	waveshare_epaper
namespace	web_server
namespace	web_server_base
namespace	web_server_idf
namespace	weikai
	When the TEST_COMPONENT flag is defined we include some auto-test methods.
namespace	weikai_i2c
namespace	weikai_spi
namespace	whirlpool
namespace	whynter
namespace	wiegand
namespace	wifi
namespace	wifi_info
namespace	wifi_signal
namespace	wireguard
namespace	wk2132_i2c
namespace	wl_134
namespace	wled
namespace	wts01
namespace	x9c
namespace	xgzp68xx
namespace	xiaomi_ble
namespace	xiaomi_cgd1
namespace	xiaomi_cgdk2
namespace	xiaomi_cgg1
namespace	xiaomi_cgpr1
namespace	xiaomi_gcls002
namespace	xiaomi_hhccjcy01
namespace	xiaomi_hhccjcy10
namespace	xiaomi_hhccpot002
namespace	xiaomi_jqjcy01ym
namespace	xiaomi_lywsd02
namespace	xiaomi_lywsd02mmc
namespace	xiaomi_lywsd03mmc
namespace	xiaomi_lywsdcgq
namespace	xiaomi_mhoc303
namespace	xiaomi_mhoc401
namespace	xiaomi_miscale
namespace	xiaomi_mjyd02yla
namespace	xiaomi_mue4094rt
namespace	xiaomi_rtcgq02lm
namespace	xiaomi_wx08zm
namespace	xiaomi_xmwsdj04mmc
namespace	xl9535
namespace	xpt2046
namespace	xxtea
namespace	yashima
namespace	zephyr
namespace	zephyr_ble_server
namespace	zephyr_coredump
namespace	zephyr_mcumgr
namespace	zhlt01
namespace	zigbee
namespace	zio_ultrasonic
namespace	zwave_proxy
namespace	zyaura

Data Structures
class	Action
class	ActionList
class	AndCondition
class	Application
class	Area
class	Automation
struct	Callback
	Lightweight type-erased callback (8 bytes on 32-bit) that avoids std::function overhead. More...
struct	Callback< void(Ts...)>
class	CallbackManager
class	CallbackManager< void(Ts...)>
	Helper class to allow having multiple subscribers to a callback. More...
struct	Color
class	Component
class	ComponentIterator
struct	ComponentRuntimeStats
	Inline runtime statistics — eliminates std::map lookup on every loop iteration. More...
class	Condition
	Base class for all automation conditions. More...
class	ConstVector
	Lightweight read-only view over a const array stored in RODATA (will typically be in flash memory) Avoids copying data from flash to RAM by keeping a pointer to the flash data. More...
class	ContinuationAction
	Simple continuation action that calls play_next_ on a parent action. More...
class	Controller
class	ControllerRegistry
	Global registry for Controllers to receive entity state updates. More...
class	Deduplicator
	Helper class to deduplicate items in a series of values. More...
struct	DefaultBitPolicy
	Default bit mapping policy for contiguous enums starting at 0 Provides 1:1 mapping where enum value equals bit position. More...
class	DelayAction
class	Device
class	EntityBase
class	ESPHomeOTAComponent
	ESPHomeOTAComponent provides a simple way to integrate Over-the-Air updates into your app using ArduinoOTA. More...
class	ESPPreferenceObject
struct	ESPTime
	A more user-friendly version of struct tm from time.h. More...
class	EventPool
class	FiniteSetMask
	Generic bitmask for storing a finite set of discrete values efficiently. More...
class	FixedRingBuffer
	Fixed-capacity circular buffer - allocates once at runtime, never reallocates. More...
struct	FixedString
	Helper for C++20 string literal template arguments. More...
class	FixedVector
	Fixed-capacity vector - allocates once at runtime, never reallocates This avoids std::vector template overhead (_M_realloc_insert, _M_default_append) when size is known at initialization but not at compile time. More...
class	ForCondition
class	FreeRTOSQueue
struct	gens< 0, S... >
class	GPIOPin
class	HashBase
	Base class for hash algorithms. More...
struct	HasLoopOverride
	SFINAE helper: detects whether T overrides Component::loop(). More...
struct	HasLoopOverride< T, std::void_t< decltype(&T::loop)> >
class	HighFrequencyLoopRequester
	Helper class to request loop() to be called as fast as possible. More...
class	IfAction
struct	int24_t
	24-bit signed integer type, transparently converting to 32-bit. More...
class	InternalGPIOPin
class	InterruptLock
	Helper class to disable interrupts. More...
class	ISRInternalGPIOPin
	Copy of GPIOPin that is safe to use from ISRs (with no virtual functions) More...
class	LambdaAction
class	LambdaCondition
class	LazyCallbackManager
class	LazyCallbackManager< void(Ts...)>
	Lazy-allocating callback manager that only allocates memory when callbacks are registered. More...
class	LockFreeQueue
class	LockGuard
	Helper class that wraps a mutex with a RAII-style API. More...
class	LoopTrigger
class	LwIPLock
	Helper class to lock the lwIP TCPIP core when making lwIP API calls from non-TCPIP threads. More...
class	Millis64Impl
	Extends 32-bit millis() to 64-bit using rollover tracking. More...
class	MillisInternal
class	Mutex
	Mutex implementation, with API based on the unavailable std::mutex. More...
class	NotCondition
class	NotifyingLockFreeQueue
struct	OptionalContinuation
struct	OptionalContinuation< false, Ts... >
class	OrCondition
class	Parented
	Helper class to easily give an object a parent of type T. More...
class	PollingComponent
	This class simplifies creating components that periodically check a state. More...
struct	PreferenceBackend
struct	Preferences
class	PreferencesMixin
	CRTP mixin providing type-safe template make_preference<T>() helpers. More...
struct	ProgmemStringTable
	Compile-time string table that packs strings into a single blob with offset lookup. More...
class	ProjectUpdateTrigger
class	RAMAllocator
	An STL allocator that uses SPI or internal RAM. More...
class	RepeatAction
class	RepeatLoopContinuation
	Loop continuation for RepeatAction that increments iteration and repeats or continues. More...
class	ResumeComponentAction
class	ShutdownTrigger
class	SmallBufferWithHeapFallback
	Helper class for efficient buffer allocation - uses stack for small sizes, heap for large This is useful when most operations need a small buffer but occasionally need larger ones. More...
class	SmallInlineBuffer
	Small buffer optimization - stores data inline when small, heap-allocates for large data This avoids heap fragmentation for common small allocations while supporting arbitrary sizes. More...
class	StartupTrigger
class	StatefulEntityBase
	Base class for entities that track a typed state value with change-detection and callbacks. More...
class	StatelessLambdaAction
	Optimized lambda action for stateless lambdas (no capture). More...
class	StatelessLambdaCondition
	Optimized lambda condition for stateless lambdas (no capture). More...
class	StaticCallbackManager
	CallbackManager backed by StaticVector for compile-time-known callback counts. More...
class	StaticCallbackManager< N, void(Ts...)>
class	StaticRingBuffer
	Fixed-size circular buffer with FIFO semantics and iteration support. More...
class	StaticTask
	Helper for FreeRTOS static task management. More...
class	StaticVector
	Minimal static vector - saves memory by avoiding std::vector overhead. More...
class	StringRef
	StringRef is a reference to a string owned by something else. More...
class	SuspendComponentAction
class	TemplatableFn
	Function-pointer-only templatable storage (4 bytes on 32-bit). More...
class	TemplatableValue
	Primary TemplatableValue: stores either a constant value or a function pointer. More...
class	TemplatableValue< std::string, X... >
	Specialization for std::string: supports VALUE, STATIC_STRING, FLASH_STRING, stateless lambdas, and stateful lambdas (std::function). More...
class	TemplateLambda
	Lightweight wrapper for template platform lambdas (stateless function pointers only). More...
class	Trigger
struct	TriggerForwarder
	Callback forwarder that triggers an Automation directly. More...
struct	TriggerOnFalseForwarder
	Callback forwarder that triggers an Automation<> only when the bool arg is false. More...
struct	TriggerOnTrueForwarder
	Callback forwarder that triggers an Automation<> only when the bool arg is true. More...
struct	uint24_t
	24-bit unsigned integer type, transparently converting to 32-bit. More...
class	UpdateComponentAction
class	WaitUntilAction
	Wait until a condition is true to continue execution. More...
class	WarnIfComponentBlockingGuard
class	WhileAction
class	WhileLoopContinuation
	Loop continuation for WhileAction that checks condition and repeats or continues. More...
class	XorCondition

Concepts
concept	comparable_with
	Functions to constrain the range of arithmetic values.

Typedefs
using	PreferenceBackend = esp32::ESP32PreferenceBackend
template<typename T , typename... X>
using	TemplatableStorage
	Selects TemplatableFn (4 bytes) for trivially copyable types, TemplatableValue (8 bytes) otherwise.
using	uint64_be_t = internal::BigEndianLayout<uint64_t>
using	uint32_be_t = internal::BigEndianLayout<uint32_t>
using	uint24_be_t = internal::BigEndianLayout<uint24_t>
using	uint16_be_t = internal::BigEndianLayout<uint16_t>
using	int64_be_t = internal::BigEndianLayout<int64_t>
using	int32_be_t = internal::BigEndianLayout<int32_t>
using	int24_be_t = internal::BigEndianLayout<int24_t>
using	int16_be_t = internal::BigEndianLayout<int16_t>
using	uint64_le_t = internal::LittleEndianLayout<uint64_t>
using	uint32_le_t = internal::LittleEndianLayout<uint32_t>
using	uint24_le_t = internal::LittleEndianLayout<uint24_t>
using	uint16_le_t = internal::LittleEndianLayout<uint16_t>
using	int64_le_t = internal::LittleEndianLayout<int64_t>
using	int32_le_t = internal::LittleEndianLayout<int32_t>
using	int24_le_t = internal::LittleEndianLayout<int24_t>
using	int16_le_t = internal::LittleEndianLayout<int16_t>
using	ESPPreferenceBackend = PreferenceBackend
using	ESPPreferences = Preferences

Enumerations
enum class	InternalSchedulerID : uint32_t { POLLING_UPDATE = 0 }
	Type-safe scheduler IDs for core base classes. More...
enum class	RetryResult { DONE , RETRY }
enum	EntityCategory : uint8_t { ENTITY_CATEGORY_NONE = 0 , ENTITY_CATEGORY_CONFIG = 1 , ENTITY_CATEGORY_DIAGNOSTIC = 2 }

Functions
void	loop_task (void *pv_params)
void	app_main ()
uint32_t IRAM_ATTR HOT	millis ()
void	arch_restart ()
void	arch_init ()
uint32_t	arch_get_cpu_freq_hz ()
	__attribute__ ((always_inline)) inline bool in_isr_context()
	Returns true when executing inside an interrupt handler.
int64_t	esp_timer_get_time (void)
void	force_link_symbols ()
void	resetPins ()
void HOT	delay (uint32_t ms)
void	esphome_wake_ota_component_any_context ()
uint64_t	millis_64 ()
uint32_t IRAM_ATTR HOT	micros ()
void IRAM_ATTR HOT	delayMicroseconds (uint32_t us)
uint32_t	arch_get_cpu_cycle_count ()
	__attribute__ ((hot, always_inline)) inline void arch_feed_wdt()
void	arch_feed_wdt ()
std::string	str_truncate (const std::string &str, size_t length)
	Truncate a string to a specific length.
std::string	str_until (const char *str, char ch)
	Extract the part of the string until either the first occurrence of the specified character, or the end (requires str to be null-terminated).
std::string	str_until (const std::string &str, char ch)
	Extract the part of the string until either the first occurrence of the specified character, or the end.
template<int(*)(int) fn>
std::string	str_ctype_transform (const std::string &str)
std::string	str_lower_case (const std::string &str)
	Convert the string to lower case.
std::string	str_upper_case (const std::string &str)
	Convert the string to upper case.
std::string	str_snake_case (const std::string &str)
	Convert the string to snake case (lowercase with underscores).
std::string	str_sanitize (const std::string &str)
	Sanitizes the input string by removing all characters but alphanumerics, dashes and underscores.
std::string	str_snprintf (const char *fmt, size_t len,...)
std::string	str_sprintf (const char *fmt,...)
std::string	value_accuracy_to_string (float value, int8_t accuracy_decimals)
std::string	base64_encode (const std::vector< uint8_t > &buf)
	Encode a byte vector to base64 string.
std::string	base64_encode (const uint8_t *buf, size_t buf_len)
	Format a float value with accuracy decimals to a string.
std::vector< uint8_t >	base64_decode (const std::string &encoded_string)
	Decode a base64 string to a byte vector.
std::string	format_mac_address_pretty (const uint8_t *mac)
std::string	format_hex (const uint8_t *data, size_t length)
	Format the byte array data of length len in lowercased hex.
std::string	format_hex (const std::vector< uint8_t > &data)
	Format the vector data in lowercased hex.
std::string	format_hex_pretty (const uint8_t *data, size_t length, char separator='.', bool show_length=true)
	Format a byte array in pretty-printed, human-readable hex format.
std::string	format_hex_pretty (const std::vector< uint8_t > &data, char separator='.', bool show_length=true)
	Format a byte vector in pretty-printed, human-readable hex format.
std::string	format_hex_pretty (const uint16_t *data, size_t length, char separator='.', bool show_length=true)
	Format a 16-bit word array in pretty-printed, human-readable hex format.
std::string	format_hex_pretty (const std::vector< uint16_t > &data, char separator='.', bool show_length=true)
	Format a 16-bit word vector in pretty-printed, human-readable hex format.
std::string	format_hex_pretty (const std::string &data, char separator='.', bool show_length=true)
	Format a string's bytes in pretty-printed, human-readable hex format.
std::string	format_bin (const uint8_t *data, size_t length)
	Format the byte array data of length len in binary.
std::string	get_mac_address ()
	Get the device MAC address as a string, in lowercase hex notation.
std::string	get_mac_address_pretty ()
	Get the device MAC address as a string, in colon-separated uppercase hex notation.
std::string	__attribute__ ((format(printf, 1, 3))) str_snprintf(const char *fmt
	snprintf-like function returning std::string of maximum length len (excluding null terminator).
std::string size_t std::string	__attribute__ ((format(printf, 1, 2))) str_sprintf(const char *fmt
	sprintf-like function returning std::string.
std::string size_t std::string std::string	format_mac_address_pretty (const uint8_t mac[6])
	Format the six-byte array mac into a MAC address string.
char app_storage[sizeof(Application)]	asm (ESPHOME_STRINGIFY_(__USER_LABEL_PREFIX__) "_ZN7esphome3AppE")
template<int... >
struct	ESPDEPRECATED ("Use std::index_sequence instead. Removed in 2026.6.0", "2025.12.0") seq
void	log_update_interval (const char *tag, PollingComponent *component)
void	__attribute__ ((noinline, cold)) WarnIfComponentBlockingGuard
void	clear_setup_priority_overrides ()
	__attribute__ ((weak)) const LogString *component_source_lookup(uint8_t)
const LogString *	component_source_lookup (uint8_t index)
	Lookup component source name by index (1-based).
struct esphome::uint24_t	__attribute__ ((packed))
void	log_entity_icon (const char *tag, const char *prefix, const EntityBase &obj)
void	log_entity_device_class (const char *tag, const char *prefix, const EntityBase &obj)
void	log_entity_unit_of_measurement (const char *tag, const char *prefix, const EntityBase &obj)
const char *	entity_device_class_lookup (uint8_t index)
const char *	entity_uom_lookup (uint8_t index)
const char *	entity_icon_lookup (uint8_t index)
void	log_pin (const char *tag, const __FlashStringHelper *prefix, GPIOPin *pin)
void	log_pin (const char *tag, const char *prefix, GPIOPin *pin)
void	log_pin_with_prefix (const char *tag, const char *prefix, GPIOPin *pin)
void	__attribute__ ((noreturn)) arch_restart()
uint8_t	progmem_read_byte (const uint8_t *addr)
const char *	progmem_read_ptr (const char *const *addr)
uint16_t	progmem_read_uint16 (const uint16_t *addr)
	if (data)
float	gamma_correct (float value, float gamma)
float	gamma_uncorrect (float value, float gamma)
void HOT	esp_log_printf_ (int level, const char *tag, int line, const char *format,...)
void HOT	esp_log_printf_ (int level, const char *tag, int line, const __FlashStringHelper *format,...)
void HOT	esp_log_vprintf_ (int level, const char *tag, int line, const char *format, va_list args)
void HOT	esp_log_vprintf_ (int level, const char *tag, int line, const __FlashStringHelper *format, va_list args)
int HOT	esp_idf_log_vprintf_ (const char *format, va_list args)
	__attribute__ ((deprecated("Use esp_log_printf_() instead. Removed in 2026.9.0."))) void esp_log_vprintf_(int level
void	retry_handler (const std::shared_ptr< RetryArgs > &args)
void	__attribute__ ((noinline)) Scheduler
bool	operator== (const StringRef &lhs, const StringRef &rhs)
bool	operator== (const StringRef &lhs, const std::string &rhs)
bool	operator== (const std::string &lhs, const StringRef &rhs)
bool	operator== (const StringRef &lhs, const char *rhs)
bool	operator== (const char *lhs, const StringRef &rhs)
bool	operator!= (const StringRef &lhs, const StringRef &rhs)
bool	operator!= (const StringRef &lhs, const std::string &rhs)
bool	operator!= (const std::string &lhs, const StringRef &rhs)
bool	operator!= (const StringRef &lhs, const char *rhs)
bool	operator!= (const char *lhs, const StringRef &rhs)
bool	operator== (const StringRef &lhs, const __FlashStringHelper *rhs)
bool	operator== (const __FlashStringHelper *lhs, const StringRef &rhs)
bool	operator!= (const StringRef &lhs, const __FlashStringHelper *rhs)
bool	operator!= (const __FlashStringHelper *lhs, const StringRef &rhs)
bool	operator< (const StringRef &lhs, const StringRef &rhs)
std::string &	operator+= (std::string &lhs, const StringRef &rhs)
std::string	operator+ (const char *lhs, const StringRef &rhs)
std::string	operator+ (const StringRef &lhs, const char *rhs)
std::string	operator+ (const StringRef &lhs, const std::string &rhs)
std::string	operator+ (const std::string &lhs, const StringRef &rhs)
int	stoi (const StringRef &str, size_t *pos=nullptr, int base=10)
long	stol (const StringRef &str, size_t *pos=nullptr, int base=10)
float	stof (const StringRef &str, size_t *pos=nullptr)
double	stod (const StringRef &str, size_t *pos=nullptr)
void	convertToJson (const StringRef &src, JsonVariant dst)
uint8_t	days_in_month (uint8_t month, uint16_t year)
template<typename T >
bool	increment_time_value (T &current, uint16_t begin, uint16_t end)
template<typename ReturnT = uint32_t>
	__attribute__ ((always_inline)) inline const expr ReturnT micros_to_millis(uint64_t us)
	Convert a 64-bit microsecond count to milliseconds without calling __udivdi3 (software 64-bit divide, ~1200 ns on Xtensa @ 240 MHz).
bool	mqtt_is_connected ()
	Return whether the node has an active connection to an MQTT broker.
bool	remote_is_connected ()
	Return whether the node has any form of "remote" connection via the API or to an MQTT broker.
ESPHOME_ALWAYS_INLINE bool	api_is_connected ()
	Return whether the node has at least one client connected to the native API.
void IRAM_ATTR	wake_loop_any_context ()
	IRAM_ATTR entry point for ISR callers — defined in wake_esp8266.cpp.
void ESPHOME_ALWAYS_INLINE	wake_loop_impl ()
	Inline implementation — IRAM callers inline this directly.
void	wake_loop_threadsafe ()
	Non-ISR: always inline.
void ESPHOME_ALWAYS_INLINE	wake_loop_isrsafe ()
	ISR-safe: no task_woken arg because ESP8266 has no FreeRTOS. Caller must be IRAM_ATTR.
void IRAM_ATTR	wake_loop_isrsafe (BaseType_t *px_higher_priority_task_woken)
	IRAM_ATTR entry points — defined in wake_freertos.cpp.
bool	wake_register_fd (int fd)
	Register a socket file descriptor with the host select() loop.
void	wake_unregister_fd (int fd)
	Unregister a socket file descriptor. Not thread-safe — main loop only.
void	wake_setup ()
	One-time setup of the loopback wake socket. Called from Application::setup().
bool ESPHOME_ALWAYS_INLINE	wake_fd_ready (int fd)
void ESPHOME_ALWAYS_INLINE	wake_drain_notifications ()
	K_SEM_DEFINE (esphome_wake_sem, 0, 1)
System APIs
void	delay_microseconds_safe (uint32_t us)
	Delay for the given amount of microseconds, possibly yielding to other processes during the wait.
void	get_mac_address_raw (uint8_t *mac)
	Get the device MAC address as raw bytes, written into the provided byte array (6 bytes).
void	set_mac_address (uint8_t *mac)
	Set the MAC address to use from the provided byte array (6 bytes).
bool	has_custom_mac_address ()
	Check if a custom MAC address is set (ESP32 & variants)
void	get_mac_address_into_buffer (std::span< char, MAC_ADDRESS_BUFFER_SIZE > buf)
	Get the device MAC address into the given buffer, in lowercase hex notation.
const char *	get_mac_address_pretty_into_buffer (std::span< char, MAC_ADDRESS_PRETTY_BUFFER_SIZE > buf)
	Get the device MAC address into the given buffer, in colon-separated uppercase hex notation.
bool	mac_address_is_valid (const uint8_t *mac)
	Check if the MAC address is not all zeros or all ones.
STL backports
template<typename To , typename From , enable_if_t< sizeof(To)==sizeof(From) &&is_trivially_copyable< From >::value &&is_trivially_copyable< To >::value, int > = 0>
To	bit_cast (const From &src)
	Convert data between types, without aliasing issues or undefined behaviour.
float	lerp (float completion, float start, float end)=delete
template<typename T >
constexpr T	byteswap (T n)
template<>
constexpr uint8_t	byteswap (uint8_t n)
template<>
uint16_t	byteswap (uint16_t n)
template<>
uint32_t	byteswap (uint32_t n)
template<>
uint64_t	byteswap (uint64_t n)
template<>
int8_t	byteswap (int8_t n)
template<>
int16_t	byteswap (int16_t n)
template<>
int32_t	byteswap (int32_t n)
template<>
int64_t	byteswap (int64_t n)
template<>
constexpr uint16_t	byteswap (uint16_t n)
template<>
constexpr uint32_t	byteswap (uint32_t n)
template<>
constexpr uint64_t	byteswap (uint64_t n)
template<>
constexpr int8_t	byteswap (int8_t n)
template<>
constexpr int16_t	byteswap (int16_t n)
template<>
constexpr int32_t	byteswap (int32_t n)
template<>
constexpr int64_t	byteswap (int64_t n)
Container utilities
template<typename T , size_t N>
void	init_array_from (std::array< T, N > &dest, std::initializer_list< T > src)
	Initialize a std::array from an initializer_list.
Bit manipulation
constexpr uint16_t	encode_uint16 (uint8_t msb, uint8_t lsb)
	Encode a 16-bit value given the most and least significant byte.
constexpr uint32_t	encode_uint24 (uint8_t byte1, uint8_t byte2, uint8_t byte3)
	Encode a 24-bit value given three bytes in most to least significant byte order.
constexpr uint32_t	encode_uint32 (uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4)
	Encode a 32-bit value given four bytes in most to least significant byte order.
template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>
constexpr T	encode_value (const uint8_t *bytes)
	Encode a value from its constituent bytes (from most to least significant) in an array with length sizeof(T).
template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>
constexpr T	encode_value (const std::array< uint8_t, sizeof(T)> bytes)
	Encode a value from its constituent bytes (from most to least significant) in an std::array with length sizeof(T).
template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>
constexpr std::array< uint8_t, sizeof(T)>	decode_value (T val)
	Decode a value into its constituent bytes (from most to least significant).
uint8_t	reverse_bits (uint8_t x)
	Reverse the order of 8 bits.
uint16_t	reverse_bits (uint16_t x)
	Reverse the order of 16 bits.
uint32_t	reverse_bits (uint32_t x)
	Reverse the order of 32 bits.
template<typename T >
constexpr T	convert_big_endian (T val)
	Convert a value between host byte order and big endian (most significant byte first) order.
template<typename T >
constexpr T	convert_little_endian (T val)
	Convert a value between host byte order and little endian (least significant byte first) order.
Units
constexpr float	celsius_to_fahrenheit (float value)
	Convert degrees Celsius to degrees Fahrenheit.
constexpr float	fahrenheit_to_celsius (float value)
	Convert degrees Fahrenheit to degrees Celsius.
Utilities
void *	callback_manager_grow (void *data, uint16_t size, uint16_t &capacity, size_t elem_size)
	Grow a CallbackManager's backing array to exactly size+1. Defined in helpers.cpp.
Internal functions
template<typename T , enable_if_t<!std::is_pointer< T >::value, int > = 0>
T	id (T value)
	Helper function to make id(var) known from lambdas work in custom components.
template<typename T , enable_if_t< std::is_pointer< T * >::value, int > = 0>
T &	id (T *value)
	Helper function to make id(var) known from lambdas work in custom components.

Variables
TaskHandle_t	loop_task_handle = nullptr
ESPPreferences *	global_preferences
runtime_stats::RuntimeStatsCollector *	global_runtime_stats
std::string size_t	len
Application	App
	Global storage of Application pointer - only one Application can exist.
constexpr uint32_t	SCHEDULER_DONT_RUN = 4294967295UL
constexpr uint8_t	COMPONENT_STATE_MASK = 0x07
constexpr uint8_t	COMPONENT_STATE_CONSTRUCTION = 0x00
constexpr uint8_t	COMPONENT_STATE_SETUP = 0x01
constexpr uint8_t	COMPONENT_STATE_LOOP = 0x02
constexpr uint8_t	COMPONENT_STATE_FAILED = 0x03
constexpr uint8_t	COMPONENT_STATE_LOOP_DONE = 0x04
constexpr uint8_t	STATUS_LED_MASK = 0x18
constexpr uint8_t	STATUS_LED_OK = 0x00
constexpr uint8_t	STATUS_LED_WARNING = 0x08
constexpr uint8_t	STATUS_LED_ERROR = 0x10
constexpr uint8_t	COMPONENT_HAS_LOOP = 0x20
constexpr uint8_t	APP_STATE_SETUP_COMPLETE = 0x40
constexpr uint8_t	WARN_IF_BLOCKING_OVER_CS = 5U
constexpr size_t	GPIO_SUMMARY_MAX_LEN = 48
	Maximum buffer size for dump_summary output.
uint16_t uint16_t &	capacity = new_cap
uint16_t uint16_t size_t	elem_size
uint16_t	new_cap = size + 1
auto *	new_data = ::operator new(new_cap *elem_size)
const char *	tag
const char int	line
const char int const __FlashStringHelper *	format
const char int const __FlashStringHelper va_list	args
volatile bool	g_main_loop_woke = false
std::atomic< uint8_t >	g_wake_requested = 0
constexpr size_t	WAKE_NOTIFY_DRAIN_BUFFER_SIZE = 16

Parsing & formatting
enum	ParseOnOffState : uint8_t { PARSE_NONE = 0 , PARSE_ON , PARSE_OFF , PARSE_TOGGLE }
	Return values for parse_on_off(). More...
size_t	parse_hex (const char *str, size_t len, uint8_t *data, size_t count)
	Parse bytes from a hex-encoded string into a byte array.
char *	uint32_to_str_unchecked (char *buf, uint32_t val)
	Write unsigned 32-bit integer to buffer (internal, no size check).
char *	format_hex_to (char *buffer, size_t buffer_size, const uint8_t *data, size_t length)
	Format byte array as lowercase hex to buffer (base implementation).
char *	format_hex_pretty_to (char *buffer, size_t buffer_size, const uint8_t *data, size_t length, char separator=':')
	Format byte array as uppercase hex to buffer (base implementation).
char *	format_hex_pretty_to (char *buffer, size_t buffer_size, const uint16_t *data, size_t length, char separator=':')
	Format uint16_t array as uppercase hex with separator to pre-allocated buffer.
char *	format_bin_to (char *buffer, size_t buffer_size, const uint8_t *data, size_t length)
	Format byte array as binary string to buffer.
ParseOnOffState	parse_on_off (const char *str, const char *on=nullptr, const char *off=nullptr)
	Parse a string that contains either on, off or toggle.
size_t	value_accuracy_to_buf (std::span< char, VALUE_ACCURACY_MAX_LEN > buf, float value, int8_t accuracy_decimals)
	Format value with accuracy to buffer, returns chars written (excluding null)
size_t	value_accuracy_with_uom_to_buf (std::span< char, VALUE_ACCURACY_MAX_LEN > buf, float value, int8_t accuracy_decimals, StringRef unit_of_measurement)
	Format value with accuracy and UOM to buffer, returns chars written (excluding null)
int8_t	step_to_accuracy_decimals (float step)
	Derive accuracy in decimals from an increment step.
size_t	base64_decode (const std::string &encoded_string, uint8_t *buf, size_t buf_len)
size_t	base64_decode (const uint8_t *encoded_data, size_t encoded_len, uint8_t *buf, size_t buf_len)
bool	base64_decode_int32_vector (const std::string &base64, std::vector< int32_t > &out)
	Decode base64/base64url string directly into vector of little-endian int32 values.
template<typename T , enable_if_t<(std::is_integral< T >::value &&std::is_unsigned< T >::value), int > = 0>
optional< T >	parse_number (const char *str)
	Parse an unsigned decimal number from a null-terminated string.
template<typename T , enable_if_t<(std::is_integral< T >::value &&std::is_unsigned< T >::value), int > = 0>
optional< T >	parse_number (const std::string &str)
	Parse an unsigned decimal number.
bool	parse_hex (const char *str, uint8_t *data, size_t count)
	Parse count bytes from the hex-encoded string str of at least 2*count characters into array data.
bool	parse_hex (const std::string &str, uint8_t *data, size_t count)
	Parse count bytes from the hex-encoded string str of at least 2*count characters into array data.
bool	parse_hex (const char *str, std::vector< uint8_t > &data, size_t count)
	Parse count bytes from the hex-encoded string str of at least 2*count characters into vector data.
bool	parse_hex (const std::string &str, std::vector< uint8_t > &data, size_t count)
	Parse count bytes from the hex-encoded string str of at least 2*count characters into vector data.
template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>
optional< T >	parse_hex (const char *str, size_t len)
	Parse a hex-encoded string into an unsigned integer.
template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>
optional< T >	parse_hex (const char *str)
	Parse a hex-encoded null-terminated string (starting with the most significant byte) into an unsigned integer.
template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>
optional< T >	parse_hex (const std::string &str)
	Parse a hex-encoded null-terminated string (starting with the most significant byte) into an unsigned integer.
constexpr uint8_t	parse_hex_char (char c)
ESPHOME_ALWAYS_INLINE char	format_hex_char (uint8_t v, char base)
	Convert a nibble (0-15) to hex char with specified base ('a' for lowercase, 'A' for uppercase)
ESPHOME_ALWAYS_INLINE char	format_hex_char (uint8_t v)
	Convert a nibble (0-15) to lowercase hex char.
ESPHOME_ALWAYS_INLINE char	format_hex_pretty_char (uint8_t v)
	Convert a nibble (0-15) to uppercase hex char (used for pretty printing)
char *	int8_to_str (char *buf, int8_t val)
	Write int8 value to buffer without modulo operations.
char *	buf_append_sep_str (char *buf, size_t remaining, char separator, const char *str, size_t str_len)
	Append a separator char and a string to a buffer, respecting remaining space.
uint32_t	small_pow10 (int8_t n)
	Return 10^n for small non-negative n (0-3) as uint32_t, avoiding float.
size_t	uint32_to_str (std::span< char, UINT32_MAX_STR_SIZE > buf, uint32_t val)
	Write unsigned 32-bit integer to buffer with compile-time size check.
char *	frac_to_str_unchecked (char *buf, uint32_t frac, uint32_t divisor)
	Write fractional digits with leading zeros to buffer (internal, no size check).
template<size_t N>
char *	format_hex_to (char(&buffer)[N], const uint8_t *data, size_t length)
	Format byte array as lowercase hex to buffer.
template<size_t N, typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>
char *	format_hex_to (char(&buffer)[N], T val)
	Format an unsigned integer in lowercased hex to buffer, starting with the most significant byte.
template<size_t N>
char *	format_hex_to (char(&buffer)[N], const std::vector< uint8_t > &data)
	Format std::vector<uint8_t> as lowercase hex to buffer.
template<size_t N, size_t M>
char *	format_hex_to (char(&buffer)[N], const std::array< uint8_t, M > &data)
	Format std::array<uint8_t, M> as lowercase hex to buffer.
constexpr size_t	format_hex_size (size_t byte_count)
	Calculate buffer size needed for format_hex_to: "XXXXXXXX...\0" = bytes * 2 + 1.
constexpr size_t	format_hex_prefixed_size (size_t byte_count)
	Calculate buffer size needed for format_hex_prefixed_to: "0xXXXXXXXX...\0" = bytes * 2 + 3.
template<size_t N, typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>
char *	format_hex_prefixed_to (char(&buffer)[N], T val)
	Format an unsigned integer as "0x" prefixed lowercase hex to buffer.
template<size_t N>
char *	format_hex_prefixed_to (char(&buffer)[N], const uint8_t *data, size_t length)
	Format byte array as "0x" prefixed lowercase hex to buffer.
constexpr size_t	format_hex_pretty_size (size_t byte_count)
	Calculate buffer size needed for format_hex_pretty_to with separator: "XX:XX:...:XX\0".
template<size_t N>
char *	format_hex_pretty_to (char(&buffer)[N], const uint8_t *data, size_t length, char separator=':')
	Format byte array as uppercase hex with separator to buffer. Automatically deduces buffer size.
template<size_t N>
char *	format_hex_pretty_to (char(&buffer)[N], const std::vector< uint8_t > &data, char separator=':')
	Format std::vector<uint8_t> as uppercase hex with separator to buffer.
template<size_t N, size_t M>
char *	format_hex_pretty_to (char(&buffer)[N], const std::array< uint8_t, M > &data, char separator=':')
	Format std::array<uint8_t, M> as uppercase hex with separator to buffer.
constexpr size_t	format_hex_pretty_uint16_size (size_t count)
	Calculate buffer size needed for format_hex_pretty_to with uint16_t data: "XXXX:XXXX:...:XXXX\0".
template<size_t N>
char *	format_hex_pretty_to (char(&buffer)[N], const uint16_t *data, size_t length, char separator=':')
	Format uint16_t array as uppercase hex with separator to buffer. Automatically deduces buffer size.
char *	format_mac_addr_upper (const uint8_t *mac, char *output)
	Format MAC address as XX:XX:XX:XX:XX:XX (uppercase, colon separators)
void	format_mac_addr_lower_no_sep (const uint8_t *mac, char *output)
	Format MAC address as xxxxxxxxxxxxxx (lowercase, no separators)
template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>
std::string	format_hex (T val)
	Format an unsigned integer in lowercased hex, starting with the most significant byte.
template<std::size_t N>
std::string	format_hex (const std::array< uint8_t, N > &data)
	Format the std::array data in lowercased hex.
template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>
std::string	format_hex_pretty (T val, char separator='.', bool show_length=true)
	Format an unsigned integer in pretty-printed, human-readable hex format.
constexpr size_t	format_bin_size (size_t byte_count)
	Calculate buffer size needed for format_bin_to: "01234567...\0" = bytes * 8 + 1.
template<size_t N>
char *	format_bin_to (char(&buffer)[N], const uint8_t *data, size_t length)
	Format byte array as binary to buffer. Automatically deduces buffer size.
template<size_t N, typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>
char *	format_bin_to (char(&buffer)[N], T val)
	Format an unsigned integer in binary to buffer, MSB first.
template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>
std::string	format_bin (T val)
	Format an unsigned integer in binary, starting with the most significant byte.

Memory management
template<class T >
using	ExternalRAMAllocator = RAMAllocator<T>
template<std::totally_ordered T, comparable_with< T > U>
T	clamp_at_least (T value, U min)
template<std::totally_ordered T, comparable_with< T > U>
T	clamp_at_most (T value, U max)

Strings
uint16_t	size
size_t size_t	pos
size_t size_t const char *	fmt
int	written = vsnprintf(buf + pos, size - pos, fmt, args)
bool	str_equals_case_insensitive (const std::string &a, const std::string &b)
	Compare strings for equality in case-insensitive manner.
bool	str_equals_case_insensitive (StringRef a, StringRef b)
	Compare StringRefs for equality in case-insensitive manner.
bool	str_startswith (const std::string &str, const std::string &start)
	Check whether a string starts with a value.
bool	str_endswith (const std::string &str, const std::string &end)
	Check whether a string ends with a value.
bool	str_endswith_ignore_case (const char *str, size_t str_len, const char *suffix, size_t suffix_len)
	Case-insensitive check if string ends with suffix (no heap allocation).
char *	str_sanitize_to (char *buffer, size_t buffer_size, const char *str)
	Sanitize a string to buffer, keeping only alphanumerics, dashes, and underscores.
size_t	make_name_with_suffix_to (char *buffer, size_t buffer_size, const char *name, size_t name_len, char sep, const char *suffix_ptr, size_t suffix_len)
	Zero-allocation version: format name + separator + suffix directly into buffer.
std::string	make_name_with_suffix (const char *name, size_t name_len, char sep, const char *suffix_ptr, size_t suffix_len)
	Optimized string concatenation: name + separator + suffix (const char* overload) Uses a fixed stack buffer to avoid heap allocations.
std::string	make_name_with_suffix (const std::string &name, char sep, const char *suffix_ptr, size_t suffix_len)
	Concatenate a name with a separator and suffix using an efficient stack-based approach.
bool	str_equals_case_insensitive (const char *a, const char *b)
	Compare C strings for equality in case-insensitive manner (no heap allocation).
bool	str_equals_case_insensitive (const std::string &a, const char *b)
bool	str_equals_case_insensitive (const char *a, const std::string &b)
bool	str_endswith_ignore_case (const char *str, const char *suffix)
bool	str_endswith_ignore_case (const std::string &str, const char *suffix)
constexpr char	to_snake_case_char (char c)
	Convert a single char to snake_case: lowercase and space to underscore.
constexpr char	to_sanitized_char (char c)
	Sanitize a single char: keep alphanumerics, dashes, underscores; replace others with underscore.
template<size_t N>
char *	str_sanitize_to (char(&buffer)[N], const char *str)
	Sanitize a string to buffer. Automatically deduces buffer size.
uint32_t	fnv1_hash_object_id (const char *str, size_t len)
	Calculate FNV-1 hash of a string while applying snake_case + sanitize transformations.
size_t	buf_append_printf_p (char *buf, size_t size, size_t pos, PGM_P fmt,...)
	Safely append formatted string to buffer, returning new position (capped at size).
	__attribute__ ((format(printf, 4, 5))) inline size_t buf_append_printf(char *buf
	Safely append formatted string to buffer, returning new position (capped at size).
size_t size_t const char	va_start (args, fmt)
	va_end (args)
	if (written< 0)
size_t	buf_append_str_p (char *buf, size_t size, size_t pos, PGM_P str)
	Safely append a PROGMEM string to buffer, returning new position (capped at size).
size_t	buf_append_str (char *buf, size_t size, size_t pos, const char *str)
	Safely append a string to buffer, returning new position (capped at size).

Mathematics
constexpr uint32_t	FNV1_OFFSET_BASIS = 2166136261UL
	FNV-1 32-bit offset basis.
constexpr uint32_t	FNV1_PRIME = 16777619UL
	FNV-1 32-bit prime.
bool	random_bytes (uint8_t *data, size_t len)
	Generate len random bytes using the platform's secure RNG (hardware RNG or OS CSPRNG).
uint32_t	random_uint32 ()
	Return a random 32-bit unsigned integer.
uint8_t	crc8 (const uint8_t *data, uint8_t len, uint8_t crc=0x00, uint8_t poly=0x8C, bool msb_first=false)
	Calculate a CRC-8 checksum of data with size len.
uint16_t	crc16 (const uint8_t *data, uint16_t len, uint16_t crc=0xffff, uint16_t reverse_poly=0xa001, bool refin=false, bool refout=false)
	Calculate a CRC-16 checksum of data with size len.
uint16_t	crc16be (const uint8_t *data, uint16_t len, uint16_t crc, uint16_t poly, bool refin, bool refout)
uint32_t	fnv1_hash (const char *str)
	Calculate a FNV-1 hash of str.
float	random_float ()
	Return a random float between 0 and 1.
int8_t	ilog10 (float value)
	Compute floor(log10(fabs(value))) using iterative comparison.
float	pow10_int (int8_t exp)
	Compute 10^exp using iterative multiplication/division.
template<typename T , typename U >
T	remap (U value, U min, U max, T min_out, T max_out)
	Remap value from the range (min, max) to (min_out, max_out).
uint32_t	fnv1_hash (const std::string &str)
template<std::integral T>
constexpr uint32_t	fnv1_hash_extend (uint32_t hash, T value)
	Extend a FNV-1 hash with an integer (hashes each byte).
constexpr uint32_t	fnv1_hash_extend (uint32_t hash, const char *str)
	Extend a FNV-1 hash with additional string data.
uint32_t	fnv1_hash_extend (uint32_t hash, const std::string &str)
constexpr uint32_t	fnv1a_hash_extend (uint32_t hash, const char *str)
	Extend a FNV-1a hash with additional string data.
uint32_t	fnv1a_hash_extend (uint32_t hash, const std::string &str)
template<std::integral T>
constexpr uint32_t	fnv1a_hash_extend (uint32_t hash, T value)
	Extend a FNV-1a hash with an integer (hashes each byte).
constexpr uint32_t	fnv1a_hash (const char *str)
	Calculate a FNV-1a hash of str.
uint32_t	fnv1a_hash (const std::string &str)

Colors
float	gamma
void	rgb_to_hsv (float red, float green, float blue, int &hue, float &saturation, float &value)
	Convert red, green and blue (all 0-1) values to hue (0-360), saturation (0-1) and value (0-1).
void	hsv_to_rgb (int hue, float saturation, float value, float &red, float &green, float &blue)
	Convert hue (0-360), saturation (0-1) and value (0-1) to red, green and blue (all 0-1).
	ESPDEPRECATED ("Use LightState::gamma_correct_lut() instead. Removed in 2026.9.0.", "2026.3.0") float gamma_correct(float value
	Applies gamma correction of gamma to value.
	ESPDEPRECATED ("Use LightState::gamma_uncorrect_lut() instead. Removed in 2026.9.0.", "2026.3.0") float gamma_uncorrect(float value
	Reverts gamma correction of gamma to value.

Typedef Documentation

ESPPreferenceBackend

using esphome::ESPPreferenceBackend = PreferenceBackend

Definition at line 36 of file preference_backend.h.

ESPPreferences

using esphome::ESPPreferences = Preferences

Definition at line 42 of file preferences.h.

ExternalRAMAllocator

template<class T >

using esphome::ExternalRAMAllocator = RAMAllocator<T>

Definition at line 2174 of file helpers.h.

int16_be_t

using esphome::int16_be_t = internal::BigEndianLayout<int16_t>

Definition at line 51 of file datatypes.h.

int16_le_t

using esphome::int16_le_t = internal::LittleEndianLayout<int16_t>

Definition at line 59 of file datatypes.h.

int24_be_t

using esphome::int24_be_t = internal::BigEndianLayout<int24_t>

Definition at line 50 of file datatypes.h.

int24_le_t

using esphome::int24_le_t = internal::LittleEndianLayout<int24_t>

Definition at line 58 of file datatypes.h.

int32_be_t

using esphome::int32_be_t = internal::BigEndianLayout<int32_t>

Definition at line 49 of file datatypes.h.

int32_le_t

using esphome::int32_le_t = internal::LittleEndianLayout<int32_t>

Definition at line 57 of file datatypes.h.

int64_be_t

using esphome::int64_be_t = internal::BigEndianLayout<int64_t>

Definition at line 48 of file datatypes.h.

int64_le_t

using esphome::int64_le_t = internal::LittleEndianLayout<int64_t>

Definition at line 56 of file datatypes.h.

PreferenceBackend

typedef zephyr::ZephyrPreferenceBackend esphome::PreferenceBackend = esp32::ESP32PreferenceBackend

Definition at line 24 of file preference_backend.h.

TemplatableStorage

template<typename T , typename... X>

using esphome::TemplatableStorage

Initial value:

 
    std::conditional_t<std::is_trivially_copyable_v<T>, TemplatableFn<T, X...>, TemplatableValue<T, X...>>

Selects TemplatableFn (4 bytes) for trivially copyable types, TemplatableValue (8 bytes) otherwise.

Non-trivial types (std::string, std::vector<uint8_t>, etc.) need TemplatableValue for raw value storage, PROGMEM/FlashStringHelper support (strings), and proper copy/move/destruction.

Definition at line 100 of file automation.h.

uint16_be_t

using esphome::uint16_be_t = internal::BigEndianLayout<uint16_t>

Definition at line 47 of file datatypes.h.

uint16_le_t

using esphome::uint16_le_t = internal::LittleEndianLayout<uint16_t>

Definition at line 55 of file datatypes.h.

uint24_be_t

using esphome::uint24_be_t = internal::BigEndianLayout<uint24_t>

Definition at line 46 of file datatypes.h.

uint24_le_t

using esphome::uint24_le_t = internal::LittleEndianLayout<uint24_t>

Definition at line 54 of file datatypes.h.

uint32_be_t

using esphome::uint32_be_t = internal::BigEndianLayout<uint32_t>

Definition at line 45 of file datatypes.h.

uint32_le_t

using esphome::uint32_le_t = internal::LittleEndianLayout<uint32_t>

Definition at line 53 of file datatypes.h.

uint64_be_t

using esphome::uint64_be_t = internal::BigEndianLayout<uint64_t>

Definition at line 44 of file datatypes.h.

uint64_le_t

using esphome::uint64_le_t = internal::LittleEndianLayout<uint64_t>

Definition at line 52 of file datatypes.h.

Enumeration Type Documentation

EntityCategory

enum esphome::EntityCategory : uint8_t

Enumerator
ENTITY_CATEGORY_NONE
ENTITY_CATEGORY_CONFIG
ENTITY_CATEGORY_DIAGNOSTIC

Definition at line 52 of file entity_base.h.

InternalSchedulerID

enum class esphome::InternalSchedulerID : uint32_t

strong

Type-safe scheduler IDs for core base classes.

Uses a separate NameType (NUMERIC_ID_INTERNAL) so IDs can never collide with component-level NUMERIC_ID values, even if the uint32_t values overlap.

Enumerator
POLLING_UPDATE

Definition at line 66 of file component.h.

ParseOnOffState

enum esphome::ParseOnOffState : uint8_t

Return values for parse_on_off().

Enumerator
PARSE_NONE
PARSE_ON
PARSE_OFF
PARSE_TOGGLE

Definition at line 1551 of file helpers.h.

RetryResult

enum class esphome::RetryResult

strong

Enumerator
DONE
RETRY

Definition at line 98 of file component.h.

Function Documentation

__attribute__() [1/12]

esphome::__attribute__

(

(always_inline)

)

Returns true when executing inside an interrupt handler.

Wake the main loop from any context (ISR or task).

ESP8266 has no reliable single-register ISR detection: PS.INTLEVEL is non-zero both in a real ISR and when user code masks interrupts. The ESP8266 wake path is context-agnostic (wake_loop_impl uses esp_schedule which is ISR-safe) so this helper is unused on this platform.

Host has no ISR concept.

Zephyr/nRF52: not currently consulted — wake path is platform-specific.

always_inline so callers placed in IRAM keep the whole wake path in IRAM.

Definition at line 28 of file hal.h.

__attribute__() [2/12]

template<typename ReturnT = uint32_t>

esphome::__attribute__

(

(always_inline)

)

const

Convert a 64-bit microsecond count to milliseconds without calling __udivdi3 (software 64-bit divide, ~1200 ns on Xtensa @ 240 MHz).

Returns uint32_t by default (for millis()), or uint64_t when requested (for millis_64()). The only difference is whether hi * Q is truncated to 32 bits or widened to 64.

On 32-bit targets, GCC does not optimize 64-bit constant division into a multiply-by-reciprocal. Since 1000 = 8 * 125, we first right-shift by 3 (free divide-by-8), then use the Euclidean division identity to decompose the remaining 64-bit divide-by-125 into a single 32-bit division:

floor(us / 1000) = floor(floor(us / 8) / 125) [exact for integers] 2^32 = Q * 125 + R (34359738 * 125 + 46) (hi * 2^32 + lo) / 125 = hi * Q + (hi * R + lo) / 125

GCC optimizes the remaining 32-bit "/ 125U" into a multiply-by-reciprocal (mulhu + shift), so no division instruction is emitted.

Safe for us up to ~3.2e18 (~101,700 years of microseconds).

See: https://en.wikipedia.org/wiki/Euclidean_division See: https://ridiculousfish.com/blog/posts/labor-of-division-episode-iii.html

Definition at line 31 of file time_conversion.h.

__attribute__() [3/12]

esphome::__attribute__

(

(deprecated("Use esp_log_printf_() instead. Removed in 2026.9.0."))

)

__attribute__() [4/12]

std::string size_t std::string esphome::__attribute__

(

(format(printf, 1, 2))

)

const

sprintf-like function returning std::string.

Warning

Allocates heap memory. Use snprintf() with a stack buffer instead.

__attribute__() [5/12]

std::string esphome::__attribute__

(

(format(printf, 1, 3))

)

const

snprintf-like function returning std::string of maximum length len (excluding null terminator).

Warning

Allocates heap memory. Use snprintf() with a stack buffer instead.

__attribute__() [6/12]

esphome::__attribute__

(

(format(printf, 4, 5))

)

Safely append formatted string to buffer, returning new position (capped at size).

Handles snprintf edge cases: negative returns (encoding errors) and truncation.

Parameters

buf	Output buffer
size	Total buffer size
pos	Current position in buffer
fmt	printf-style format string

Returns

New position after appending (capped at size on overflow)

__attribute__() [7/12]

esphome::__attribute__

(

(hot, always_inline)

)

Definition at line 103 of file hal.h.

__attribute__() [8/12]

void esphome::__attribute__

(

(noinline)

)

Definition at line 910 of file scheduler.cpp.

__attribute__() [9/12]

esphome::__attribute__

(

(noinline, cold)

)

Definition at line 513 of file component.cpp.

__attribute__() [10/12]

void esphome::__attribute__

(

(noreturn)

)

__attribute__() [11/12]

struct esphome::int24_t esphome::__attribute__

(

(packed)

)

__attribute__() [12/12]

esphome::__attribute__

(

(weak)

)

const

Definition at line 537 of file component.cpp.

api_is_connected()

ESPHOME_ALWAYS_INLINE bool esphome::api_is_connected ( )

inline

Return whether the node has at least one client connected to the native API.

Inline so that hot-path callers (e.g. component loop() ticks that check connectivity every iteration) can skip the call8/return pair. With USE_API disabled this trivially returns false and collapses at compile time.

Definition at line 20 of file util.h.

app_main()

void esphome::app_main

(

)

Definition at line 29 of file core.cpp.

arch_feed_wdt()

void esphome::arch_feed_wdt

(

)

Definition at line 53 of file hal.cpp.

arch_get_cpu_cycle_count()

uint32_t esphome::arch_get_cpu_cycle_count

(

)

Definition at line 71 of file hal.cpp.

arch_get_cpu_freq_hz()

uint32_t esphome::arch_get_cpu_freq_hz

(

)

Definition at line 63 of file hal.cpp.

arch_init()

void esphome::arch_init

(

)

Definition at line 47 of file hal.cpp.

arch_restart()

void esphome::arch_restart

(

)

Definition at line 39 of file hal.cpp.

asm()

char app_storage[sizeof(Application)] esphome::asm

(

ESPHOME_STRINGIFY_(__USER_LABEL_PREFIX__) "_ZN7esphome3AppE"

)

base64_decode() [1/3]

std::vector< uint8_t > esphome::base64_decode

(

const std::string &

encoded_string

)

Decode a base64 string to a byte vector.

Warning

Allocates heap memory. Use base64_decode(data, len, buf, buf_len) with a pre-allocated buffer instead.

Definition at line 143 of file alloc_helpers.cpp.

base64_decode() [2/3]

size_t esphome::base64_decode	(	const std::string &	encoded_string,
		uint8_t *	buf,
		size_t	buf_len )

Definition at line 545 of file helpers.cpp.

base64_decode() [3/3]

size_t esphome::base64_decode	(	const uint8_t *	encoded_data,
		size_t	encoded_len,
		uint8_t *	buf,
		size_t	buf_len )

Definition at line 570 of file helpers.cpp.

base64_decode_int32_vector()

bool esphome::base64_decode_int32_vector	(	const std::string &	base64,
		std::vector< int32_t > &	out )

Decode base64/base64url string directly into vector of little-endian int32 values.

Parameters

base64	Base64 or base64url encoded string (both +/ and -_ accepted)
out	Output vector (cleared and filled with decoded int32 values)

Returns

true if successful, false if decode failed or invalid size

Definition at line 610 of file helpers.cpp.

base64_encode() [1/2]

std::string esphome::base64_encode

(

const std::vector< uint8_t > &

buf

)

Encode a byte vector to base64 string.

Warning

Allocates heap memory.

Definition at line 115 of file alloc_helpers.cpp.

base64_encode() [2/2]

std::string esphome::base64_encode	(	const uint8_t *	buf,
		size_t	buf_len )

Format a float value with accuracy decimals to a string.

Encode a byte buffer to base64 string.

Warning

Allocates heap memory.

Definition at line 117 of file alloc_helpers.cpp.

bit_cast()

template<typename To , typename From , enable_if_t< sizeof(To)==sizeof(From) &&is_trivially_copyable< From >::value &&is_trivially_copyable< To >::value, int > = 0>

To esphome::bit_cast

(

const From &

src

)

Convert data between types, without aliasing issues or undefined behaviour.

Definition at line 84 of file helpers.h.

buf_append_printf_p()

size_t esphome::buf_append_printf_p ( char * buf, size_t size, size_t pos, PGM_P fmt, ... )

inline

Safely append formatted string to buffer, returning new position (capped at size).

Parameters

buf	Output buffer
size	Total buffer size
pos	Current position in buffer
fmt	Format string (must be in PROGMEM on ESP8266)

Returns

New position after appending (capped at size on overflow)

Definition at line 1016 of file helpers.h.

buf_append_sep_str()

char * esphome::buf_append_sep_str ( char * buf, size_t remaining, char separator, const char * str, size_t str_len )

inline

Append a separator char and a string to a buffer, respecting remaining space.

Returns pointer past last char written. The buffer is always null-terminated when remaining >= 1 (even on the no-room early-return), so callers always get a valid C string.

Definition at line 1285 of file helpers.h.

buf_append_str()

size_t esphome::buf_append_str ( char * buf, size_t size, size_t pos, const char * str )

inline

Safely append a string to buffer, returning new position (capped at size).

More efficient than buf_append_printf for plain string literals.

Parameters

buf	Output buffer
size	Total buffer size
pos	Current position in buffer
str	String to append (must not be null)

Returns

New position after appending (capped at size on overflow)

Definition at line 1087 of file helpers.h.

buf_append_str_p()

size_t esphome::buf_append_str_p ( char * buf, size_t size, size_t pos, PGM_P str )

inline

Safely append a PROGMEM string to buffer, returning new position (capped at size).

ESP8266 internal implementation — prefer the buf_append_str macro which wraps literals with PSTR() automatically so they stay in flash instead of eating RAM.

Parameters

buf	Output buffer
size	Total buffer size
pos	Current position in buffer
str	PROGMEM-resident string to append (must not be null)

Returns

New position after appending; returns size if pos >= size, otherwise returns at most size - 1 because one byte is reserved for the null terminator

Definition at line 1064 of file helpers.h.

byteswap() [1/16]

template<>

int16_t esphome::byteswap ( int16_t n )

inline

Definition at line 109 of file helpers.h.

byteswap() [2/16]

template<>

int16_t esphome::byteswap ( int16_t n )

constexpr

Definition at line 117 of file helpers.h.

byteswap() [3/16]

template<>

int32_t esphome::byteswap ( int32_t n )

inline

Definition at line 110 of file helpers.h.

byteswap() [4/16]

template<>

int32_t esphome::byteswap ( int32_t n )

constexpr

Definition at line 118 of file helpers.h.

byteswap() [5/16]

template<>

int64_t esphome::byteswap ( int64_t n )

inline

Definition at line 111 of file helpers.h.

byteswap() [6/16]

template<>

int64_t esphome::byteswap ( int64_t n )

constexpr

Definition at line 119 of file helpers.h.

byteswap() [7/16]

template<>

int8_t esphome::byteswap ( int8_t n )

inline

Definition at line 108 of file helpers.h.

byteswap() [8/16]

template<>

int8_t esphome::byteswap ( int8_t n )

constexpr

Definition at line 116 of file helpers.h.

byteswap() [9/16]

template<typename T >

T esphome::byteswap ( T n )

constexpr

Definition at line 96 of file helpers.h.

byteswap() [10/16]

template<>

uint16_t esphome::byteswap ( uint16_t n )

inline

Definition at line 105 of file helpers.h.

byteswap() [11/16]

template<>

uint16_t esphome::byteswap ( uint16_t n )

constexpr

Definition at line 113 of file helpers.h.

byteswap() [12/16]

template<>

uint32_t esphome::byteswap ( uint32_t n )

inline

Definition at line 106 of file helpers.h.

byteswap() [13/16]

template<>

uint32_t esphome::byteswap ( uint32_t n )

constexpr

Definition at line 114 of file helpers.h.

byteswap() [14/16]

template<>

uint64_t esphome::byteswap ( uint64_t n )

inline

Definition at line 107 of file helpers.h.

byteswap() [15/16]

template<>

uint64_t esphome::byteswap ( uint64_t n )

constexpr

Definition at line 115 of file helpers.h.

byteswap() [16/16]

template<>

uint8_t esphome::byteswap ( uint8_t n )

constexpr

Definition at line 102 of file helpers.h.

callback_manager_grow()

void * esphome::callback_manager_grow	(	void *	data,
		uint16_t	size,
		uint16_t &	capacity,
		size_t	elem_size )

Grow a CallbackManager's backing array to exactly size+1. Defined in helpers.cpp.

celsius_to_fahrenheit()

float esphome::celsius_to_fahrenheit ( float value )

constexpr

Convert degrees Celsius to degrees Fahrenheit.

Definition at line 1610 of file helpers.h.

clamp_at_least()

template<std::totally_ordered T, comparable_with< T > U>

T esphome::clamp_at_least	(	T	value,
		U	min )

Definition at line 2186 of file helpers.h.

clamp_at_most()

template<std::totally_ordered T, comparable_with< T > U>

T esphome::clamp_at_most	(	T	value,
		U	max )

Definition at line 2191 of file helpers.h.

clear_setup_priority_overrides()

void esphome::clear_setup_priority_overrides

(

)

Definition at line 529 of file component.cpp.

component_source_lookup()

const LogString * esphome::component_source_lookup

(

uint8_t

index

)

Lookup component source name by index (1-based).

Generated by Python codegen. Weak default returns "<unknown>" so builds without codegen still link.

convert_big_endian()

template<typename T >

T esphome::convert_big_endian ( T val )

constexpr

Convert a value between host byte order and big endian (most significant byte first) order.

Definition at line 915 of file helpers.h.

convert_little_endian()

template<typename T >

T esphome::convert_little_endian ( T val )

constexpr

Convert a value between host byte order and little endian (least significant byte first) order.

Definition at line 924 of file helpers.h.

convertToJson()

void esphome::convertToJson ( const StringRef & src, JsonVariant dst )

inline

Definition at line 252 of file string_ref.h.

crc16()

uint16_t esphome::crc16	(	const uint8_t *	data,
		uint16_t	len,
		uint16_t	crc,
		uint16_t	reverse_poly,
		bool	refin,
		bool	refout )

Calculate a CRC-16 checksum of data with size len.

Definition at line 86 of file helpers.cpp.

crc16be()

uint16_t esphome::crc16be	(	const uint8_t *	data,
		uint16_t	len,
		uint16_t	crc,
		uint16_t	poly,
		bool	refin,
		bool	refout )

Definition at line 126 of file helpers.cpp.

crc8()

uint8_t esphome::crc8	(	const uint8_t *	data,
		uint8_t	len,
		uint8_t	crc,
		uint8_t	poly,
		bool	msb_first )

Calculate a CRC-8 checksum of data with size len.

Definition at line 59 of file helpers.cpp.

days_in_month()

uint8_t esphome::days_in_month	(	uint8_t	month,
		uint16_t	year )

Definition at line 11 of file time.cpp.

decode_value()

template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>

std::array< uint8_t, sizeof(T)> esphome::decode_value ( T val )

constexpr

Decode a value into its constituent bytes (from most to least significant).

Definition at line 888 of file helpers.h.

delay()

void esphome::delay

(

uint32_t

ms

)

Definition at line 82 of file hal.cpp.

delay_microseconds_safe()

void esphome::delay_microseconds_safe

(

uint32_t

us

)

Delay for the given amount of microseconds, possibly yielding to other processes during the wait.

Definition at line 786 of file helpers.cpp.

delayMicroseconds()

void esphome::delayMicroseconds

(

uint32_t

us

)

Definition at line 48 of file hal.cpp.

encode_uint16()

uint16_t esphome::encode_uint16 ( uint8_t msb, uint8_t lsb )

constexpr

Encode a 16-bit value given the most and least significant byte.

Definition at line 859 of file helpers.h.

encode_uint24()

uint32_t esphome::encode_uint24 ( uint8_t byte1, uint8_t byte2, uint8_t byte3 )

constexpr

Encode a 24-bit value given three bytes in most to least significant byte order.

Definition at line 863 of file helpers.h.

encode_uint32()

uint32_t esphome::encode_uint32 ( uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4 )

constexpr

Encode a 32-bit value given four bytes in most to least significant byte order.

Definition at line 867 of file helpers.h.

encode_value() [1/2]

template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>

T esphome::encode_value ( const std::array< uint8_t, sizeof(T)> bytes )

constexpr

Encode a value from its constituent bytes (from most to least significant) in an std::array with length sizeof(T).

Definition at line 883 of file helpers.h.

encode_value() [2/2]

template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>

T esphome::encode_value ( const uint8_t * bytes )

constexpr

Encode a value from its constituent bytes (from most to least significant) in an array with length sizeof(T).

Definition at line 873 of file helpers.h.

entity_device_class_lookup()

const char * esphome::entity_device_class_lookup ( uint8_t index )

extern

entity_icon_lookup()

const char * esphome::entity_icon_lookup ( uint8_t index )

extern

entity_uom_lookup()

const char * esphome::entity_uom_lookup ( uint8_t index )

extern

esp_idf_log_vprintf_()

int esphome::esp_idf_log_vprintf_	(	const char *	format,
		va_list	args )

Definition at line 74 of file log.cpp.

esp_log_printf_() [1/2]

void void esphome::esp_log_printf_	(	int	level,
		const char *	tag,
		int	line,
		const __FlashStringHelper *	format,
			... )

Definition at line 40 of file log.cpp.

esp_log_printf_() [2/2]

void esphome::esp_log_printf_	(	int	level,
		const char *	tag,
		int	line,
		const char *	format,
			... )

Definition at line 21 of file log.cpp.

esp_log_vprintf_() [1/2]

void HOT esphome::esp_log_vprintf_	(	int	level,
		const char *	tag,
		int	line,
		const __FlashStringHelper *	format,
		va_list	args )

Definition at line 65 of file log.cpp.

esp_log_vprintf_() [2/2]

void esphome::esp_log_vprintf_	(	int	level,
		const char *	tag,
		int	line,
		const char *	format,
		va_list	args )

Definition at line 51 of file log.cpp.

esp_timer_get_time()

int64_t esphome::esp_timer_get_time

(

void

)

ESPDEPRECATED() [1/3]

esphome::ESPDEPRECATED	(	"Use LightState::gamma_correct_lut() instead. Removed in 2026.9.0."	,
		"2026.3.0"	)

Applies gamma correction of gamma to value.

ESPDEPRECATED() [2/3]

esphome::ESPDEPRECATED	(	"Use LightState::gamma_uncorrect_lut() instead. Removed in 2026.9.0."	,
		"2026.3.0"	)

Reverts gamma correction of gamma to value.

ESPDEPRECATED() [3/3]

template<int... >

struct esphome::ESPDEPRECATED	(	"Use std::index_sequence instead. Removed in 2026.6.0"	,
		"2025.12.0"	)

Definition at line 1 of file automation.h.

esphome_wake_ota_component_any_context()

void esphome::esphome_wake_ota_component_any_context

(

void

)

Definition at line 39 of file ota_esphome.cpp.

fahrenheit_to_celsius()

float esphome::fahrenheit_to_celsius ( float value )

constexpr

Convert degrees Fahrenheit to degrees Celsius.

Definition at line 1612 of file helpers.h.

fnv1_hash() [1/2]

uint32_t esphome::fnv1_hash

(

const char *

str

)

Calculate a FNV-1 hash of str.

Note: FNV-1a (fnv1a_hash) is preferred for new code due to better avalanche characteristics.

Definition at line 161 of file helpers.cpp.

fnv1_hash() [2/2]

uint32_t esphome::fnv1_hash ( const std::string & str )

inline

Definition at line 781 of file helpers.h.

fnv1_hash_extend() [1/3]

uint32_t esphome::fnv1_hash_extend ( uint32_t hash, const char * str )

constexpr

Extend a FNV-1 hash with additional string data.

Definition at line 799 of file helpers.h.

fnv1_hash_extend() [2/3]

uint32_t esphome::fnv1_hash_extend ( uint32_t hash, const std::string & str )

inline

Definition at line 808 of file helpers.h.

fnv1_hash_extend() [3/3]

template<std::integral T>

uint32_t esphome::fnv1_hash_extend ( uint32_t hash, T value )

constexpr

Extend a FNV-1 hash with an integer (hashes each byte).

Definition at line 789 of file helpers.h.

fnv1_hash_object_id()

uint32_t esphome::fnv1_hash_object_id ( const char * str, size_t len )

inline

Calculate FNV-1 hash of a string while applying snake_case + sanitize transformations.

This computes object_id hashes directly from names without creating an intermediate buffer. IMPORTANT: Must match Python fnv1_hash_object_id() in esphome/helpers.py. If you modify this function, update the Python version and tests in both places.

Definition at line 995 of file helpers.h.

fnv1a_hash() [1/2]

uint32_t esphome::fnv1a_hash ( const char * str )

constexpr

Calculate a FNV-1a hash of str.

Definition at line 834 of file helpers.h.

fnv1a_hash() [2/2]

uint32_t esphome::fnv1a_hash ( const std::string & str )

inline

Definition at line 835 of file helpers.h.

fnv1a_hash_extend() [1/3]

uint32_t esphome::fnv1a_hash_extend ( uint32_t hash, const char * str )

constexpr

Extend a FNV-1a hash with additional string data.

Definition at line 811 of file helpers.h.

fnv1a_hash_extend() [2/3]

uint32_t esphome::fnv1a_hash_extend ( uint32_t hash, const std::string & str )

inline

Definition at line 820 of file helpers.h.

fnv1a_hash_extend() [3/3]

template<std::integral T>

uint32_t esphome::fnv1a_hash_extend ( uint32_t hash, T value )

constexpr

Extend a FNV-1a hash with an integer (hashes each byte).

Definition at line 824 of file helpers.h.

force_link_symbols()

void esphome::force_link_symbols

(

)

Definition at line 13 of file core.cpp.

format_bin() [1/2]

std::string esphome::format_bin	(	const uint8_t *	data,
		size_t	length )

Format the byte array data of length len in binary.

Warning

Allocates heap memory. Use format_bin_to() with a stack buffer instead.

Definition at line 207 of file alloc_helpers.cpp.

format_bin() [2/2]

template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>

std::string esphome::format_bin

(

T

val

)

Format an unsigned integer in binary, starting with the most significant byte.

Warning

Allocates heap memory. Use format_bin_to() with a stack buffer instead.

Definition at line 1545 of file helpers.h.

format_bin_size()

size_t esphome::format_bin_size ( size_t byte_count )

constexpr

Calculate buffer size needed for format_bin_to: "01234567...\0" = bytes * 8 + 1.

Definition at line 1489 of file helpers.h.

format_bin_to() [1/3]

char * esphome::format_bin_to	(	char *	buffer,
		size_t	buffer_size,
		const uint8_t *	data,
		size_t	length )

Format byte array as binary string to buffer.

Each byte is formatted as 8 binary digits (MSB first). Truncates output if data exceeds buffer capacity.

Parameters

buffer	Output buffer to write to.
buffer_size	Size of the output buffer.
data	Pointer to the byte array to format.
length	Number of bytes in the array.

Returns

Pointer to buffer.

Buffer size needed: length * 8 + 1 (use format_bin_size()).

Example:

char buf[9];  // format_bin_size(1)
format_bin_to(buf, sizeof(buf), data, 1);  // "10101011"

Definition at line 378 of file helpers.cpp.

format_bin_to() [2/3]

template<size_t N>

char * esphome::format_bin_to ( char(&) buffer[N], const uint8_t * data, size_t length )

inline

Format byte array as binary to buffer. Automatically deduces buffer size.

Definition at line 1513 of file helpers.h.

format_bin_to() [3/3]

template<size_t N, typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>

char * esphome::format_bin_to ( char(&) buffer[N], T val )

inline

Format an unsigned integer in binary to buffer, MSB first.

Template Parameters

N	Buffer size (must be >= sizeof(T) * 8 + 1).
T	Unsigned integer type.

Parameters

buffer	Output buffer to write to.
val	The unsigned integer value to format.

Returns

Pointer to buffer.

Example:

char buf[9];  // format_bin_size(sizeof(uint8_t))
format_bin_to(buf, uint8_t{0xAA});  // "10101010"
char buf16[17];  // format_bin_size(sizeof(uint16_t))
format_bin_to(buf16, uint16_t{0x1234});  // "0001001000110100"

Definition at line 1535 of file helpers.h.

format_hex() [1/4]

template<std::size_t N>

std::string esphome::format_hex

(

const std::array< uint8_t, N > &

data

)

Format the std::array data in lowercased hex.

Warning

Allocates heap memory. Use format_hex_to() with a stack buffer instead.

Definition at line 1473 of file helpers.h.

format_hex() [2/4]

std::string esphome::format_hex

(

const std::vector< uint8_t > &

data

)

Format the vector data in lowercased hex.

Warning

Allocates heap memory. Use format_hex_to() with a stack buffer instead.

Definition at line 167 of file alloc_helpers.cpp.

format_hex() [3/4]

std::string esphome::format_hex	(	const uint8_t *	data,
		size_t	length )

Format the byte array data of length len in lowercased hex.

Warning

Allocates heap memory. Use format_hex_to() with a stack buffer instead.

Definition at line 160 of file alloc_helpers.cpp.

format_hex() [4/4]

template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>

std::string esphome::format_hex

(

T

val

)

Format an unsigned integer in lowercased hex, starting with the most significant byte.

Warning

Allocates heap memory. Use format_hex_to() with a stack buffer instead.

Definition at line 1467 of file helpers.h.

format_hex_char() [1/2]

ESPHOME_ALWAYS_INLINE char esphome::format_hex_char ( uint8_t v )

inline

Convert a nibble (0-15) to lowercase hex char.

Definition at line 1252 of file helpers.h.

format_hex_char() [2/2]

ESPHOME_ALWAYS_INLINE char esphome::format_hex_char ( uint8_t v, char base )

inline

Convert a nibble (0-15) to hex char with specified base ('a' for lowercase, 'A' for uppercase)

Definition at line 1249 of file helpers.h.

format_hex_prefixed_size()

size_t esphome::format_hex_prefixed_size ( size_t byte_count )

constexpr

Calculate buffer size needed for format_hex_prefixed_to: "0xXXXXXXXX...\0" = bytes * 2 + 3.

Definition at line 1363 of file helpers.h.

format_hex_prefixed_to() [1/2]

template<size_t N>

char * esphome::format_hex_prefixed_to ( char(&) buffer[N], const uint8_t * data, size_t length )

inline

Format byte array as "0x" prefixed lowercase hex to buffer.

Definition at line 1377 of file helpers.h.

format_hex_prefixed_to() [2/2]

template<size_t N, typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>

char * esphome::format_hex_prefixed_to ( char(&) buffer[N], T val )

inline

Format an unsigned integer as "0x" prefixed lowercase hex to buffer.

Definition at line 1367 of file helpers.h.

format_hex_pretty() [1/6]

std::string esphome::format_hex_pretty	(	const std::string &	data,
		char	separator = '.',
		bool	show_length = true )

Format a string's bytes in pretty-printed, human-readable hex format.

Warning

Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.

Definition at line 203 of file alloc_helpers.cpp.

format_hex_pretty() [2/6]

std::string esphome::format_hex_pretty	(	const std::vector< uint16_t > &	data,
		char	separator = '.',
		bool	show_length = true )

Format a 16-bit word vector in pretty-printed, human-readable hex format.

Warning

Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.

Definition at line 200 of file alloc_helpers.cpp.

format_hex_pretty() [3/6]

std::string esphome::format_hex_pretty	(	const std::vector< uint8_t > &	data,
		char	separator = '.',
		bool	show_length = true )

Format a byte vector in pretty-printed, human-readable hex format.

Warning

Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.

Definition at line 185 of file alloc_helpers.cpp.

format_hex_pretty() [4/6]

std::string esphome::format_hex_pretty	(	const uint16_t *	data,
		size_t	length,
		char	separator = '.',
		bool	show_length = true )

Format a 16-bit word array in pretty-printed, human-readable hex format.

Warning

Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.

Definition at line 189 of file alloc_helpers.cpp.

format_hex_pretty() [5/6]

std::string esphome::format_hex_pretty	(	const uint8_t *	data,
		size_t	length,
		char	separator = '.',
		bool	show_length = true )

Format a byte array in pretty-printed, human-readable hex format.

Warning

Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.

Definition at line 182 of file alloc_helpers.cpp.

format_hex_pretty() [6/6]

template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>

std::string esphome::format_hex_pretty	(	T	val,
		char	separator = '.',
		bool	show_length = true )

Format an unsigned integer in pretty-printed, human-readable hex format.

Warning

Allocates heap memory. Use format_hex_pretty_to() with a stack buffer instead.

Definition at line 1483 of file helpers.h.

format_hex_pretty_char()

ESPHOME_ALWAYS_INLINE char esphome::format_hex_pretty_char ( uint8_t v )

inline

Convert a nibble (0-15) to uppercase hex char (used for pretty printing)

Definition at line 1255 of file helpers.h.

format_hex_pretty_size()

size_t esphome::format_hex_pretty_size ( size_t byte_count )

constexpr

Calculate buffer size needed for format_hex_pretty_to with separator: "XX:XX:...:XX\0".

Definition at line 1386 of file helpers.h.

format_hex_pretty_to() [1/6]

char * esphome::format_hex_pretty_to	(	char *	buffer,
		size_t	buffer_size,
		const uint16_t *	data,
		size_t	length,
		char	separator = ':' )

Format uint16_t array as uppercase hex with separator to pre-allocated buffer.

Each uint16_t is formatted as 4 hex chars in big-endian order.

Parameters

buffer	Output buffer to write to.
buffer_size	Size of the output buffer.
data	Pointer to uint16_t array.
length	Number of uint16_t values.
separator	Character to use between values, or '\0' for no separator.

Returns

Pointer to buffer.

Buffer size needed: length * 5 with separator (for "XXXX:XXXX\0"), length * 4 + 1 without.

Definition at line 345 of file helpers.cpp.

format_hex_pretty_to() [2/6]

char * esphome::format_hex_pretty_to	(	char *	buffer,
		size_t	buffer_size,
		const uint8_t *	data,
		size_t	length,
		char	separator = ':' )

Format byte array as uppercase hex to buffer (base implementation).

Parameters

buffer	Output buffer to write to.
buffer_size	Size of the output buffer.
data	Pointer to the byte array to format.
length	Number of bytes in the array.
separator	Character to use between hex bytes, or '\0' for no separator.

Returns

Pointer to buffer.

Buffer size needed: length * 3 with separator (for "XX:XX:XX\0"), length * 2 + 1 without.

Definition at line 341 of file helpers.cpp.

format_hex_pretty_to() [3/6]

template<size_t N, size_t M>

char * esphome::format_hex_pretty_to ( char(&) buffer[N], const std::array< uint8_t, M > & data, char separator = ':' )

inline

Format std::array<uint8_t, M> as uppercase hex with separator to buffer.

Definition at line 1416 of file helpers.h.

format_hex_pretty_to() [4/6]

template<size_t N>

char * esphome::format_hex_pretty_to ( char(&) buffer[N], const std::vector< uint8_t > & data, char separator = ':' )

inline

Format std::vector<uint8_t> as uppercase hex with separator to buffer.

Definition at line 1410 of file helpers.h.

format_hex_pretty_to() [5/6]

template<size_t N>

char * esphome::format_hex_pretty_to ( char(&) buffer[N], const uint16_t * data, size_t length, char separator = ':' )

inline

Format uint16_t array as uppercase hex with separator to buffer. Automatically deduces buffer size.

Definition at line 1440 of file helpers.h.

format_hex_pretty_to() [6/6]

template<size_t N>

char * esphome::format_hex_pretty_to ( char(&) buffer[N], const uint8_t * data, size_t length, char separator = ':' )

inline

Format byte array as uppercase hex with separator to buffer. Automatically deduces buffer size.

Definition at line 1403 of file helpers.h.

format_hex_pretty_uint16_size()

size_t esphome::format_hex_pretty_uint16_size ( size_t count )

constexpr

Calculate buffer size needed for format_hex_pretty_to with uint16_t data: "XXXX:XXXX:...:XXXX\0".

Definition at line 1421 of file helpers.h.

format_hex_size()

size_t esphome::format_hex_size ( size_t byte_count )

constexpr

Calculate buffer size needed for format_hex_to: "XXXXXXXX...\0" = bytes * 2 + 1.

Definition at line 1360 of file helpers.h.

format_hex_to() [1/5]

char * esphome::format_hex_to	(	char *	buffer,
		size_t	buffer_size,
		const uint8_t *	data,
		size_t	length )

Format byte array as lowercase hex to buffer (base implementation).

Definition at line 335 of file helpers.cpp.

format_hex_to() [2/5]

template<size_t N, size_t M>

char * esphome::format_hex_to ( char(&) buffer[N], const std::array< uint8_t, M > & data )

inline

Format std::array<uint8_t, M> as lowercase hex to buffer.

Definition at line 1355 of file helpers.h.

format_hex_to() [3/5]

template<size_t N>

char * esphome::format_hex_to ( char(&) buffer[N], const std::vector< uint8_t > & data )

inline

Format std::vector<uint8_t> as lowercase hex to buffer.

Definition at line 1350 of file helpers.h.

format_hex_to() [4/5]

template<size_t N>

char * esphome::format_hex_to ( char(&) buffer[N], const uint8_t * data, size_t length )

inline

Format byte array as lowercase hex to buffer.

Automatically deduces buffer size. Truncates output if data exceeds buffer capacity. Returns pointer to buffer.

Definition at line 1336 of file helpers.h.

format_hex_to() [5/5]

template<size_t N, typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>

char * esphome::format_hex_to ( char(&) buffer[N], T val )

inline

Format an unsigned integer in lowercased hex to buffer, starting with the most significant byte.

Definition at line 1343 of file helpers.h.

format_mac_addr_lower_no_sep()

void esphome::format_mac_addr_lower_no_sep ( const uint8_t * mac, char * output )

inline

Format MAC address as xxxxxxxxxxxxxx (lowercase, no separators)

Definition at line 1458 of file helpers.h.

format_mac_addr_upper()

char * esphome::format_mac_addr_upper ( const uint8_t * mac, char * output )

inline

Format MAC address as XX:XX:XX:XX:XX:XX (uppercase, colon separators)

Definition at line 1453 of file helpers.h.

format_mac_address_pretty() [1/2]

std::string esphome::format_mac_address_pretty

(

const uint8_t *

mac

)

Definition at line 154 of file alloc_helpers.cpp.

format_mac_address_pretty() [2/2]

std::string size_t std::string std::string esphome::format_mac_address_pretty

(

const uint8_t

mac[6]

)

Format the six-byte array mac into a MAC address string.

Warning

Allocates heap memory. Use format_mac_addr_upper() with a stack buffer instead.

frac_to_str_unchecked()

char * esphome::frac_to_str_unchecked ( char * buf, uint32_t frac, uint32_t divisor )

inline

Write fractional digits with leading zeros to buffer (internal, no size check).

frac is the fractional value, divisor is the highest place value (e.g. 100 for 3 digits). Returns pointer past last char written.

Definition at line 1322 of file helpers.h.

gamma_correct()

float esphome::gamma_correct	(	float	value,
		float	gamma )

Definition at line 648 of file helpers.cpp.

gamma_uncorrect()

float esphome::gamma_uncorrect	(	float	value,
		float	gamma )

Definition at line 656 of file helpers.cpp.

get_mac_address()

std::string esphome::get_mac_address

(

)

Get the device MAC address as a string, in lowercase hex notation.

Warning

Allocates heap memory. Use get_mac_address_into_buffer() instead.

Definition at line 216 of file alloc_helpers.cpp.

get_mac_address_into_buffer()

void esphome::get_mac_address_into_buffer

(

std::span< char, MAC_ADDRESS_BUFFER_SIZE >

buf

)

Get the device MAC address into the given buffer, in lowercase hex notation.

Assumes buffer length is MAC_ADDRESS_BUFFER_SIZE (12 digits for hexadecimal representation followed by null terminator).

Definition at line 745 of file helpers.cpp.

get_mac_address_pretty()

std::string esphome::get_mac_address_pretty

(

)

Get the device MAC address as a string, in colon-separated uppercase hex notation.

Warning

Allocates heap memory. Use get_mac_address_pretty_into_buffer() instead.

Definition at line 224 of file alloc_helpers.cpp.

get_mac_address_pretty_into_buffer()

const char * esphome::get_mac_address_pretty_into_buffer

(

std::span< char, MAC_ADDRESS_PRETTY_BUFFER_SIZE >

buf

)

Get the device MAC address into the given buffer, in colon-separated uppercase hex notation.

Buffer must be exactly MAC_ADDRESS_PRETTY_BUFFER_SIZE bytes (17 for "XX:XX:XX:XX:XX:XX" + null terminator). Returns pointer to the buffer for convenience.

Definition at line 751 of file helpers.cpp.

get_mac_address_raw()

void esphome::get_mac_address_raw

(

uint8_t *

mac

)

Get the device MAC address as raw bytes, written into the provided byte array (6 bytes).

Definition at line 74 of file helpers.cpp.

has_custom_mac_address()

bool esphome::has_custom_mac_address

(

)

Check if a custom MAC address is set (ESP32 & variants)

Returns

True if a custom MAC address is set (ESP32 & variants), else false

Definition at line 110 of file helpers.cpp.

hsv_to_rgb()

void esphome::hsv_to_rgb	(	int	hue,
		float	saturation,
		float	value,
		float &	red,
		float &	green,
		float &	blue )

Convert hue (0-360), saturation (0-1) and value (0-1) to red, green and blue (all 0-1).

Definition at line 688 of file helpers.cpp.

id() [1/2]

template<typename T , enable_if_t< std::is_pointer< T * >::value, int > = 0>

T & esphome::id

(

T *

value

)

Helper function to make id(var) known from lambdas work in custom components.

This function is not called from lambdas, the code generator replaces calls to it with the appropriate variable.

Definition at line 2209 of file helpers.h.

id() [2/2]

template<typename T , enable_if_t<!std::is_pointer< T >::value, int > = 0>

T esphome::id

(

T

value

)

Helper function to make id(var) known from lambdas work in custom components.

This function is not called from lambdas, the code generator replaces calls to it with the appropriate variable.

Definition at line 2204 of file helpers.h.

if() [1/2]

esphome::if

(

data

)

Definition at line 30 of file helpers.cpp.

if() [2/2]

esphome::if

(

)

Definition at line 1047 of file helpers.h.

ilog10()

int8_t esphome::ilog10

(

float

value

)

Compute floor(log10(fabs(value))) using iterative comparison.

Avoids pulling in __ieee754_logf/log10f (~1KB flash). Only valid for finite, non-zero values.

Definition at line 416 of file helpers.cpp.

increment_time_value()

template<typename T >

bool esphome::increment_time_value	(	T &	current,
		uint16_t	begin,
		uint16_t	end )

Definition at line 375 of file time.cpp.

init_array_from()

template<typename T , size_t N>

void esphome::init_array_from ( std::array< T, N > & dest, std::initializer_list< T > src )

inline

Initialize a std::array from an initializer_list.

Uses memcpy for trivially copyable types (optimal codegen), falls back to element-wise copy for non-trivially copyable types (e.g. TemplatableValue). N is always set by code generation — the caller is responsible for ensuring src.size() == N. The debug assert is a safety net for development, not a runtime check.

Definition at line 512 of file helpers.h.

int8_to_str()

char * esphome::int8_to_str ( char * buf, int8_t val )

inline

Write int8 value to buffer without modulo operations.

Buffer must have at least 4 bytes free. Returns pointer past last char written.

Definition at line 1259 of file helpers.h.

K_SEM_DEFINE()

esphome::K_SEM_DEFINE	(	esphome_wake_sem	,
		0	,
		1	)

lerp()

float esphome::lerp ( float completion, float start, float end )

inlinedelete

log_entity_device_class()

void esphome::log_entity_device_class	(	const char *	tag,
		const char *	prefix,
		const EntityBase &	obj )

Definition at line 228 of file entity_base.cpp.

log_entity_icon()

void esphome::log_entity_icon ( const char * tag, const char * prefix, const EntityBase & obj )

inline

Definition at line 219 of file entity_base.cpp.

log_entity_unit_of_measurement()

void esphome::log_entity_unit_of_measurement	(	const char *	tag,
		const char *	prefix,
		const EntityBase &	obj )

Definition at line 236 of file entity_base.cpp.

log_pin() [1/2]

void esphome::log_pin	(	const char *	tag,
		const __FlashStringHelper *	prefix,
		GPIOPin *	pin )

Definition at line 7 of file gpio.cpp.

log_pin() [2/2]

void esphome::log_pin	(	const char *	tag,
		const char *	prefix,
		GPIOPin *	pin )

Definition at line 17 of file gpio.cpp.

log_pin_with_prefix()

void esphome::log_pin_with_prefix ( const char * tag, const char * prefix, GPIOPin * pin )

inline

Definition at line 148 of file gpio.h.

log_update_interval()

void esphome::log_update_interval	(	const char *	tag,
		PollingComponent *	component )

Definition at line 444 of file component.cpp.

loop_task()

void esphome::loop_task

(

void *

pv_params

)

Definition at line 22 of file core.cpp.

mac_address_is_valid()

bool esphome::mac_address_is_valid

(

const uint8_t *

mac

)

Check if the MAC address is not all zeros or all ones.

Returns

True if MAC is valid, else false

Definition at line 762 of file helpers.cpp.

make_name_with_suffix() [1/2]

std::string esphome::make_name_with_suffix	(	const char *	name,
		size_t	name_len,
		char	sep,
		const char *	suffix_ptr,
		size_t	suffix_len )

Optimized string concatenation: name + separator + suffix (const char* overload) Uses a fixed stack buffer to avoid heap allocations.

Parameters

name	The base name string
name_len	Length of the name
sep	Single character separator
suffix_ptr	Pointer to the suffix characters
suffix_len	Length of the suffix

Returns

The concatenated string: name + sep + suffix

Definition at line 262 of file helpers.cpp.

make_name_with_suffix() [2/2]

std::string esphome::make_name_with_suffix	(	const std::string &	name,
		char	sep,
		const char *	suffix_ptr,
		size_t	suffix_len )

Concatenate a name with a separator and suffix using an efficient stack-based approach.

This avoids multiple heap allocations during string construction. Maximum name length supported is 120 characters for friendly names.

Parameters

name	The base name string
sep	The separator character (e.g., '-', ' ', or '.')
suffix_ptr	Pointer to the suffix characters
suffix_len	Length of the suffix

Returns

The concatenated string: name + sep + suffix

Definition at line 269 of file helpers.cpp.

make_name_with_suffix_to()

size_t esphome::make_name_with_suffix_to	(	char *	buffer,
		size_t	buffer_size,
		const char *	name,
		size_t	name_len,
		char	sep,
		const char *	suffix_ptr,
		size_t	suffix_len )

Zero-allocation version: format name + separator + suffix directly into buffer.

Parameters

buffer	Output buffer (must have space for result + null terminator)
buffer_size	Size of the output buffer
name	The base name string
name_len	Length of the name
sep	Single character separator
suffix_ptr	Pointer to the suffix characters
suffix_len	Length of the suffix

Returns

Length written (excluding null terminator)

Definition at line 242 of file helpers.cpp.

micros()

uint32_t esphome::micros

(

)

Definition at line 43 of file hal.cpp.

millis()

uint32_t esphome::millis

(

)

Definition at line 28 of file hal.cpp.

millis_64()

uint64_t esphome::millis_64

(

)

Definition at line 29 of file hal.cpp.

mqtt_is_connected()

bool esphome::mqtt_is_connected

(

)

Return whether the node has an active connection to an MQTT broker.

Definition at line 12 of file util.cpp.

operator!=() [1/7]

bool esphome::operator!= ( const __FlashStringHelper * lhs, const StringRef & rhs )

inline

Definition at line 178 of file string_ref.h.

operator!=() [2/7]

bool esphome::operator!= ( const char * lhs, const StringRef & rhs )

inline

Definition at line 162 of file string_ref.h.

operator!=() [3/7]

bool esphome::operator!= ( const std::string & lhs, const StringRef & rhs )

inline

Definition at line 158 of file string_ref.h.

operator!=() [4/7]

bool esphome::operator!= ( const StringRef & lhs, const __FlashStringHelper * rhs )

inline

Definition at line 176 of file string_ref.h.

operator!=() [5/7]

bool esphome::operator!= ( const StringRef & lhs, const char * rhs )

inline

Definition at line 160 of file string_ref.h.

operator!=() [6/7]

bool esphome::operator!= ( const StringRef & lhs, const std::string & rhs )

inline

Definition at line 156 of file string_ref.h.

operator!=() [7/7]

bool esphome::operator!= ( const StringRef & lhs, const StringRef & rhs )

inline

Definition at line 154 of file string_ref.h.

operator+() [1/4]

std::string esphome::operator+ ( const char * lhs, const StringRef & rhs )

inline

Definition at line 190 of file string_ref.h.

operator+() [2/4]

std::string esphome::operator+ ( const std::string & lhs, const StringRef & rhs )

inline

Definition at line 208 of file string_ref.h.

operator+() [3/4]

std::string esphome::operator+ ( const StringRef & lhs, const char * rhs )

inline

Definition at line 196 of file string_ref.h.

operator+() [4/4]

std::string esphome::operator+ ( const StringRef & lhs, const std::string & rhs )

inline

Definition at line 202 of file string_ref.h.

operator+=()

std::string & esphome::operator+= ( std::string & lhs, const StringRef & rhs )

inline

Definition at line 185 of file string_ref.h.

operator<()

bool esphome::operator< ( const StringRef & lhs, const StringRef & rhs )

inline

Definition at line 181 of file string_ref.h.

operator==() [1/7]

bool esphome::operator== ( const __FlashStringHelper * lhs, const StringRef & rhs )

inline

Definition at line 174 of file string_ref.h.

operator==() [2/7]

bool esphome::operator== ( const char * lhs, const StringRef & rhs )

inline

Definition at line 152 of file string_ref.h.

operator==() [3/7]

bool esphome::operator== ( const std::string & lhs, const StringRef & rhs )

inline

Definition at line 146 of file string_ref.h.

operator==() [4/7]

bool esphome::operator== ( const StringRef & lhs, const __FlashStringHelper * rhs )

inline

Definition at line 165 of file string_ref.h.

operator==() [5/7]

bool esphome::operator== ( const StringRef & lhs, const char * rhs )

inline

Definition at line 148 of file string_ref.h.

operator==() [6/7]

bool esphome::operator== ( const StringRef & lhs, const std::string & rhs )

inline

Definition at line 142 of file string_ref.h.

operator==() [7/7]

bool esphome::operator== ( const StringRef & lhs, const StringRef & rhs )

inline

Definition at line 138 of file string_ref.h.

parse_hex() [1/8]

template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>

optional< T > esphome::parse_hex

(

const char *

str

)

Parse a hex-encoded null-terminated string (starting with the most significant byte) into an unsigned integer.

Definition at line 1226 of file helpers.h.

parse_hex() [2/8]

template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>

optional< T > esphome::parse_hex	(	const char *	str,
		size_t	len )

Parse a hex-encoded string into an unsigned integer.

Parameters

str	String to read from, starting with the most significant byte.
len	Length of str (excluding optional null-terminator), is a limit on the number of characters parsed.

Definition at line 1219 of file helpers.h.

parse_hex() [3/8]

size_t esphome::parse_hex	(	const char *	str,
		size_t	len,
		uint8_t *	data,
		size_t	count )

Parse bytes from a hex-encoded string into a byte array.

When len is less than 2*count, the result is written to the back of data (i.e. this function treats str as if it were padded with zeros at the front).

Parameters

str	String to read from.
len	Length of str (excluding optional null-terminator), is a limit on the number of characters parsed.
data	Byte array to write to.
count	Length of data.

Returns

The number of characters parsed from str.

Definition at line 275 of file helpers.cpp.

parse_hex() [4/8]

bool esphome::parse_hex ( const char * str, std::vector< uint8_t > & data, size_t count )

inline

Parse count bytes from the hex-encoded string str of at least 2*count characters into vector data.

Definition at line 1204 of file helpers.h.

parse_hex() [5/8]

bool esphome::parse_hex ( const char * str, uint8_t * data, size_t count )

inline

Parse count bytes from the hex-encoded string str of at least 2*count characters into array data.

Definition at line 1196 of file helpers.h.

parse_hex() [6/8]

template<typename T , enable_if_t< std::is_unsigned< T >::value, int > = 0>

optional< T > esphome::parse_hex

(

const std::string &

str

)

Parse a hex-encoded null-terminated string (starting with the most significant byte) into an unsigned integer.

Definition at line 1230 of file helpers.h.

parse_hex() [7/8]

bool esphome::parse_hex ( const std::string & str, std::vector< uint8_t > & data, size_t count )

inline

Parse count bytes from the hex-encoded string str of at least 2*count characters into vector data.

Definition at line 1209 of file helpers.h.

parse_hex() [8/8]

bool esphome::parse_hex ( const std::string & str, uint8_t * data, size_t count )

inline

Parse count bytes from the hex-encoded string str of at least 2*count characters into array data.

Definition at line 1200 of file helpers.h.

parse_hex_char()

uint8_t esphome::parse_hex_char ( char c )

constexpr

Definition at line 1238 of file helpers.h.

parse_number() [1/2]

template<typename T , enable_if_t<(std::is_integral< T >::value &&std::is_unsigned< T >::value), int > = 0>

optional< T > esphome::parse_number

(

const char *

str

)

Parse an unsigned decimal number from a null-terminated string.

Parse a decimal floating-point number from a null-terminated string.

Parse a signed decimal number from a null-terminated string.

Definition at line 1143 of file helpers.h.

parse_number() [2/2]

template<typename T , enable_if_t<(std::is_integral< T >::value &&std::is_unsigned< T >::value), int > = 0>

optional< T > esphome::parse_number

(

const std::string &

str

)

Parse an unsigned decimal number.

Parse a decimal floating-point number.

Parse a signed decimal number.

Definition at line 1152 of file helpers.h.

parse_on_off()

ParseOnOffState esphome::parse_on_off	(	const char *	str,
		const char *	on,
		const char *	off )

Parse a string that contains either on, off or toggle.

Definition at line 401 of file helpers.cpp.

pow10_int()

float esphome::pow10_int ( int8_t exp )

inline

Compute 10^exp using iterative multiplication/division.

Avoids pulling in powf/__ieee754_powf (~2.3KB flash) for small integer exponents. // NOLINT Matches powf(10, exp) for the int8_t exponent range used by sensor accuracy_decimals. // NOLINT

Definition at line 752 of file helpers.h.

progmem_read_byte()

uint8_t esphome::progmem_read_byte ( const uint8_t * addr )

inline

Definition at line 42 of file hal.h.

progmem_read_ptr()

const char * esphome::progmem_read_ptr ( const char *const * addr )

inline

Definition at line 43 of file hal.h.

progmem_read_uint16()

uint16_t esphome::progmem_read_uint16 ( const uint16_t * addr )

inline

Definition at line 44 of file hal.h.

random_bytes()

bool esphome::random_bytes	(	uint8_t *	data,
		size_t	len )

Generate len random bytes using the platform's secure RNG (hardware RNG or OS CSPRNG).

Thread-safe. Suitable for cryptographic use.

Definition at line 20 of file helpers.cpp.

random_float()

float esphome::random_float

(

)

Return a random float between 0 and 1.

Not thread-safe. Must only be called from the main loop. Not suitable for cryptographic use; use random_bytes() instead.

Definition at line 198 of file helpers.cpp.

random_uint32()

uint32_t esphome::random_uint32

(

)

Return a random 32-bit unsigned integer.

Not thread-safe. Must only be called from the main loop. Not suitable for cryptographic use; use random_bytes() instead.

Definition at line 12 of file helpers.cpp.

remap()

template<typename T , typename U >

T esphome::remap	(	U	value,
		U	min,
		U	max,
		T	min_out,
		T	max_out )

Remap value from the range (min, max) to (min_out, max_out).

Definition at line 765 of file helpers.h.

remote_is_connected()

bool esphome::remote_is_connected

(

)

Return whether the node has any form of "remote" connection via the API or to an MQTT broker.

Definition at line 21 of file util.cpp.

resetPins()

void esphome::resetPins

(

)

Definition at line 27 of file core.cpp.

retry_handler()

void esphome::retry_handler

(

const std::shared_ptr< RetryArgs > &

args

)

Definition at line 336 of file scheduler.cpp.

reverse_bits() [1/3]

uint16_t esphome::reverse_bits ( uint16_t x )

inline

Reverse the order of 16 bits.

Definition at line 905 of file helpers.h.

reverse_bits() [2/3]

uint32_t esphome::reverse_bits ( uint32_t x )

inline

Reverse the order of 32 bits.

Definition at line 909 of file helpers.h.

reverse_bits() [3/3]

uint8_t esphome::reverse_bits ( uint8_t x )

inline

Reverse the order of 8 bits.

Definition at line 898 of file helpers.h.

rgb_to_hsv()

void esphome::rgb_to_hsv	(	float	red,
		float	green,
		float	blue,
		int &	hue,
		float &	saturation,
		float &	value )

Convert red, green and blue (all 0-1) values to hue (0-360), saturation (0-1) and value (0-1).

Definition at line 665 of file helpers.cpp.

set_mac_address()

void esphome::set_mac_address

(

uint8_t *

mac

)

Set the MAC address to use from the provided byte array (6 bytes).

Definition at line 108 of file helpers.cpp.

small_pow10()

uint32_t esphome::small_pow10 ( int8_t n )

inline

Return 10^n for small non-negative n (0-3) as uint32_t, avoiding float.

Definition at line 1302 of file helpers.h.

step_to_accuracy_decimals()

int8_t esphome::step_to_accuracy_decimals

(

float

step

)

Derive accuracy in decimals from an increment step.

Definition at line 504 of file helpers.cpp.

stod()

double esphome::stod ( const StringRef & str, size_t * pos = nullptr )

inline

Definition at line 245 of file string_ref.h.

stof()

float esphome::stof ( const StringRef & str, size_t * pos = nullptr )

inline

Definition at line 242 of file string_ref.h.

stoi()

int esphome::stoi ( const StringRef & str, size_t * pos = nullptr, int base = 10 )

inline

Definition at line 236 of file string_ref.h.

stol()

long esphome::stol ( const StringRef & str, size_t * pos = nullptr, int base = 10 )

inline

Definition at line 239 of file string_ref.h.

str_ctype_transform()

template<int(*)(int) fn>

std::string esphome::str_ctype_transform

(

const std::string &

str

)

Definition at line 28 of file alloc_helpers.cpp.

str_endswith()

bool esphome::str_endswith	(	const std::string &	str,
		const std::string &	end )

Check whether a string ends with a value.

Definition at line 210 of file helpers.cpp.

str_endswith_ignore_case() [1/3]

bool esphome::str_endswith_ignore_case ( const char * str, const char * suffix )

inline

Definition at line 953 of file helpers.h.

str_endswith_ignore_case() [2/3]

bool esphome::str_endswith_ignore_case	(	const char *	str,
		size_t	str_len,
		const char *	suffix,
		size_t	suffix_len )

Case-insensitive check if string ends with suffix (no heap allocation).

Definition at line 218 of file helpers.cpp.

str_endswith_ignore_case() [3/3]

bool esphome::str_endswith_ignore_case ( const std::string & str, const char * suffix )

inline

Definition at line 956 of file helpers.h.

str_equals_case_insensitive() [1/5]

bool esphome::str_equals_case_insensitive ( const char * a, const char * b )

inline

Compare C strings for equality in case-insensitive manner (no heap allocation).

Definition at line 942 of file helpers.h.

str_equals_case_insensitive() [2/5]

bool esphome::str_equals_case_insensitive ( const char * a, const std::string & b )

inline

Definition at line 944 of file helpers.h.

str_equals_case_insensitive() [3/5]

bool esphome::str_equals_case_insensitive ( const std::string & a, const char * b )

inline

Definition at line 943 of file helpers.h.

str_equals_case_insensitive() [4/5]

bool esphome::str_equals_case_insensitive	(	const std::string &	a,
		const std::string &	b )

Compare strings for equality in case-insensitive manner.

Definition at line 202 of file helpers.cpp.

str_equals_case_insensitive() [5/5]

bool esphome::str_equals_case_insensitive	(	StringRef	a,
		StringRef	b )

Compare StringRefs for equality in case-insensitive manner.

Definition at line 205 of file helpers.cpp.

str_lower_case()

std::string esphome::str_lower_case

(

const std::string &

str

)

Convert the string to lower case.

Warning

Allocates heap memory. Avoid in new code - causes heap fragmentation on long-running devices.

Definition at line 34 of file alloc_helpers.cpp.

str_sanitize()

std::string esphome::str_sanitize

(

const std::string &

str

)

Sanitizes the input string by removing all characters but alphanumerics, dashes and underscores.

Warning

Allocates heap memory. Use str_sanitize_to() with a stack buffer instead.

Definition at line 51 of file alloc_helpers.cpp.

str_sanitize_to() [1/2]

char * esphome::str_sanitize_to	(	char *	buffer,
		size_t	buffer_size,
		const char *	str )

Sanitize a string to buffer, keeping only alphanumerics, dashes, and underscores.

Parameters

buffer	Output buffer to write to.
buffer_size	Size of the output buffer.
str	Input string to sanitize.

Returns

Pointer to buffer.

Buffer size needed: strlen(str) + 1.

Definition at line 225 of file helpers.cpp.

str_sanitize_to() [2/2]

template<size_t N>

char * esphome::str_sanitize_to ( char(&) buffer[N], const char * str )

inline

Sanitize a string to buffer. Automatically deduces buffer size.

Definition at line 985 of file helpers.h.

str_snake_case()

std::string esphome::str_snake_case

(

const std::string &

str

)

Convert the string to snake case (lowercase with underscores).

Warning

Allocates heap memory. Avoid in new code - causes heap fragmentation on long-running devices.

Definition at line 43 of file alloc_helpers.cpp.

str_snprintf()

std::string esphome::str_snprintf	(	const char *	fmt,
		size_t	len,
			... )

Definition at line 58 of file alloc_helpers.cpp.

str_sprintf()

std::string esphome::str_sprintf	(	const char *	fmt,
			... )

Definition at line 73 of file alloc_helpers.cpp.

str_startswith()

bool esphome::str_startswith	(	const std::string &	str,
		const std::string &	start )

Check whether a string starts with a value.

Definition at line 209 of file helpers.cpp.

str_truncate()

std::string esphome::str_truncate	(	const std::string &	str,
		size_t	length )

Truncate a string to a specific length.

Warning

Allocates heap memory. Avoid in new code - causes heap fragmentation on long-running devices.

Definition at line 16 of file alloc_helpers.cpp.

str_until() [1/2]

std::string esphome::str_until	(	const char *	str,
		char	ch )

Extract the part of the string until either the first occurrence of the specified character, or the end (requires str to be null-terminated).

Warning

Allocates heap memory. Avoid in new code - causes heap fragmentation on long-running devices.

Definition at line 20 of file alloc_helpers.cpp.

str_until() [2/2]

std::string esphome::str_until	(	const std::string &	str,
		char	ch )

Extract the part of the string until either the first occurrence of the specified character, or the end.

Warning

Allocates heap memory. Avoid in new code - causes heap fragmentation on long-running devices.

Definition at line 24 of file alloc_helpers.cpp.

str_upper_case()

std::string esphome::str_upper_case

(

const std::string &

str

)

Convert the string to upper case.

Warning

Allocates heap memory. Avoid in new code - causes heap fragmentation on long-running devices.

Definition at line 36 of file alloc_helpers.cpp.

to_sanitized_char()

char esphome::to_sanitized_char ( char c )

constexpr

Sanitize a single char: keep alphanumerics, dashes, underscores; replace others with underscore.

Definition at line 969 of file helpers.h.

to_snake_case_char()

char esphome::to_snake_case_char ( char c )

constexpr

Convert a single char to snake_case: lowercase and space to underscore.

Definition at line 965 of file helpers.h.

uint32_to_str()

size_t esphome::uint32_to_str ( std::span< char, UINT32_MAX_STR_SIZE > buf, uint32_t val )

inline

Write unsigned 32-bit integer to buffer with compile-time size check.

Null-terminates the output. Returns number of chars written (excluding null).

Definition at line 1313 of file helpers.h.

uint32_to_str_unchecked()

char * esphome::uint32_to_str_unchecked	(	char *	buf,
		uint32_t	val )

Write unsigned 32-bit integer to buffer (internal, no size check).

Buffer must have at least 10 bytes free. Returns pointer past last char written.

Definition at line 321 of file helpers.cpp.

va_end()

esphome::va_end

(

args

)

va_start()

size_t size_t const char esphome::va_start	(	args	,
		fmt	)

value_accuracy_to_buf()

size_t esphome::value_accuracy_to_buf	(	std::span< char, VALUE_ACCURACY_MAX_LEN >	buf,
		float	value,
		int8_t	accuracy_decimals )

Format value with accuracy to buffer, returns chars written (excluding null)

Definition at line 474 of file helpers.cpp.

value_accuracy_to_string()

std::string esphome::value_accuracy_to_string	(	float	value,
		int8_t	accuracy_decimals )

Definition at line 91 of file alloc_helpers.cpp.

value_accuracy_with_uom_to_buf()

size_t esphome::value_accuracy_with_uom_to_buf	(	std::span< char, VALUE_ACCURACY_MAX_LEN >	buf,
		float	value,
		int8_t	accuracy_decimals,
		StringRef	unit_of_measurement )

Format value with accuracy and UOM to buffer, returns chars written (excluding null)

Definition at line 493 of file helpers.cpp.

wake_drain_notifications()

void ESPHOME_ALWAYS_INLINE esphome::wake_drain_notifications ( )

inline

Definition at line 48 of file wake_host.h.

wake_fd_ready()

bool ESPHOME_ALWAYS_INLINE esphome::wake_fd_ready ( int fd )

inline

Definition at line 42 of file wake_host.h.

wake_loop_any_context()

void esphome::wake_loop_any_context ( )

inline

IRAM_ATTR entry point for ISR callers — defined in wake_esp8266.cpp.

Definition at line 17 of file wake_esp8266.cpp.

wake_loop_impl()

void ESPHOME_ALWAYS_INLINE esphome::wake_loop_impl ( )

inline

Inline implementation — IRAM callers inline this directly.

Definition at line 14 of file wake_esp8266.h.

wake_loop_isrsafe() [1/2]

void esphome::wake_loop_isrsafe ( )

inline

ISR-safe: no task_woken arg because ESP8266 has no FreeRTOS. Caller must be IRAM_ATTR.

ISR-safe: no task_woken arg because Zephyr's k_sem_give() does its own ISR scheduling.

Forwards to wake_loop_threadsafe().

Definition at line 29 of file wake_esp8266.h.

wake_loop_isrsafe() [2/2]

void esphome::wake_loop_isrsafe

(

BaseType_t *

px_higher_priority_task_woken

)

IRAM_ATTR entry points — defined in wake_freertos.cpp.

Definition at line 21 of file wake_freertos.cpp.

wake_loop_threadsafe()

void esphome::wake_loop_threadsafe ( )

inline

Non-ISR: always inline.

Zephyr: wakes the main loop via k_sem_give().

Host: wakes select() via UDP loopback socket. Defined in wake_host.cpp.

Thread- and ISR-safe. Defined in wake_zephyr.cpp.

Definition at line 26 of file wake_esp8266.h.

wake_register_fd()

bool esphome::wake_register_fd

(

int

fd

)

Register a socket file descriptor with the host select() loop.

Not thread-safe — main loop only. Returns false if fd is invalid or >= FD_SETSIZE.

Definition at line 46 of file wake_host.cpp.

wake_setup()

void esphome::wake_setup

(

)

One-time setup of the loopback wake socket. Called from Application::setup().

Definition at line 151 of file wake_host.cpp.

wake_unregister_fd()

void esphome::wake_unregister_fd

(

int

fd

)

Unregister a socket file descriptor. Not thread-safe — main loop only.

Definition at line 65 of file wake_host.cpp.

Variable Documentation

App

Application esphome::App

extern

Global storage of Application pointer - only one Application can exist.

APP_STATE_SETUP_COMPLETE

uint8_t esphome::APP_STATE_SETUP_COMPLETE = 0x40

inlineconstexpr

Definition at line 96 of file component.h.

args

const char int const __FlashStringHelper va_list esphome::args

Definition at line 74 of file log.h.

capacity

esphome::capacity = new_cap

Definition at line 25 of file helpers.cpp.

COMPONENT_HAS_LOOP

uint8_t esphome::COMPONENT_HAS_LOOP = 0x20

inlineconstexpr

Definition at line 91 of file component.h.

COMPONENT_STATE_CONSTRUCTION

uint8_t esphome::COMPONENT_STATE_CONSTRUCTION = 0x00

inlineconstexpr

Definition at line 80 of file component.h.

COMPONENT_STATE_FAILED

uint8_t esphome::COMPONENT_STATE_FAILED = 0x03

inlineconstexpr

Definition at line 83 of file component.h.

COMPONENT_STATE_LOOP

uint8_t esphome::COMPONENT_STATE_LOOP = 0x02

inlineconstexpr

Definition at line 82 of file component.h.

COMPONENT_STATE_LOOP_DONE

uint8_t esphome::COMPONENT_STATE_LOOP_DONE = 0x04

inlineconstexpr

Definition at line 84 of file component.h.

COMPONENT_STATE_MASK

uint8_t esphome::COMPONENT_STATE_MASK = 0x07

inlineconstexpr

Definition at line 79 of file component.h.

COMPONENT_STATE_SETUP

uint8_t esphome::COMPONENT_STATE_SETUP = 0x01

inlineconstexpr

Definition at line 81 of file component.h.

elem_size

uint16_t uint16_t size_t esphome::elem_size

Initial value:

{
  ESPHOME_DEBUG_ASSERT(size < UINT16_MAX)

Definition at line 26 of file helpers.cpp.

fmt

size_t size_t const char* esphome::fmt

Definition at line 1039 of file helpers.h.

FNV1_OFFSET_BASIS

uint32_t esphome::FNV1_OFFSET_BASIS = 2166136261UL

constexpr

FNV-1 32-bit offset basis.

Definition at line 784 of file helpers.h.

FNV1_PRIME

uint32_t esphome::FNV1_PRIME = 16777619UL

constexpr

FNV-1 32-bit prime.

Definition at line 786 of file helpers.h.

format

const char int const __FlashStringHelper* esphome::format

Definition at line 74 of file log.h.

g_main_loop_woke

volatile bool esphome::g_main_loop_woke = false

Definition at line 14 of file wake_esp8266.cpp.

g_wake_requested

volatile uint8_t esphome::g_wake_requested = 0

Definition at line 49 of file wake.h.

gamma

float esphome::gamma

Definition at line 1593 of file helpers.h.

global_preferences

ESPPreferences * esphome::global_preferences

Definition at line 209 of file preferences.cpp.

global_runtime_stats

runtime_stats::RuntimeStatsCollector * esphome::global_runtime_stats

Initial value:

=  
    nullptr

Definition at line 151 of file runtime_stats.cpp.

GPIO_SUMMARY_MAX_LEN

size_t esphome::GPIO_SUMMARY_MAX_LEN = 48

inlineconstexpr

Maximum buffer size for dump_summary output.

Definition at line 13 of file gpio.h.

len

std::string size_t esphome::len

Definition at line 53 of file alloc_helpers.h.

line

const char int esphome::line

Definition at line 74 of file log.h.

loop_task_handle

TaskHandle_t esphome::loop_task_handle = nullptr

Definition at line 17 of file core.cpp.

new_cap

uint16_t esphome::new_cap = size + 1

Definition at line 28 of file helpers.cpp.

new_data

return esphome::new_data = ::operator new(new_cap *elem_size)

Definition at line 29 of file helpers.cpp.

pos

size_t size_t esphome::pos

Definition at line 1038 of file helpers.h.

SCHEDULER_DONT_RUN

uint32_t esphome::SCHEDULER_DONT_RUN = 4294967295UL

inlineconstexpr

Definition at line 61 of file component.h.

size

size_t esphome::size

Definition at line 25 of file helpers.cpp.

STATUS_LED_ERROR

uint8_t esphome::STATUS_LED_ERROR = 0x10

inlineconstexpr

Definition at line 89 of file component.h.

STATUS_LED_MASK

uint8_t esphome::STATUS_LED_MASK = 0x18

inlineconstexpr

Definition at line 86 of file component.h.

STATUS_LED_OK

uint8_t esphome::STATUS_LED_OK = 0x00

inlineconstexpr

Definition at line 87 of file component.h.

STATUS_LED_WARNING

uint8_t esphome::STATUS_LED_WARNING = 0x08

inlineconstexpr

Definition at line 88 of file component.h.

tag

const char* esphome::tag

Definition at line 74 of file log.h.

WAKE_NOTIFY_DRAIN_BUFFER_SIZE

size_t esphome::WAKE_NOTIFY_DRAIN_BUFFER_SIZE = 16

inlineconstexpr

Definition at line 46 of file wake_host.h.

WARN_IF_BLOCKING_OVER_CS

uint8_t esphome::WARN_IF_BLOCKING_OVER_CS = 5U

inlineconstexpr

Definition at line 100 of file component.h.

written

int esphome::written = vsnprintf(buf + pos, size - pos, fmt, args)

Definition at line 1045 of file helpers.h.