Tu Primer Flujo Complejo en Node-RED: Switch, Variables y Lógica Avanzada

Si has seguido nuestra guía de instalación y paletas esenciales de Node-RED, ya tienes el motor listo. Seguramente ya hayas logrado encender una luz cuando un sensor detecta movimiento. Eso está bien para empezar, pero es un mero mecanismo de acción-reacción.

La verdadera magia de la domótica no ocurre cuando la casa obedece, sino cuando la casa piensa. En esta guía vamos a dar el salto de nivel: dejaremos atrás las líneas rectas para construir árboles de decisiones ramificados usando el nodo Switch y la gestión de Estados Globales.

Introducción a los Flujos No Lineales

La vida real rara vez es una línea recta. Tus decisiones cotidianas dependen del contexto: «Si tengo hambre, como. PERO si es tarde, como poco. Y si no hay comida, pido una pizza». Eso es un flujo no lineal.

En la domótica básica (como las rutinas estándar de Alexa), estamos limitados a órdenes simples: «Cuando pase A, haz B». En Node-RED, rompemos esa barrera para imitar el pensamiento humano.

¿Por qué necesitamos complejidad? De la línea recta al árbol de decisiones

Imagina una automatización de seguridad para la puerta de entrada.

Versión Lineal: «Si la puerta se abre → Suena la sirena».

Resultado: La sirena suena cuando entras tú, cuando entra tu pareja y cuando entra el ladrón. Es un sistema inútil por molesto.

Versión Ramificada (Árbol de decisión):

1. La puerta se abre.
2. El sistema se pregunta: «¿Está la alarma activada?»
3. Si NO → No hace nada (bienvenida).
4. Si SÍ → Se pregunta: «¿Es un teléfono conocido el que entra?» (rastreo WiFi).
5. Si es conocido → Desactiva alarma.
6. Si es desconocido → Suena la sirena.

Este nivel de detalle es lo que diferencia un juguete de un sistema de seguridad real.

Anatomía de un flujo complejo: Lógica, Enrutamiento y Memoria

Para construir estos «cerebros digitales», necesitamos entender los tres pilares que sostienen cualquier algoritmo avanzado en Node-RED:

• Lógica (Logic): Es la capacidad de comparar datos. «¿Es la temperatura mayor de 25ºC?» o «¿El consumo es inferior a 10W?». Sin lógica, no hay criterio.
• Enrutamiento (Routing): Es el sistema de vías del tren. El nodo Switch (que veremos a continuación) es el encargado de desviar el mensaje por el camino A o el camino B según el resultado de la lógica.
• Memoria (State): El componente más olvidado. Para decidir bien, el sistema necesita recordar el pasado. «¿Encendí la luz yo manualmente o se encendió sola?». Gestionar estas variables (Contexto) es lo que veremos en la segunda parte de esta guía.

El Cerebro del Flujo: Lógica Condicional (If/Else)

En programación tradicional, las decisiones se escriben con sentencias If/Else (Si pasa esto… haz aquello, si no… haz lo otro). En Node-RED, esta función la cumple el nodo color crema llamado Switch.

A diferencia de un interruptor físico que enciende o apaga, el nodo Switch actúa como un jefe de estación de trenes. Mira la carga que trae el vagón (el mensaje) y decide por qué vía debe continuar su viaje. Es la herramienta fundamental para filtrar el ruido de tus sensores inteligentes.

Conceptos Básicos: El nodo «Si ocurre esto, haz aquello»

El funcionamiento es sencillo: le llega un mensaje, lo compara con una lista de reglas y lo escupe por la salida correspondiente.

Configurando tu primera condición simple

Imagina que quieres encender la calefacción solo si hace frío. Arrastra un nodo Switch y haz doble clic:

1. Property (Propiedad): Aquí indicas qué dato quieres examinar. Por defecto es msg.payload. Si tu termostato envía la temperatura ahí, déjalo tal cual.
2. Rules (Reglas): Pulsa el botón + add abajo a la izquierda.
   • Selecciona el operador matemático < (menor que).
   • Escribe el valor: 19.

