Node RED: automatyzacje dla początkujących

Czym jest Node-RED i dlaczego ułatwia start z automatyzacją

Node-RED to graficzne środowisko do tworzenia automatyzacji i integracji, które bazuje na przetwarzaniu danych w postaci tzw. przepływów (flows). Zamiast pisać długi kod w JavaScript, Pythonie czy C, buduje się logikę z gotowych klocków – węzłów (nodes) – przeciąganych na planszę i łączonych liniami. Dzięki temu osoba początkująca może zbudować realne automatyzacje po kilku godzinach zabawy, a nie po tygodniach nauki programowania.

Node-RED powstał w IBM jako narzędzie do integracji w świecie IoT i automatyki. Dziś jest rozwijany jako projekt open source, działa na Raspberry Pi, komputerach PC, serwerach, a nawet w chmurze. Używa go zarówno hobbysta automatyzujący mieszkanie, jak i inżynier wdrażający systemy w firmie produkcyjnej. W centrum zawsze jest ten sam pomysł: rysujesz logikę przepływu danych zamiast pisać kod od zera.

Dla osób startujących z automatyką i robotyką Node-RED jest wygodnym „pierwszym językiem”. Pozwala skupić się na tym, co ma się dziać (logika, scenariusze), a nie na tym, jak to zaprogramować w każdym szczególe. A gdy przychodzi moment na bardziej zaawansowane rozwiązania, węzły JavaScript pozwalają stopniowo wchodzić w prawdziwe programowanie.

Główne idee działania Node-RED

Cała koncepcja Node-RED opiera się na kilku prostych założeniach, które dobrze zrozumieć na starcie:

• Przepływy (flows) – to „diagramy” automatyzacji. Każdy flow to zestaw połączonych węzłów, który wykonuje określone zadanie: np. pobiera dane z czujnika, przetwarza je i wysyła powiadomienie.
• Węzły (nodes) – gotowe klocki realizujące pojedynczą funkcję: wejście (np. MQTT, HTTP, GPIO), logika (porównanie, warunek, funkcja), wyjście (e-mail, baza danych, przekaźnik).
• Wiadomości (msg) – dane płynące między węzłami. Każda wiadomość to obiekt (w praktyce coś jak „paczkowana” struktura), który ma różne pola: msg.payload, msg.topic itd.
• Wizualne łączenie – zamiast budować architekturę w głowie, łączy się węzły w czytelne ścieżki. Dzięki temu po miesiącu wciąż wiadomo, co robi dana automatyzacja.

Taka architektura sprawia, że Node-RED dobrze nadaje się zarówno do prostych automatyzacji domowych, jak i integracji kilku systemów przemysłowych. Początkujący mogą używać głównie gotowych węzłów, a z czasem sięgać po bardziej zaawansowane elementy: własne funkcje, szablony, dashboardy.

Przykładowe zastosowania Node-RED dla początkujących

Nawet na starcie da się szybko zbudować automatyzacje o realnej wartości. Kilka prostych przykładów:

• Smart home: włączanie światła przy wykryciu ruchu i braku światła dziennego, powiadomienie na telefon przy otwarciu drzwi, sterowanie ogrzewaniem według prognozy pogody.
• Monitoring: zapis danych z czujników temperatury i wilgotności do bazy danych, wykresy w przeglądarce, alarm SMS, gdy temperatura przekroczy próg.
• Integracje internetowe: pobieranie kursów walut co godzinę i zapisywanie do arkusza Google, wysyłanie powiadomień na Slacka lub Telegram, gdy pojawi się nowy wpis na określonym API.
• Prosta automatyka sprzętowa: sterowanie przekaźnikami z Raspberry Pi, włączanie wentylatora po przekroczeniu zadanej temperatury, logika start/stop dla prostych urządzeń.

Wszystkie te scenariusze da się zrealizować, nie pisząc ani jednej linii „klasycznego” kodu – wystarczą gotowe węzły i kilka prostych ustawień.

Instalacja Node-RED krok po kroku

Zanim powstanie pierwsza automatyzacja, Node-RED trzeba zainstalować. Proces nie jest trudny, ale różni się zależnie od platformy. W praktyce najczęściej używa się trzech rozwiązań: instalacji na komputerze, na Raspberry Pi albo w kontenerze Docker.

Wymagania wstępne: Node.js i środowisko

Node-RED jest aplikacją napisaną w JavaScript, działającą na środowisku Node.js. To oznacza, że przed instalacją warto zadbać o kilka podstaw:

• system operacyjny: Linux, Windows lub macOS,
• zainstalowany Node.js (najczęściej wersja LTS),
• podstawowy dostęp do konsoli (terminal, PowerShell).

Na komputerach desktopowych wygodnie jest zainstalować Node.js z oficjalnej strony, a potem użyć wbudowanego menedżera pakietów npm. Na Raspberry Pi jeszcze prościej – oficjalny system Raspberry Pi OS ma Node-RED w pakiecie lub do doinstalowania jednym skryptem.

Instalacja Node-RED na komputerze (Linux/Windows/macOS)

Typowy scenariusz dla początkującego to uruchomienie Node-RED na własnym komputerze i sterowanie nim z tej samej przeglądarki. Podstawowa ścieżka wygląda następująco (schematycznie):

