mirror of
https://github.com/esphome/esphome.git
synced 2024-11-23 15:38:11 +01:00
1b8d242505
* Enable use of alternate hardware UARTs for logging Enable use of Serial1 on ESP8266 and Serial1/Serial2 on ESP32 for logging. This is frequently done on ESP8266 to allow use of Serial for UART TX+RX, while maintaining logging output on Serial1 which is TX-only via GPIO2. * ESPHOMELIB_UART -> UART_SELECTION_UART; HW_UART -> HARDWARE_UART * Add test3 to travis; remove test4 * Set DEBUG_ESP_PORT based on logger UART setting
180 lines
6.8 KiB
Python
180 lines
6.8 KiB
Python
import re
|
|
|
|
import voluptuous as vol
|
|
|
|
from esphomeyaml.automation import ACTION_REGISTRY, LambdaAction
|
|
import esphomeyaml.config_validation as cv
|
|
from esphomeyaml.const import CONF_ARGS, CONF_BAUD_RATE, CONF_FORMAT, CONF_ID, CONF_LEVEL, \
|
|
CONF_LOGS, CONF_TAG, CONF_TX_BUFFER_SIZE, CONF_HARDWARE_UART
|
|
from esphomeyaml.core import EsphomeyamlError, Lambda, CORE
|
|
from esphomeyaml.cpp_generator import Pvariable, RawExpression, add, process_lambda, statement
|
|
from esphomeyaml.cpp_types import App, Component, esphomelib_ns, global_ns, void
|
|
from esphomeyaml.py_compat import text_type
|
|
|
|
LOG_LEVELS = {
|
|
'NONE': global_ns.ESPHOMELIB_LOG_LEVEL_NONE,
|
|
'ERROR': global_ns.ESPHOMELIB_LOG_LEVEL_ERROR,
|
|
'WARN': global_ns.ESPHOMELIB_LOG_LEVEL_WARN,
|
|
'INFO': global_ns.ESPHOMELIB_LOG_LEVEL_INFO,
|
|
'DEBUG': global_ns.ESPHOMELIB_LOG_LEVEL_DEBUG,
|
|
'VERBOSE': global_ns.ESPHOMELIB_LOG_LEVEL_VERBOSE,
|
|
'VERY_VERBOSE': global_ns.ESPHOMELIB_LOG_LEVEL_VERY_VERBOSE,
|
|
}
|
|
|
|
LOG_LEVEL_TO_ESP_LOG = {
|
|
'ERROR': global_ns.ESP_LOGE,
|
|
'WARN': global_ns.ESP_LOGW,
|
|
'INFO': global_ns.ESP_LOGI,
|
|
'DEBUG': global_ns.ESP_LOGD,
|
|
'VERBOSE': global_ns.ESP_LOGV,
|
|
'VERY_VERBOSE': global_ns.ESP_LOGVV,
|
|
}
|
|
|
|
LOG_LEVEL_SEVERITY = ['NONE', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'VERBOSE', 'VERY_VERBOSE']
|
|
|
|
UART_SELECTION_ESP32 = ['UART0', 'UART1', 'UART2']
|
|
|
|
UART_SELECTION_ESP8266 = ['UART0', 'UART0_SWAP', 'UART1']
|
|
|
|
HARDWARE_UART_TO_UART_SELECTION = {
|
|
'UART0': global_ns.UART_SELECTION_UART0,
|
|
'UART0_SWAP': global_ns.UART_SELECTION_UART0_SWAP,
|
|
'UART1': global_ns.UART_SELECTION_UART1,
|
|
'UART2': global_ns.UART_SELECTION_UART2,
|
|
}
|
|
|
|
HARDWARE_UART_TO_SERIAL = {
|
|
'UART0': 'Serial',
|
|
'UART0_SWAP': 'Serial',
|
|
'UART1': 'Serial1',
|
|
'UART2': 'Serial2',
|
|
}
|
|
|
|
# pylint: disable=invalid-name
|
|
is_log_level = cv.one_of(*LOG_LEVELS, upper=True)
|
|
|
|
|
|
def uart_selection(value):
|
|
if CORE.is_esp32:
|
|
return cv.one_of(*UART_SELECTION_ESP32, upper=True)(value)
|
|
if CORE.is_esp8266:
|
|
return cv.one_of(*UART_SELECTION_ESP8266, upper=True)(value)
|
|
raise NotImplementedError
|
|
|
|
|
|
def validate_local_no_higher_than_global(value):
|
|
global_level = value.get(CONF_LEVEL, 'DEBUG')
|
|
for tag, level in value.get(CONF_LOGS, {}).items():
|
|
if LOG_LEVEL_SEVERITY.index(level) > LOG_LEVEL_SEVERITY.index(global_level):
|
|
raise EsphomeyamlError(u"The local log level {} for {} must be less severe than the "
|
|
u"global log level {}.".format(level, tag, global_level))
|
|
return value
|
|
|
|
|
|
LogComponent = esphomelib_ns.class_('LogComponent', Component)
|
|
|
|
CONFIG_SCHEMA = vol.All(vol.Schema({
|
|
cv.GenerateID(): cv.declare_variable_id(LogComponent),
|
|
vol.Optional(CONF_BAUD_RATE, default=115200): cv.positive_int,
|
|
vol.Optional(CONF_TX_BUFFER_SIZE, default=512): cv.validate_bytes,
|
|
vol.Optional(CONF_HARDWARE_UART, default='UART0'): uart_selection,
|
|
vol.Optional(CONF_LEVEL): is_log_level,
|
|
vol.Optional(CONF_LOGS): vol.Schema({
|
|
cv.string: is_log_level,
|
|
})
|
|
}), validate_local_no_higher_than_global)
|
|
|
|
|
|
def to_code(config):
|
|
rhs = App.init_log(config.get(CONF_BAUD_RATE),
|
|
config.get(CONF_TX_BUFFER_SIZE),
|
|
HARDWARE_UART_TO_UART_SELECTION[config.get(CONF_HARDWARE_UART)])
|
|
log = Pvariable(config[CONF_ID], rhs)
|
|
if CONF_LEVEL in config:
|
|
add(log.set_global_log_level(LOG_LEVELS[config[CONF_LEVEL]]))
|
|
for tag, level in config.get(CONF_LOGS, {}).items():
|
|
add(log.set_log_level(tag, LOG_LEVELS[level]))
|
|
|
|
|
|
def required_build_flags(config):
|
|
flags = []
|
|
if CONF_LEVEL in config:
|
|
flags.append(u'-DESPHOMELIB_LOG_LEVEL={}'.format(str(LOG_LEVELS[config[CONF_LEVEL]])))
|
|
this_severity = LOG_LEVEL_SEVERITY.index(config[CONF_LEVEL])
|
|
verbose_severity = LOG_LEVEL_SEVERITY.index('VERBOSE')
|
|
is_at_least_verbose = this_severity >= verbose_severity
|
|
has_serial_logging = config.get(CONF_BAUD_RATE) != 0
|
|
if CORE.is_esp8266 and has_serial_logging and is_at_least_verbose:
|
|
debug_serial_port = HARDWARE_UART_TO_SERIAL[config.get(CONF_HARDWARE_UART)]
|
|
flags.append(u"-DDEBUG_ESP_PORT={}".format(debug_serial_port))
|
|
flags.append(u"-DLWIP_DEBUG")
|
|
DEBUG_COMPONENTS = {
|
|
'HTTP_CLIENT',
|
|
'HTTP_SERVER',
|
|
'HTTP_UPDATE',
|
|
'OTA',
|
|
'SSL',
|
|
'TLS_MEM',
|
|
'UPDATER',
|
|
'WIFI',
|
|
}
|
|
for comp in DEBUG_COMPONENTS:
|
|
flags.append(u"-DDEBUG_ESP_{}".format(comp))
|
|
if CORE.is_esp32 and is_at_least_verbose:
|
|
flags.append('-DCORE_DEBUG_LEVEL=5')
|
|
|
|
return flags
|
|
|
|
|
|
def maybe_simple_message(schema):
|
|
def validator(value):
|
|
if isinstance(value, dict):
|
|
return vol.Schema(schema)(value)
|
|
return vol.Schema(schema)({CONF_FORMAT: value})
|
|
|
|
return validator
|
|
|
|
|
|
def validate_printf(value):
|
|
# https://stackoverflow.com/questions/30011379/how-can-i-parse-a-c-format-string-in-python
|
|
# pylint: disable=anomalous-backslash-in-string
|
|
cfmt = u"""\
|
|
( # start of capture group 1
|
|
% # literal "%"
|
|
(?: # first option
|
|
(?:[-+0 #]{0,5}) # optional flags
|
|
(?:\d+|\*)? # width
|
|
(?:\.(?:\d+|\*))? # precision
|
|
(?:h|l|ll|w|I|I32|I64)? # size
|
|
[cCdiouxXeEfgGaAnpsSZ] # type
|
|
) | # OR
|
|
%%) # literal "%%"
|
|
""" # noqa
|
|
matches = re.findall(cfmt, value[CONF_FORMAT], flags=re.X)
|
|
if len(matches) != len(value[CONF_ARGS]):
|
|
raise vol.Invalid(u"Found {} printf-patterns ({}), but {} args were given!"
|
|
u"".format(len(matches), u', '.join(matches), len(value[CONF_ARGS])))
|
|
return value
|
|
|
|
|
|
CONF_LOGGER_LOG = 'logger.log'
|
|
LOGGER_LOG_ACTION_SCHEMA = vol.All(maybe_simple_message({
|
|
vol.Required(CONF_FORMAT): cv.string,
|
|
vol.Optional(CONF_ARGS, default=list): cv.ensure_list(cv.lambda_),
|
|
vol.Optional(CONF_LEVEL, default="DEBUG"): cv.one_of(*LOG_LEVEL_TO_ESP_LOG, upper=True),
|
|
vol.Optional(CONF_TAG, default="main"): cv.string,
|
|
}), validate_printf)
|
|
|
|
|
|
@ACTION_REGISTRY.register(CONF_LOGGER_LOG, LOGGER_LOG_ACTION_SCHEMA)
|
|
def logger_log_action_to_code(config, action_id, arg_type, template_arg):
|
|
esp_log = LOG_LEVEL_TO_ESP_LOG[config[CONF_LEVEL]]
|
|
args = [RawExpression(text_type(x)) for x in config[CONF_ARGS]]
|
|
|
|
text = text_type(statement(esp_log(config[CONF_TAG], config[CONF_FORMAT], *args)))
|
|
|
|
for lambda_ in process_lambda(Lambda(text), [(arg_type, 'x')], return_type=void):
|
|
yield None
|
|
rhs = LambdaAction.new(template_arg, lambda_)
|
|
type = LambdaAction.template(template_arg)
|
|
yield Pvariable(action_id, rhs, type=type)
|