Al hacer esto, verás que al nodo le aparece un pequeño puerto gris a la derecha. Todo mensaje que entre con un valor de 18 o menos, saldrá por ahí. Si entra un 20, morirá en el nodo (no pasará nada).

Lógica Avanzada para Expertos

La vida real no suele depender de un solo factor. A menudo necesitamos combinar varias condiciones. Aquí entran en juego las puertas lógicas que explicamos en nuestra guía sobre termostatos inteligentes.

Evaluando múltiples propiedades simultáneamente (AND/OR)

Node-RED maneja esto mediante la disposición visual de los nodos:

• Lógica AND (Serie): ¿Quieres que ocurra algo solo si hace frío Y hay gente en casa?Coloca dos nodos Switch uno detrás de otro.

  Sensor Temp (< 19) ➡ Sensor Presencia (== true) ➡ Calefacción ON.

  El mensaje solo llegará al final si supera ambos filtros.

• Lógica OR (Paralelo): ¿Quieres encender la luz si detecta movimiento el sensor A O el sensor B?Conecta ambos sensores a la entrada del mismo nodo de acción. Si cualquiera de los dos se activa, la acción se ejecuta.

Evitando el «Spaghetti code» visual: Cuándo no usar If/Else

En programación, llamamos código espagueti a programas cuyo flujo es tan enrevesado que es imposible de seguir. En Node-RED, esto ocurre cuando encadenas 10 nodos Switch seguidos.

La regla de oro: Si tienes que anidar más de 3 condiciones (Si A, y B, y C, pero no D…), deja de usar nodos Switch en serie. Es el momento de usar un nodo Function con JavaScript o expresiones JSONata dentro de un nodo Change, lo cual simplifica la visualización drásticamente y reduce la carga del servidor.

El Enrutador Inteligente: Dominando los ‘Switch Nodes’

Si la lógica condicional es el cerebro, el nodo Switch es el sistema nervioso que distribuye las órdenes. Es el componente que permite que un solo flujo de entrada se divida en múltiples caminos de salida, ejecutando acciones totalmente distintas según lo que haya ocurrido.

¿Qué es un Switch Node y cuándo usarlo?

Un Switch Node evalúa un mensaje entrante (usualmente msg.payload) y lo envía por una o varias salidas específicas basándose en reglas predefinidas. Es equivalente a la estructura switch-case en programación tradicional.

Diferencias clave entre nodos ‘Switch’ y múltiples ‘If’

Podrías pensar: «¿Por qué usar esto si puedo poner varios filtros seguidos?». La diferencia es la eficiencia y la limpieza visual.

• Múltiples If (Serie): Evalúan condiciones secuencialmente. Si falla el primero, el mensaje se detiene. Es rígido.
• Switch Node (Paralelo): Evalúa todas las reglas a la vez. Un solo mensaje puede salir por la vía 1 (porque es > 10) Y por la vía 2 (porque es par) simultáneamente. Permite crear flujos paralelos desde un único punto de origen.

Configuración de Reglas de Enrutamiento

Dentro del nodo, la magia ocurre al definir las reglas. Node-RED ofrece desde comparaciones simples hasta análisis de texto avanzado.

Coincidencia exacta (Strings y Números)

Es la forma más común. Le dices al nodo: «Si el mensaje es EXACTAMENTE esta palabra, sal por aquí».

• Ejemplo Numérico: Si la temperatura == 21, activar modo Eco.
• Ejemplo de Texto (String): Si el estado de la alarma es armed_away, activar sensores de movimiento interiores.

Es vital respetar mayúsculas y minúsculas. «ON» no es lo mismo que «on».

Uso de Expresiones Regulares (Regex) para patrones complejos

A veces, los dispositivos no envían mensajes limpios. Una aspiradora robot puede enviar: «Error 5: Rueda atascada» o «Error 7: Cepillo sucio». Si quieres detectar cualquier error sin escribir 50 reglas, usas Expresiones Regulares (Regex).