1. Zainstaluj Node.js (LTS) z oficjalnej strony lub menedżera pakietów systemu.
2. Otwórz terminal lub PowerShell.
3. Zainstaluj Node-RED globalnie poleceniem npm install -g --unsafe-perm node-red (składnia może się nieco różnić w zależności od systemu).
4. Uruchom Node-RED komendą node-red.
5. W przeglądarce wejdź na http://localhost:1880.

Po tej operacji powinien być widoczny edytor Node-RED. Domyślnie działa on lokalnie, bez uwierzytelniania, więc w środowisku domowym jest to wygodne rozwiązanie. W środowiskach firmowych trzeba dołożyć warstwę zabezpieczeń (o czym szerzej w dalszej części artykułu).

Instalacja na Raspberry Pi – dobry wybór dla automatyki

Raspberry Pi to mały komputer, który świetnie nadaje się na „serwer automatyzacji”. Pobiera niewiele energii, może działać 24/7, ma wyprowadzone piny GPIO, przez co da się nim bezpośrednio sterować przekaźnikami, czujnikami czy inną elektroniką. Połączenie Raspberry Pi + Node-RED to bardzo częsty wybór u osób, które chcą zbudować podstawy automatyki domowej lub mały system do monitoringu.

Na Raspberry Pi są dwie popularne drogi:

• użycie dedykowanego obrazu systemu z preinstalowanym Node-RED,
• instalacja Node-RED za pomocą przygotowanego skryptu (jedno polecenie w terminalu).

Po instalacji dostęp do edytora odbywa się zwykle pod adresem http://adres_rpi:1880. W praktyce wystarczy znać adres IP Raspberry Pi w sieci lokalnej lub użyć nazwy hosta, jeśli tak skonfigurowano sieć. Od tego momentu wszystkie automatyzacje będą działały bez konieczności włączania komputera, co jest dużym atutem przy stałych scenariuszach (np. sterowanie oświetleniem według harmonogramu).

Node-RED w Dockerze i w chmurze

Osoby, które mają już styczność z konteneryzacją, często uruchamiają Node-RED w kontenerze Docker. Daje to kilka korzyści: łatwe aktualizacje, separację środowisk, szybkie przenoszenie między serwerami. Oficjalny obraz Node-RED dostępny w rejestrze Docker Hub zawiera większość potrzebnych komponentów.

Drugą opcją jest uruchomienie Node-RED w chmurze, np. na VPS lub w ramach platform PaaS. Takie rozwiązanie bywa sensowne, gdy system ma być dostępny z wielu lokalizacji lub ma integrować się głównie z usługami internetowymi, a nie z lokalnymi czujnikami. Początkujący zwykle tego nie potrzebują, ale wiedza, że taka opcja istnieje, ułatwia późniejszy rozwój projektu.

Interfejs Node-RED: pierwsze spojrzenie na edytor przepływów

Po wejściu na adres serwera Node-RED ukazuje się edytor przepływów. Wygląda jak prosta aplikacja webowa, ale kryje w sobie sporo funkcji. Zrozumienie interfejsu ułatwia późniejszą pracę i ogranicza chaos w rosnącej liczbie automatyzacji.

Trzy główne części edytora

Ekran edytora Node-RED można podzielić na trzy podstawowe obszary:

• Paleta węzłów (po lewej) – pionowy pasek z listą gotowych węzłów posortowanych według kategorii (input, output, function, social, storage itd.). Stąd przeciąga się węzły na główną planszę.
• Obszar przepływu (centrum) – duża siatka, na której umieszcza się węzły i łączy je liniami. Każda zakładka u góry (Flow 1, Flow 2…) to osobna karta przepływu.
• Panel boczny (po prawej) – sekcja z zakładkami: debug, info, context, konfiguracja węzłów, import/eksport i inne narzędzia. Pozwala podglądać działanie przepływów i szczegóły elementów.

Przepływ buduje się, przeciągając węzły z palety na planszę, a następnie łącząc je myszką. Złącza na lewej stronie węzła to wejścia, a na prawej – wyjścia. Gdy światło połączenia świeci się na niebiesko (lub inny aktywny kolor w używanej wersji), oznacza to, że połączenie jest poprawne.

Podstawowe typy węzłów w palecie

Standardowa instalacja Node-RED zawiera zestaw węzłów, który pokrywa większość typowych potrzeb początkujących. Poniżej krótka charakterystyka podstawowych kategorii:

• Input – węzły wejściowe, np. inject (ręczne lub cykliczne generowanie wiadomości), http in (wejście z żądania HTTP), mqtt in (subskrypcja tematów MQTT), węzły dla GPIO, serial.
• Output – węzły wyjściowe, np. debug (podgląd danych), mqtt out, http response, e-mail, plik, GPIO out.
• Function – logika i przetwarzanie: function (własny kod JS), switch (warunek), change (zmiana struktury wiadomości), template, delay, join, split.
• Social / integracje – węzły do łączenia z serwisami internetowymi (np. Telegram, Slack, Twitter, e-mail), przydatne przy powiadomieniach.
• Storage – zapisywanie danych: pliki, bazy danych (np. SQLite, MySQL – często jako dodatkowe pakiety).

To wystarcza, aby od razu budować funkcjonalne przepływy. Całą resztę można doinstalować później z poziomu palety (węzły społeczności – tzw. contrib nodes).

Panel debug i obserwacja działania automatyzacji