Configura la regla como matches regex y usa un patrón como:

Error \d+

Esto detectará cualquier mensaje que contenga la palabra «Error» seguida de un número, permitiéndote enviar una notificación genérica de «Problema en la aspiradora» sin importar el código específico.

La importancia crítica de la salida ‘Default’ (Fallback)

Este es el salvavidas de tu flujo. Al final de la lista de reglas en el nodo Switch, verás una opción llamada «otherwise» (en otro caso).

¿Por qué activarla siempre?
Si un mensaje entra en el Switch y no cumple ninguna regla, desaparece silenciosamente. Esto hace que la depuración sea una pesadilla («¿Por qué no se encendió la luz?»).

Buenas prácticas: Conecta siempre la salida «otherwise» a un nodo Debug. Así, si llega un dato inesperado (ej: un sensor envía unavailable en lugar de un número), lo verás inmediatamente en la consola de depuración y podrás arreglarlo.

La Memoria del Sistema: Gestión de Estados y Contexto

Hasta ahora, tu sistema padece de amnesia a corto plazo. Cuando un mensaje entra, se procesa y sale, Node-RED se olvida de que existió. Pero para una casa verdaderamente inteligente, necesitamos memoria.

Necesitas saber si la luz ya estaba encendida antes de cambiarle el color, o cuántas veces se ha abierto la puerta en la última hora. Aquí es donde entra en juego el concepto de Contexto.

Entendiendo el Ciclo de Vida de los Datos

En programación, no todos los datos viven para siempre. Entender cuándo «muere» una variable es crucial para no perder información importante.

Variables volátiles vs. Variables persistentes

Por defecto, Node-RED guarda el contexto en la memoria RAM. Esto significa que son variables volátiles: si reinicias el servidor o se va la luz, vuelven a cero.

Para datos críticos (como el acumulado de consumo eléctrico mensual), debes configurar tu archivo settings.js para habilitar el almacenamiento en disco (Filesystem). De lo contrario, un reinicio te borrará el historial del mes.

Tipos de Estado (Scopes) explicados

Node-RED tiene una jerarquía de privacidad para sus variables. Piensa en ello como secretos:

Estado del Mensaje (msg): Datos que viajan

Es como una nota en tu bolsillo. Solo la tienes tú mientras caminas por el cable. Cuando el mensaje llega al final del flujo (nodo debug o acción), la nota se destruye. Es ideal para datos temporales que no necesitas guardar.

Estado del Flujo (flow): Datos que viven en la pestaña

Es como una pizarra en la pared de una habitación. Todos los nodos que estén en la misma pestaña (Tab) pueden leer y escribir en ella.

Uso ideal: Contadores locales (ej: «¿Cuántas veces ha saltado el sensor del salón hoy?»). Los nodos de la pestaña «Cocina» no podrán ver esta pizarra.

Estado Global (global): Datos compartidos entre todo el sistema

Es un tablón de anuncios en el pasillo principal. Cualquier nodo, en cualquier pestaña, puede acceder a estos datos.

Uso ideal: Modos de la casa (modo_vacaciones, es_de_noche, alarma_activada). Son la columna vertebral de tu lógica domótica.

Manipulación segura de Estados Globales

Escribir en la memoria es delicado. Si lo haces mal, puedes corromper la lógica de toda la casa.

Lectura y Escritura asíncrona

Para manipular estas variables, usamos principalmente dos nodos:

• Nodo Change: La forma visual. Configúralo para Set flow.contador to 5. Es rápido y seguro.
• Nodo Function: La forma de código. Usas global.get('variable') y global.set('variable', valor).

Prevención de condiciones de carrera (Race Conditions)

Este es un error de nivel experto que puede volverte loco. Ocurre cuando dos flujos intentan escribir en la misma variable global exactamente al mismo tiempo.

Ejemplo: El sensor A y el sensor B se activan a la vez. Ambos leen que el contador está en 0. Ambos suman 1. Ambos guardan el resultado «1».

Resultado real: 1. Resultado esperado: 2.