Dla początkujących kluczowym narzędziem jest zakładka debug w panelu po prawej stronie. Węzeł debug wstawiony w przepływ pozwala podejrzeć, co faktycznie płynie w komunikacie msg. Dzięki temu od razu widać, czy czujnik senduje poprawne dane, czy warunek zadziałał, czy format wiadomości jest zgodny z oczekiwaniami.

Typowa praktyka na starcie to:

• umieszczenie węzła debug zaraz za każdym newralgicznym węzłem,
• sprawdzanie w panelu po prawej kolejnych odczytów,
• dostosowywanie warunków i struktur danych na podstawie tego podglądu.

Bez systematycznego korzystania z debug’a łatwo błądzić po omacku, szczególnie gdy przepływ robi się dłuższy. Po skończonych testach węzły debug można wyłączyć jednym kliknięciem (ikona na samym węźle) zamiast usuwać – przydadzą się w przyszłości, gdy coś trzeba będzie poprawić.

Jak myśleć w kategoriach przepływów: podstawowa logika Node-RED

Osoba przyzwyczajona do klasycznego kodu (linia po linii) musi się trochę przestawić. W Node-RED logika to sieć węzłów, a nie blok instrukcji. Początkujący, którzy zrozumieją ten model, szybciej budują poprawne automatyzacje i rzadziej wpadają w trudne do rozwiązania błędy.

Struktura wiadomości msg i jej rola

Cały Node-RED opiera się na tym, że między węzłami przepływa obiekt o nazwie msg. To struktura, która może mieć dowolne pola. Kilka z nich występuje najczęściej:

• msg.payload – główna zawartość wiadomości, zwykle dane czujnika, tekst, liczba, obiekt JSON.
• msg.topic – kontekst wiadomości, np. nazwa czujnika, temat MQTT, rodzaj zdarzenia.
• msg.headers – nagłówki HTTP lub inne metadane, zależnie od typu wejścia.
• inne pola własne, np. msg.temperature, msg.deviceId itp.

Przepływ danych krok po kroku: od zdarzenia do akcji

Najprostszy sposób myślenia o automatyzacji w Node-RED to łańcuch: coś się wydarza → dane trafiają do msg → węzły je przetwarzają → wykonywana jest akcja. Każdy węzeł zmienia lub uzupełnia obiekt msg, po czym przekazuje go dalej.

Przykładowy scenariusz może wyglądać tak:

• czujnik temperatury wysyła wiadomość MQTT,
• węzeł mqtt in odbiera dane i umieszcza je w msg.payload,
• węzeł switch sprawdza, czy temperatura przekracza próg,
• jeśli tak – węzeł http request wywołuje API inteligentnego gniazdka,
• na końcu debug wyświetla odpowiedź z API.

Nie ma tu ukrytej „pętli głównej” ani tradycyjnego if/else w kodzie programu – decyzje rozłożone są na poszczególne węzły i ich konfigurację.

Zmiana, filtrowanie i rozgałęzianie przepływu

W większości automatyzacji przydają się trzy operacje: modyfikowanie danych, ich filtrowanie oraz wysyłanie w różne strony w zależności od warunków.

Podstawowe węzły do takich zadań to:

• change – potrafi ustawić, przenieść lub usunąć pole w msg bez pisania kodu. Nadaje się np. do zmiany typu danych z tekstu na liczbę, nadania stałego msg.topic czy skopiowania msg.payload do innego pola.
• switch – rozdzielenie przepływu na kilka ścieżek. Można w nim ustawić warunki typu „większe niż”, „równe”, „zawiera tekst”, „pasuje do wzorca”. Każde wyjście węzła to inna gałąź logiki.
• function – blok kodu JavaScript, gdy konfiguratory typu change i switch nie wystarczą. Nadaje się do złożonych obliczeń, pętli czy użycia bibliotek JS.

Dospawanie prostego warunkowania często da się zrobić wyłącznie przy użyciu change i switch. Węzeł function opłaca się wprowadzać dopiero wtedy, gdy wizualne narzędzia robią się zbyt skomplikowane lub niewygodne.

Kontext przepływu i globalny: dane poza msg

Nie wszystkie informacje trzeba przenosić w msg. Node-RED udostępnia tzw. kontekst, czyli miejsce na zmienne przechowywane w pamięci roboczej:

• context – dane lokalne dla jednego węzła,
• flow – dane wspólne dla całej karty (jednego przepływu),
• global – dane widoczne z dowolnego miejsca.

Przykładowo: licznik uruchomień konkretnej akcji można trzymać w flow, a wspólne ustawienie (np. docelowa temperatura ogrzewania) w global. W węźle function odczyt wygląda np. tak:

let licznik = flow.get("licznik") || 0;
licznik++;
flow.set("licznik", licznik);
msg.payload = licznik;
return msg;

Taki mechanizm pozwala uniknąć przenoszenia wszystkich zmiennych w obiekcie msg, który ma służyć głównie do samego „transportu” danych między węzłami.

Pierwszy praktyczny przepływ: od kliknięcia do komunikatu

Dobrym pierwszym ćwiczeniem jest przepływ, który niczego jeszcze nie steruje, ale jasno pokazuje sposób pracy z Node-RED. Wystarczy kilka podstawowych węzłów.

Tworzenie prostego przepływu krok po kroku

Na start wystarczą trzy elementy: źródło wiadomości, jakiś sposób przetworzenia oraz wyświetlenie wyniku. Typowy zestaw to inject → function → debug.

1. Przeciągnij węzeł inject z kategorii input na obszar przepływu.
2. Dodaj węzeł function z kategorii function.
3. Dodaj węzeł debug z kategorii output.
4. Połącz węzły liniami: inject → function → debug.

Następnie skonfiguruj je w prosty sposób:

• w węźle inject ustaw typ na „timestamp” (domyślnie) lub na własny tekst, np. „start”,
• w węźle function wklej krótki kod:

msg.payload = "Odebrano: " + msg.payload;
return msg;

• w węźle debug pozostaw domyślne „output: msg.payload”.

Po kliknięciu przycisku obok węzła inject w panelu debug pojawi się komunikat z przetworzonym tekstem. To mały przykład, ale pokazuje pełną ścieżkę: zdarzenie → modyfikacja → wynik.

Dodanie prostego warunku

Na tym samym przepływie można szybko zobaczyć działanie warunkowania. Wystarczy dołożyć węzeł switch między function a debug i ustawić prostą regułę, np. „przepuszczaj tylko, gdy msg.payload zawiera słowo start”.

Po zapisaniu zmian i ponownym wstrzyknięciu wiadomości zobaczysz, że część komunikatów trafia do debug, a część jest odrzucana już na poziomie węzła switch. Dokładnie tak samo będzie w bardziej złożonych automatyzacjach – różnica leży wyłącznie w liczbie i typie użytych węzłów.

Automatyzacje oparte o czas: harmonogramy i opóźnienia

W wielu projektach kluczowe są akcje wykonywane o określonych godzinach lub z opóźnieniem. Node-RED zapewnia kilka mechanizmów, które pozwalają obyć się bez ręcznego pisania zegara w kodzie.

Węzeł inject jako prosty timer

Węzeł inject potrafi nie tylko generować wiadomość „na kliknięcie”, ale też cyklicznie. Wystarczy przełączyć tryb z „manualnie” na „interwał” lub „o konkretnej godzinie”. Można w ten sposób przykładowo:

• co 5 minut odpytywać API czujnika,
• codziennie o 7:00 wysyłać komunikat „pobudka” do systemu audio,
• raz na godzinę zapisywać dane z czujników do bazy.

Konfiguracja odbywa się bez kodu: zaznacza się interwał, dni tygodnia, ewentualnie zakres godzin. Dla prostych harmonogramów to w zupełności wystarcza.

Opóźnianie i przepuszczanie paczek: węzeł delay

Węzeł delay pełni dwie funkcje: wprowadza opóźnienie i ogranicza liczbę wiadomości. Przydaje się zarówno w prostych, jak i zaawansowanych przepływach.

Najczęstsze scenariusze:

• opóźnienie o określony czas – np. wysłanie powiadomienia dopiero, gdy czujnik ruchu wykrywa obecność przez przynajmniej 30 sekund,
• „rate limiting” – ograniczenie liczby wysyłanych e-maili lub zapytań do API zbyt często generowanych w przepływie,
• buforowanie – układanie wiadomości w kolejkę i wypuszczanie ich co określony interwał.

Przy integracjach z usługami, które mają limity zapytań (np. niektóre API pogodowe), taki regulator jest wręcz obowiązkowy, żeby uniknąć blokady konta.

Bardziej złożone harmonogramy

Kiedy zwykły inject nie wystarcza (np. trzeba uwzględnić wschód/zachód słońca, dni wolne, tryb urlopowy), często sięga się po dodatkowe węzły społeczności. Przykłady:

• węzły typu „scheduler” – pozwalają klikaniem w kalendarz ustawić różne reguły dla dni tygodnia, świąt czy sezonów,
• węzły astronomiczne – wyliczają godziny wschodu/zachodu słońca dla podanej lokalizacji i wystawiają odpowiednie zdarzenia.

Takie rozszerzenia instaluje się z poziomu palety, bez grzebania w systemie. Początkującemu wystarczy na początku inject, jednak świadomość istnienia rozbudowanych schedulerów ułatwia skalowanie pomysłów w przyszłości.

Automatyzacje z czujnikami i MQTT: podstawowy wzorzec

Rzeczywista automatyzacja pojawia się tam, gdzie Node-RED spotyka fizyczny świat: czujniki, przekaźniki, moduły Wi-Fi. Najpopularniejszym „klejem” dla takich urządzeń jest MQTT – lekki protokół publikacji/subskrypcji.

MQTT w praktyce: publish / subscribe

W modelu MQTT urządzenia nie komunikują się bezpośrednio między sobą. Zamiast tego:

• czujnik publikuje dane w określonym temacie (np. dom/salon/temperatura),
• Node-RED subskrybuje ten temat przez węzeł mqtt in,
• inne urządzenia (np. termostat, panel) mogą również subskrybować ten sam temat lub odpowiadające mu tematy sterujące.

Po stronie Node-RED konfiguruje się po prostu klienta MQTT, podając adres brokera, port i dane logowania (jeżeli broker nie jest otwarty). Jeden skonfigurowany „serwer” MQTT może być używany przez wiele węzłów wejściowych i wyjściowych.

Typowy przepływ „czujnik → decyzja → akcja”