Solución: Evita bifurcaciones paralelas que escriban en la misma variable global. Usa colas o asegúrate de que las escrituras ocurran secuencialmente.

Taller Práctico: Construyendo tu Primer Flujo Complejo

La teoría está muy bien, pero Node-RED se aprende «tirando cables». Vamos a construir un flujo real que integre todo lo aprendido: Lógica, Switch y Variables Globales. Vamos a crear un Portero de Discoteca Digital.

El Escenario: Un sistema de clasificación de usuarios

Imagina que tienes un teclado en la puerta de entrada. Tu objetivo es que el sistema reaccione diferente según quién introduzca el código, y que además, lleve la cuenta de cuántas personas han entrado en casa hoy.

1. Admin (Tú): Desactiva la alarma y enciende luces.
2. Invitado: Solo enciende luces (sin tocar la alarma).
3. Desconocido: Envía una alerta al móvil.

Paso 1: Inicialización de variables globales

Antes de empezar a contar, necesitamos poner el contador a cero. Si intentamos sumar 1 + nada, el sistema dará error. Esto se hace típicamente al arrancar Node-RED.

1. Arrastra un nodo Inject y configúralo para que se ejecute «Once after 0.1 seconds» (Al arrancar).
2. Arrastra un nodo Change.
3. Configura el Change: Set flow.contadorVisitas to 0 (Number).

Explicación: Cada vez que reinicies el sistema, la pizarra se borrará y empezará la cuenta limpia.

Paso 2: Implementación del Switch Node para categorización

Ahora simularemos la entrada de una persona. Usaremos un nodo Inject donde el msg.payload sea el nombre de la persona (ej: «Juan»).

1. Arrastra un nodo Switch.
2. Define las reglas basadas en el nombre:
   • Regla 1: == "Juan" (Salida 1: Admin).
   • Regla 2: == "Invitado" (Salida 2: Visita).
   • Regla 3: otherwise (Salida 3: Intruso).

Ahora tienes un nodo con tres salidas físicas. Visualmente ya ves los tres caminos posibles.

Paso 3: Actualización de estado basada en la ruta elegida

Queremos contar cuánta gente entra, sin importar quién sea. Para ello, uniremos las salidas 1 y 2 (gente autorizada) hacia un nodo que sume puntos.

Para hacer sumas en Node-RED, usamos el lenguaje JSONata dentro de un nodo Change. Es la forma más limpia de hacerlo sin escribir código JavaScript complejo.

1. Arrastra un nodo Change.
2. Conecta la Salida 1 y la Salida 2 del Switch a este nodo.
3. Configuración:
   • Set: flow.contadorVisitas
   • To (JSONata): $flowContext("contadorVisitas") + 1

Traducción: «Busca en la memoria cuánto valía el contador, súmale 1 y vuelve a guardarlo».

Depuración (Debugging) del flujo

Ya tenemos el sistema montado. Ahora, ¿cómo sabemos si funciona sin tener una pantalla?

Uso del nodo ‘Debug’ para inspeccionar el contexto global

No basta con poner un nodo Debug al final. Queremos ver la variable interna.

1. Abre la Barra Lateral Derecha y selecciona la pestaña «Context Data» (icono de base de datos o flecha hacia abajo).
2. Pulsa el botón de refrescar junto a flow.
3. Pulsa varias veces tus nodos Inject de «Juan» o «Invitado».
4. Dale a refrescar de nuevo en la barra lateral.

Si todo ha ido bien, verás que el valor contadorVisitas incrementa mágicamente (1, 2, 3…) sin necesidad de enviar mensajes. ¡Tu sistema tiene memoria!

Buenas Prácticas y Mantenibilidad

Crear un flujo complejo es fácil; lo difícil es entenderlo seis meses después. Node-RED permite hacer cosas increíbles, pero también te permite crear un desorden visual absoluto (el temido «Spaghetti Code»).

Para evitar que tu domótica se vuelva inmanejable, sigue estas tres reglas de oro que usamos los profesionales.

Naming Conventions: Cómo nombrar tus nodos y variables