Dla początkujących dobrym wzorcem jest schemat:

1. mqtt in – odbiera dane z czujnika, np. temperaturę w salonie,
2. change / function – zamienia tekst na liczbę, zaokrągla, normalizuje,
3. switch – sprawdza, czy temperatura jest poniżej / w zakresie / powyżej progu,
4. mqtt out / http request / gpio – uruchamia ogrzewanie, wysyła komendę do gniazdka lub przekaźnika,
5. debug / e-mail / powiadomienie – opcjonalna informacja dla użytkownika.

Gdy urządzenia po stronie sprzętowej są poprawnie skonfigurowane (korzystają z tego samego brokera MQTT), większość logiki przenosi się do przepływu Node-RED. Z czasem można do tego dodać korekty, np. różne progi dla trybu „dzień” i „noc”, albo uzależnić ogrzewanie od obecności domowników.

Integracja z GPIO na Raspberry Pi

Jeśli Node-RED działa bezpośrednio na Raspberry Pi, nie trzeba nawet MQTT, żeby sterować prostymi obwodami. W palecie pojawiają się węzły rpi gpio in/out, które pozwalają:

• czytać stany przycisków, czujników krańcowych, prostych detektorów,
• włączać i wyłączać przekaźniki, diody, syrenki.

W praktyce można zbudować przepływ: przycisk na ścianie (wejście GPIO) → węzeł rpi gpio in → logika w Node-RED → węzeł rpi gpio out sterujący przekaźnikiem światła. Jeśli później dojdzie aplikacja mobilna czy sterowanie głosowe, wystarczy dopiąć je do już istniejącej logiki, a nie przerabiać całą instalację elektryczną.

Powiadomienia i integracje: reagowanie na zdarzenia

Sama automatyka często nie wystarcza – przy pewnych warunkach trzeba także poinformować użytkownika. Node-RED dobrze sprawdza się jako „rozsyłacz” powiadomień do różnych kanałów.

E-mail, komunikatory i http request

Najprostsza droga to węzeł e-mail, który wysyła wiadomość, gdy dojdzie do określonego zdarzenia. Przykłady: przekroczenie poziomu zalania, awaria czujnika, brak odpowiedzi z istotnego serwisu.

Coraz częściej wygodniejsze są jednak powiadomienia przez komunikatory (np. Telegram, Signal, Slack) albo własne API. Do tego służą:

• węzły integrujące konkretne serwisy (często jako contrib) – wystarczy w nich skonfigurować token lub klucz API,
• węzeł http request – bardziej uniwersalny, pozwala wywołać dowolny endpoint REST, np. aplikację powiadomień na telefonie.

Cały przepływ sprowadza się wtedy do decyzji: „czy warunek jest spełniony?”. Jeśli tak – węzeł wyjściowy sam zadba o odpowiednią formę wiadomości, korzystając z informacji zawartej w msg.

Ograniczanie „szumu” powiadomień

Przy powiadomieniach łatwo przesadzić. Zamiast jednego komunikatu o zalaniu można przypadkiem wysłać kilkadziesiąt. Żeby temu zapobiec, przydają się:

• węzły rbe (report by exception) – przepuszczają wiadomość tylko wówczas, gdy wartość faktycznie się zmieniła,

Zapobieganie lawinom komunikatów

• węzły delay w trybie „rate limit” – opisane wcześniej, świetnie sprawdzają się do blokowania „burzy” zdarzeń,
• prosty licznik w węźle function – przechowywanie w flow lub global informacji, kiedy ostatnio wysłano powiadomienie,
• węzły typu „throttle/debounce” z palety społeczności – gotowe implementacje popularnych wzorców z programowania frontendowego.

Przykład praktyczny: przy czujniku dymu można chcieć jeden alarm e-mail i powiadomienie na komunikator, ale już nie 100 wiadomości w ciągu minuty. Jeden węzeł delay ustawiony na „max 1 wiadomość na 10 minut” zazwyczaj załatwia temat.

Przechowywanie danych: kontekst, pliki i bazy

Automatyzacje rzadko działają w pełni „chwilowo”. Często trzeba znać poprzedni stan, mieć zapis historii czy odwołać się do ustawień użytkownika. Do tego służą mechanizmy przechowywania danych.

Kontekst wiadomości, przepływu i globalny

W każdym przepływie pracuje się z trzema poziomami danych:

• msg – to, co płynie między węzłami (stan chwilowy),
• flow – dane wspólne dla jednego przepływu,
• global – dane wspólne dla całej instancji Node-RED.

Z poziomu węzła function można odczytać i zapisać dane np. tak:

// zapis wartości
flow.set("ostatniaTemperatura", msg.payload);

// odczyt wartości
let temp = flow.get("ostatniaTemperatura") || 0;

Na początku wygodnie jest używać kontekstu flow/global do prostych rzeczy: zapamiętania, że ktoś jest w domu, aktualnego trybu (dzień/noc), ostatniej wysłanej wartości z czujnika.

Trwały kontekst i restart Node-RED

Domyślnie dane w kontekście znikają po restarcie Node-RED. Żeby temu zapobiec, konfiguruje się tzw. persistent context w pliku settings.js. Prosty przykład konfiguracji (fragment):

contextStorage: {
    default: {
        module: "localfilesystem"
    }
}

Po włączeniu takiego magazynu dane z flow.set() i global.set() mogą być przechowywane na dysku. To wygodne przy ustawieniach użytkownika czy licznikach, które nie powinny się zerować przy każdym restarcie serwera.

Zapisywanie zdarzeń do pliku lub bazy

Jeżeli trzeba mieć historię danych z czujników, najlepiej skorzystać z jednego z gotowych mechanizmów:

• węzeł file – prosty zapis do pliku tekstowego lub JSON,
• węzły baz danych (sqlite, mysql, influxdb) – lepsze przy większej liczbie pomiarów i analizie historycznej.

Przykładowy przepływ dla prostego logu temperatury może wyglądać tak: mqtt in → change (dodanie znacznika czasu) → template (format CSV) → file (dopisywanie na końcu pliku). Taki plik da się potem otworzyć choćby w arkuszu kalkulacyjnym.

Panele sterowania: dashboard i interfejs webowy

Sam „silnik automatyzacji” często wystarcza, ale wygodnie mieć też prosty panel do podglądu i ręcznego sterowania. W tym zakresie bardzo popularne są węzły dashboard.

Budowa prostych widoków dashboard

Po zainstalowaniu pakietu typu node-red-dashboard w palecie pojawia się kilka nowych grup węzłów, m.in.:

• przyciski, suwaki, przełączniki,
• wskaźniki, wykresy, pola tekstowe,
• listy rozwijane, formularze.

Konfiguracja zazwyczaj sprowadza się do:

1. wybrania grupy i zakładki (np. „Salon”, „Ustawienia”),
2. powiązania widgetu z konkretnym msg.payload,
3. podpięcia go do logiki w przepływie (np. do węzła mqtt out albo function).

Efektem może być prosty panel: suwak ustawiający temperaturę zadaną, wykres ostatnich pomiarów, przycisk „tryb urlopowy”. Wszystko dostępne z przeglądarki, bez pisania aplikacji od zera.

Wejścia z dashboard jako zdarzenia

Widgety nie służą tylko do podglądu. Każda zmiana na przełączniku lub suwaku generuje wiadomość msg, którą można potraktować jak każde inne zdarzenie. Typowy układ:

• ui_switch – użytkownik ręcznie włącza tryb „gość”,
• change – zapisanie stanu do global.isGuestMode,
• switch w innych przepływach – reaguje inaczej, gdy ten tryb jest aktywny.

Taka kombinacja ręcznego sterowania i automatycznych reguł daje sporą elastyczność. W dniu wyjazdu wystarczy kliknąć jeden przełącznik, a resztą zajmą się istniejące przepływy.



Struktura projektu i porządkowanie przepływów

Z czasem na jednym serwerze Node-RED potrafi powstać kilkanaście lub kilkadziesiąt automatyzacji. Bez porządku robi się trudno cokolwiek znaleźć.

Podział na zakładki (flows)

Najprostsza metoda organizacji to tworzenie osobnych zakładek dla logicznie powiązanych funkcji. Przykładowy podział:

• „System” – monitorowanie stanu serwera, backup, logi,
• „Ogrzewanie” – wszystkie przepływy związane z temperaturą i zaworami,
• „Powiadomienia” – e-mail, komunikatory, szablony wiadomości,
• „Eksperymenty” – miejsce do testów, bez mieszania z produkcją.

Przy większej liczbie przepływów dobrze też zmienić domyślne nazwy węzłów na bardziej opisowe. Zamiast „function” lepiej „Oblicz histerezę” czy „Format e-maila o zalaniu”.

Grupowanie i komentarze

Do porządkowania na pojedynczej zakładce przydają się:

• grupy – kolorowe ramki obejmujące zestaw powiązanych węzłów,
• węzły comment – krótkie notatki opisujące cel danego fragmentu.

Prosty podpis „Wejście z czujnika ruchu w korytarzu” potrafi oszczędzić dużo czasu po kilku miesiącach, gdy trzeba coś poprawić lub rozbudować. Grupy z kolei ułatwiają wizualne oddzielenie np. części odpowiedzialnej za zbieranie danych od tej, która wysyła powiadomienia.

Diagnostyka i debugowanie przepływów

Przy pierwszych automatyzacjach najczęstszy problem to „nic się nie dzieje” albo „dzieje się inaczej niż trzeba”. Zamiast zgadywać, lepiej wykorzystać narzędzia wbudowane w edytor.

Panel debug i selektywne logowanie

Węzeł debug to podstawowe narzędzie analizy. Dobrym nawykiem jest:

• stawianie go zaraz za nowym fragmentem logiki,
• czasowe włączanie/wyłączanie (checkbox) zamiast kasowania,
• nadawanie mu opisowych nazw (np. „Wejście z czujnika drzwi” zamiast domyślnego „msg.payload”).

Gdy przepływ robi się gęsty, wygodniej jest logować nie tylko msg.payload, ale też całe msg. Wtedy w panelu debug można rozwinąć obiekt i zobaczyć wszystkie pola, które ustawiają węzły pośrednie.

Śledzenie przebiegu z użyciem statusów i node status

Niektóre węzły potrafią wyświetlać swój status pod ikoną (np. ostatni błąd, aktualnie przetwarzaną wartość). W węzłach function można dodatkowo wywołać:

node.status({fill:"green", shape:"dot", text:"OK: " + msg.payload});