Por defecto, Node-RED llama a los nodos Switch 1, Switch 2, etc. Esto es una trampa. Cuando mires el registro de errores, verás «Error en Switch 4» y no sabrás qué bombilla está fallando.

• Nodos de Acción: Usa verbos. En lugar de «Luz Salón», pon «Encender Luz Salón».
• Nodos Switch: Usa preguntas. En lugar de «Switch 1», pon «¿Es de noche?».
• Variables Globales: Usa prefijos que indiquen el tipo de dato.
  • is_home (Booleano: sí/no).
  • count_visitas (Número).
  • str_ultimo_usuario (Texto).

Documentación dentro del flujo: Comentarios y Grupos

Sé amable con tu «yo del futuro». Node-RED tiene herramientas nativas para documentar tu trabajo sin salir del editor.

1. El Nodo Comentario (Comment):
Es ese nodo amarillo que nadie usa. Colócalo encima de bloques complejos explicando por qué hiciste eso. Ejemplo: «Esperamos 5 segundos extra porque la bombilla WiFi tarda en conectar».

2. Agrupar Selección (Groups):
Selecciona varios nodos relacionados (ej: toda la lógica de la calefacción), haz clic derecho y pulsa Group Selection. Ponle un color de fondo y un título. Visualmente, pasarás de tener 50 nodos sueltos a tener 4 cajas ordenadas por zonas.

Manejo de Errores en arquitecturas de estado global

Cuando trabajas con memoria persistente, debes aplicar lo que en ingeniería se llama Programación Defensiva.

El problema: Imagina que tu flujo intenta sumar 1 a la variable contador, pero acabas de reiniciar Node-RED y la variable aún no existe (es undefined o null). El flujo se romperá.

La solución: Inicialización por defecto.
Cuando leas una variable global, asume siempre que puede fallar. En JSONata, puedes usar este truco:

$globalContext("contador") != null ? $globalContext("contador") : 0

Esto significa: «Si el contador existe, úsalo. Si no existe (es null), usa un 0». Así tu sistema nunca colapsará por un reinicio inesperado.

---

Conclusión: Tu casa ya piensa por sí misma

Has pasado de conectar un cable recto a diseñar un sistema que evalúa, decide y recuerda. Has aprendido:

1. A usar el Nodo Switch para bifurcar la realidad.
2. A usar Variables de Contexto para dar memoria a tu casa.
3. A estructurar flujos profesionales y mantenibles.

El siguiente paso es la integración total. Ahora que sabes manejar datos complejos, ¿por qué no aprender a visualizarlos en un panel de control a medida? Revisa nuestra guía sobre Home Assistant vs Node-RED para ver cómo ambos sistemas se dan la mano.

Preguntas Frecuentes (FAQ)

¿Cuántos nodos Switch puedo poner seguidos?

Técnicamente infinitos, pero no lo recomendamos. Si necesitas encadenar más de 3 condiciones (Si A y B y C…), es mejor usar un nodo Change con lógica JSONata o un nodo Function con JavaScript. Tu flujo será más rápido y fácil de leer.

¿Las variables globales consumen mucha memoria RAM?

Variables simples (números, textos cortos, booleanos) consumen una cantidad insignificante. Sin embargo, evita guardar objetos JSON gigantes (como el historial completo de una cámara) en variables globales, ya que eso sí podría ralentizar una Raspberry Pi.

¿Puedo copiar mis flujos complejos de un ordenador a otro?

¡Sí! Selecciona tus nodos, pulsa Ctrl+E (Exportar) y obtendrás un código JSON. Puedes guardar ese texto o enviárselo a un amigo. Para importarlo, usa Ctrl+I. Es la mejor forma de compartir «Blueprints» en Node-RED.

¿Te ha sido útil? ¡Compártelo con otros!

WhatsApp Facebook X (Twitter) Telegram

Únete a la Comunidad

Síguenos en nuestras redes para ver tutoriales en vídeo, ideas de decoración y trucos rápidos para tu hogar inteligente.