W ten sposób da się np. na bieżąco widzieć temperaturę lub ostatni wysłany temat MQTT bez otwierania debug. W fazie testów ułatwia to szybkie odnalezienie miejsca, w którym przepływ „staje” lub zwraca niepoprawne dane.

Obsługa błędów i ścieżki „catch”

Gdy węzeł zgłasza błąd (np. nieudane połączenie HTTP), można go przechwycić w dedykowanym węźle catch. Typowe zastosowanie:

• catch – reaguje na błędy z określonych węzłów,
• switch – filtruje błędy krytyczne i mniej istotne,
• e-mail / komunikator – wysyła informację o poważnej awarii,
• delay + retry – po krótkim czasie podejmuje kolejną próbę połączenia.

Dzięki temu awarie zewnętrznych usług (np. chwilowy brak sieci) nie muszą usuwać całej logiki z równowagi. Przepływ może zachować się rozsądnie: spróbować jeszcze raz, a dopiero później zgłosić problem użytkownikowi.

Bezpieczeństwo i dostęp z zewnątrz

Node-RED często działa na domowym serwerze lub w małej firmie. Gdy pojawia się potrzeba dostępu spoza lokalnej sieci, od razu wchodzi temat bezpieczeństwa.

Hasło do edytora i ograniczenie dostępu

Domyślnie edytor nie jest zabezpieczony hasłem (szczególnie w instalacjach „domowych”). W pliku settings.js można włączyć:

• adminAuth – logowanie do edytora z użyciem nazwy użytkownika i hasła,
• httpNodeAuth – autoryzację dla endpointów HTTP wystawianych przez przepływy.

Dobrze też nie wystawiać portu Node-RED bezpośrednio do Internetu. Lepsze podejście to tunel VPN, reverse proxy z autoryzacją (np. Nginx, Traefik) lub dostęp tylko przez sieć firmową.

Bezpieczne przechowywanie haseł i tokenów

Integracje z API i komunikatorami wymagają kluczy i tokenów. Lepiej unikać wpisywania ich „na sztywno” w węzłach function. W zamian wygodniej używać:

• konfiguracji węzłów (pola „credentials”),
• zmiennych środowiskowych odczytywanych przez settings.js,
• zewnętrznych sejfów tajemnic (Vault, mechanizmy chmury), jeśli projekt tego wymaga.

Taki podział ułatwia też przenoszenie projektu między środowiskami – te same przepływy mogą działać w domu i w chmurze, zmieniają się tylko dane logowania.

Rozwijanie umiejętności: co dalej po pierwszych automatyzacjach

Po zbudowaniu kilku podstawowych przepływów naturalnym krokiem jest łączenie ich w większe scenariusze oraz stopniowe zastępowanie powtarzalnych fragmentów bardziej elastycznymi rozwiązaniami.

Wzorce wielokrotnego użycia

Często powtarza się ta sama struktura: wejście → walidacja → przeliczenie → powiadomienie. Zamiast kopiować te same węzły do każdego nowego przepływu, można:

• budować subflows – „pudełka” zawierające mini-przepływ wielokrotnego użytku,
• parametryzować je wejściami (np. progiem temperatury, adresem tematu MQTT),
• utrzymywać jedno miejsce, gdzie wprowadza się poprawki.

Przykład: jeden subflow obsługujący wysyłkę powiadomień z ograniczaniem częstotliwości. W każdym miejscu, gdzie jest potrzebny, wystarczy go podłączyć i ustawić kilka parametrów.

Stopniowe zwiększanie złożoności

Najbezpieczniejsza droga rozwoju to małe kroki:

• najpierw prosty warunek na jednym czujniku,
• później dodanie kolejnego źródła danych (np. harmonogram czasowy),
• na końcu scenariusze uwzględniające kilka czynników naraz: obecność domowników, pogodę, taryfę energii.

Takie podejście ułatwia lokalizowanie błędów i sprawia, że Node-RED pozostaje czytelny także po roku czy dwóch rozwijania projektu.

Najczęściej zadawane pytania (FAQ)

Czym jest Node-RED i do czego służy?

Node-RED to graficzne środowisko do tworzenia automatyzacji i integracji, oparte na tzw. przepływach (flows). Zamiast pisać kod w klasycznym języku programowania, budujesz logikę z gotowych węzłów (nodes), które przeciągasz na planszę i łączysz liniami.

Narzędzie powstało z myślą o IoT i automatyce, ale świetnie sprawdza się zarówno w prostym smart home, jak i w integracjach systemów przemysłowych. Użytkownik skupia się na tym, co ma się dziać (logika scenariusza), a nie na szczegółach składni języka programowania.

Czy do korzystania z Node-RED trzeba umieć programować?

Na start nie jest wymagana klasyczna umiejętność programowania. Większość prostych automatyzacji da się zbudować, używając gotowych węzłów wejścia, logiki i wyjścia oraz prostych ustawień w ich konfiguracji.

Podstawowe zrozumienie logiki (warunki, porównania, przepływ danych) bardzo pomaga, ale kod w JavaScript można wprowadzać dopiero wtedy, gdy chcesz tworzyć bardziej zaawansowane funkcje. Dzięki temu Node-RED dobrze sprawdza się jako „pierwszy język” automatyzacji dla początkujących.

Jak zainstalować Node-RED na komputerze (Windows, Linux, macOS)?

Aby zainstalować Node-RED na komputerze, najpierw potrzebujesz środowiska Node.js (najlepiej wersja LTS) odpowiedniego dla Twojego systemu operacyjnego. Po instalacji Node.js otwierasz terminal lub PowerShell i instalujesz Node-RED poleceniem z użyciem npm (globalnie).

Następnie uruchamiasz Node-RED komendą node-red i w przeglądarce otwierasz adres http://localhost:1880. Tam zobaczysz edytor przepływów, w którym możesz od razu zacząć tworzyć swoje pierwsze automatyzacje.

Czy Node-RED nadaje się do automatyki domowej (smart home)?

Tak, Node-RED jest bardzo popularny w prostych i średnio zaawansowanych instalacjach smart home. Umożliwia m.in. sterowanie oświetleniem, ogrzewaniem, przekaźnikami, integrację z czujnikami ruchu, temperatury czy wilgotności oraz wysyłanie powiadomień na telefon.

Przykładowe scenariusze to włączanie światła przy wykryciu ruchu, powiadomienia o otwarciu drzwi, czy sterowanie ogrzewaniem na podstawie prognozy pogody. Wszystko to można zbudować wizualnie, bez pisania długiego kodu.

Na jakich urządzeniach można uruchomić Node-RED (Raspberry Pi, serwer, chmura)?

Node-RED działa na wielu platformach: na zwykłym komputerze PC, na minikomputerach typu Raspberry Pi, na serwerach oraz w kontenerach Docker, a także w chmurze (np. na VPS lub platformach PaaS). Dzięki temu można dobrać środowisko do własnych potrzeb.

Dla automatyki domowej i prostych projektów świetnym wyborem jest Raspberry Pi, które może pracować 24/7, ma wyprowadzone piny GPIO i umożliwia bezpośrednie sterowanie przekaźnikami i czujnikami. Dla integracji głównie z usługami internetowymi wygodny bywa serwer lub instancja w chmurze.

Jak wygląda interfejs Node-RED i czy jest trudny w obsłudze?

Interfejs Node-RED to aplikacja webowa składająca się z trzech głównych części: palety węzłów po lewej stronie, centralnego obszaru przepływów oraz panelu bocznego z dodatkowymi informacjami i konfiguracją. Przeciągasz węzły z palety na planszę i łączysz je liniami, tworząc przepływy danych.

Dla początkujących interfejs jest stosunkowo intuicyjny, zwłaszcza jeśli wcześniej korzystali z jakichkolwiek narzędzi typu „przeciągnij i upuść”. Najważniejsze jest zrozumienie, że dane przepływają między węzłami jako wiadomości (msg), co ułatwia analizę i debugowanie automatyzacji.

Jakie są przykładowe zastosowania Node-RED dla początkujących?

Osoba początkująca może w krótkim czasie zbudować praktyczne rozwiązania, takie jak:

• proste scenariusze smart home (światła, powiadomienia, ogrzewanie),
• monitoring temperatury i wilgotności z zapisem do bazy i wykresami,
• integracje internetowe, np. pobieranie kursów walut, powiadomienia na Slack/Telegram,
• prosta automatyka sprzętowa na Raspberry Pi (sterowanie przekaźnikami, wentylatorami, logika start/stop).

Wszystkie te przykłady da się zrealizować głównie za pomocą gotowych węzłów, co czyni Node-RED przyjaznym narzędziem na start z automatyką i robotyką.

Kluczowe obserwacje

• Node-RED to graficzne środowisko do automatyzacji i integracji, które pozwala budować logikę z gotowych węzłów zamiast pisać tradycyjny kod.
• Dzięki koncepcji przepływów (flows), węzłów (nodes) i wiadomości (msg) użytkownik projektuje schemat przepływu danych wizualnie, co ułatwia zrozumienie i późniejszą modyfikację automatyzacji.
• Node-RED jest szczególnie przyjazny dla początkujących – pozwala skupić się na logice działania, a dopiero później, w razie potrzeby, stopniowo przechodzić do własnego kodu JavaScript.
• Środowisko jest elastyczne: sprawdza się zarówno w prostych automatyzacjach domowych (smart home, monitoring), jak i w integracjach systemów przemysłowych czy usług internetowych.
• Wiele praktycznych zastosowań da się zrealizować bez pisania ani jednej linii „klasycznego” kodu, korzystając jedynie z gotowych węzłów i ich konfiguracji.
• Node-RED działa na różnych platformach (PC, serwery, chmura, Raspberry Pi), a jego instalacja zwykle sprowadza się do zainstalowania Node.js i uruchomienia kilku prostych komend.
• Raspberry Pi jest szczególnie dobrym wyborem na serwer automatyzacji, bo może pracować 24/7, ma niskie zużycie energii i bezpośredni dostęp do pinów GPIO dla czujników i przekaźników.

Warte uwagi:

• 

  5 nietypowych zastosowań Raspberry Pi w Smart Home

• 

  Recenzja Raspberry Pi 5 – co nowego oferuje minikomputer?

• 

  AI na Raspberry Pi? Tak, to możliwe!

• 

  Raspberry Pi jako retro komputer

• 

  Czy warto zbudować własny serwer na Raspberry Pi?

• 

  Arduino czy Raspberry Pi? Co wybrać do nauki robotyki?