Sensmos

Twoje czujniki. Twoje dane. Twoja sieć.
Your sensors. Your data. Your network.

Mała płytka za kilka dolarów, która mierzy Twoje otoczenie i — razem z innymi w wielu krajach — sprawdza, jak naprawdę działa internet między domami. Za bycie online zarabia token GALU. Urządzenie, klucze i dane są Twoje, nie nasze.

A small board that costs a few dollars, measures your surroundings and — together with others across many countries — checks how the internet really works between homes. It earns the GALU token for staying online. The device, the keys and the data are yours, not ours.

Jak zacząćGet started ⬇ Pobierz aplikację⬇ Download the app ⚡ Wgraj firmware⚡ Flash firmware Zobacz mapę sieciSee the live map
Czym jest Sensmos

Czujniki, które mierzą Twój realny świat

Sensmos to sieć małych urządzeń — nodów — zbudowanych na płytce ESP32. Node stoi u Ciebie w domu i mierzy to, co się dzieje wokół: napięcie w gniazdku, siłę WiFi, temperaturę, wilgotność, cokolwiek do niego podłączysz. Odczyty widzisz w aplikacji i na wspólnej mapie, a node może na nie reagować lokalnie — alertem, automatyzacją albo przez Home Assistant. Bez chmury i bez zakładania konta.

GALU to token, którym sieć płaci za utrzymywanie noda online. Nie musisz się nim interesować, żeby korzystać z Sensmosa — ale to, co uzbierasz, jest naprawdę Twoje: portfel i klucze mieszkają na Twoim telefonie, nie u nas.

Mierzy

Node zbiera odczyty z czujników i publikuje je jako „encje".

Dzieli się

Dane trafiają do sieci i na żywą mapę; możesz je też udostępniać sąsiadom.

Zarabia

Co dobę naliczane są nagrody GALU proporcjonalnie do wkładu.

Jak to działa

Od czujnika do tokena

Node pakuje publiczne odczyty i wysyła je do sieci. Raz na dobę sieć podlicza, kto ile dołożył — ten dobowy cykl nazywamy epoką — i przyznaje GALU. Wszystko widzisz w aplikacji; wypłata na własny portfel to jedno dotknięcie.

Node
mierzy otoczenie
→
Sieć
zbiera i weryfikuje
→
Epoka
liczy nagrody
→
GALU
trafia do portfela

Nody potrafią też rozmawiać między sobą (subskrypcje danych) oraz z Home Assistant — bez chmury, lokalnie w Twojej sieci.

Obserwatorium internetu

Twój node bada internet — dom↔dom

Twój node robi jeszcze jedną rzecz, zupełnie w tle: razem z resztą sieci mierzy, jak naprawdę działa internet — widziany z mieszkań, nie z serwerowni. Speedtest mówi, jak szybkie jest Twoje łącze do najbliższego serwera testowego; Sensmos sprawdza, co dzieje się na trasach między zwykłymi domami, przez prawdziwe routery i osiedlowe łącza. Niczego nie konfigurujesz i niczego nie poczujesz.

Pomiar dom↔dom (punch)

Sieć dobiera dwa nody w parę, a sam pomiar leci bezpośrednio między nimi — bez żadnego serwera pośrodku. Wynik: prawdziwe opóźnienie, jitter i straty pakietów, takie, jakich doświadczają domy, nie datacentra.

Cykl sond

Co kilka minut node odpytuje usługi i sąsiadów czterema sposobami: icmp, tcp, dns, http. Gdy cel milczy, node śledzi trasę pakietów (traceroute), żeby ustalić, gdzie giną.

Zlecone monitory

Sieć sama rozdziela nodom pomiary usług — czy strona działa i jak szybko odpowiada, mierzone z wielu krajów naraz. Twój node po prostu je wykonuje; nic tu nie konfigurujesz. Własne pomiary robisz skryptami (sekcja „Co potrafi node").

Wyniki na żywo

Wszystko ląduje na mapie: opóźnienia między krajami, pajęczyna świeżych pomiarów, i ranking nodów — score 0–100 z opóźnień, strat i liczby partnerów pomiaru.

Koszt i prywatność. Sondy to pojedyncze pakiety — rzędu kilku KB na minutę. Adres IP noda nie jest publikowany: na mapie widać tylko pozycję (z rozmyciem), kraj i wyniki pomiarów.
Bez sprzętu

Nie masz noda? Wyślij dane, które już masz

Nie masz ESP32? Nie szkodzi. Wszystko, co potrafi wysłać żądanie HTTP — Home Assistant, ESPHome, skrypt na Raspberry Pi — może publikować odczyty na mapie jako node programowy (fioletowy), na żywo, z historią i wykresami. To ścieżka „tylko dane": bez portfela, bez GALU, bez rejestracji. Dobre na spróbowanie, zanim kupisz płytkę.

ESPHome

Komponent i kilka linijek YAML — wskazujesz sensory, a one lecą na mapę. Działa też odczyt: pobierasz dane innego noda jako swój sensor. Repo →

Home Assistant

Integracja HACS, tryb „tylko dane": wybierasz encje HA i publikujesz je na mapie — albo podglądasz dowolny node jako sensory w HA. Repo →

Dowolne źródło

Jeden POST /v1/ingest z kluczem (≥32 znaki) i listą wartości. Skrypt, serwer, Raspberry Pi — cokolwiek mówi HTTP.

Słaby sprzęt bez RAM na TLS (np. duży stos BLE)? W ESPHome dodaj insecure: true — wysyłka po zwykłym HTTP.

Jak zacząć

Od pustej płytki do działającego noda

Cała droga od zera: kupujesz płytkę, wgrywasz firmware z przeglądarki, instalujesz aplikację i łączysz jedno z drugim przez Bluetooth. Bez lutowania, bez kompilowania, bez zakładania konta.

Zdobądź płytkę ESP32
Wystarczy goła płytka za kilka dolarów. Obsługiwane: ESP32-WROOM (DevKit), ESP32-S3 (DevKitC-1), ESP32-S3 N16R8 i ESP32-C3 (SuperMini). Do tego kabel USB, który przesyła dane — nie każdy kabel „do ładowania" to potrafi.
Wgraj firmware z przeglądarki
Wejdź na sensmos.com/flash na komputerze (Chrome lub Edge), podłącz płytkę po USB, wybierz swój model i kliknij Install. Nic nie instalujesz — flashowanie idzie prosto z przeglądarki.
Zainstaluj aplikację
Android: pobierz sensmos.apk i zainstaluj (system zapyta o zgodę na instalację spoza sklepu — to normalne). Aplikacja sama pilnuje swoich aktualizacji.
Połącz node
Zasil płytkę, w aplikacji naciśnij „Połącz node" i włącz Bluetooth. Świeżo wgrany node rozgłasza się jako SENSMOS-xxxxxx — wybierz go z listy.
Podaj WiFi
Nazwa sieci 2,4 GHz + hasło (ESP32 nie widzi sieci 5 GHz). PIN zostaw domyślny — zmienisz go później w ustawieniach noda.
Poczekaj chwilę
Apka konfiguruje node, tworzy (lub odzyskuje) Twój portfel i robi krótką atestację — potwierdzenie przez Bluetooth, że to fizyczne urządzenie, a nie symulator.
Gotowe
Node łączy się z WiFi, zaczyna mierzyć i pojawia się na Twojej liście oraz na mapie. GALU nalicza się raz na dobę.
Node nie pojawia się na liście? Na Androidzie 11 i starszych skanowanie Bluetooth wymaga włączonej lokalizacji (GPS) — włącz ją i skanuj ponownie. Upewnij się też, że node jest w trybie konfiguracji: rozgłasza się jako SENSMOS-xxxxxx przy pierwszym starcie albo po przytrzymaniu przycisku serwisowego.
Masz już node? Na nowym telefonie wystarczy „Połącz node" — jeśli urządzenie ma kopię portfela, aplikacja zaproponuje jego odzyskanie przez Bluetooth.
Aktualizacje są automatyczne. Firmware wgrywasz raz — kolejne wersje node pobiera sam (OTA), weryfikując podpis sieci i sumę SHA-256. Nieudana aktualizacja cofa się do poprzedniej wersji.
Reflash płytki? Po ponownym wgraniu firmware urządzenie dostaje nowe ID. Przy dodawaniu w aplikacji włącz przełącznik „Odtwórz ID noda" i wskaż swój node offline z listy — płytka przejmie poprzednią tożsamość i historię (klucze pozostają świeże, node przejdzie ponowną atestację).
Portfel i GALU

Zarabiaj, wydawaj, wypłacaj

Portfel powstaje przy pierwszym nodzie i mieszka na Twoim telefonie — my nie mamy do niego dostępu. GALU nalicza się za czas online i aktywność nodów.

Bez darmowych punktów

Na start nie dostajesz darmowych środków — nikt nie dostaje. Płatnych funkcji sieci możesz używać od razu, „na kredyt" (saldo schodzi na minus, do limitu), ale wypłacisz dopiero to, co realnie zarobisz: nagrody najpierw spłacają minus, reszta jest Twoja. Dzięki temu każdy GALU w obiegu ma pokrycie w prawdziwej pracy nodów.

Wysłanie wiadomości0.50 GALU
Powiadomienie push0.30 GALU
Subskrypcja danych (doba)7 GALU
Jednorazowy zakup danych noda0.50 GALU

Wydane GALU nie znikają: wracają do puli nagród, a część jest spalana. Każda nagroda ma pokrycie w tokenach zdeponowanych w kontrakcie on-chain — sieć nie drukuje „wirtualnych" punktów.

Deposit

Wpłać GALU z portfela do sieci — zasila pulę, z której nody płacą za usługi.

Claim

Wypłać zarobione GALU z sieci na swój portfel (on-chain, Polygon).

MetaMask

Wyeksportuj klucz portfela (po PIN-ie noda) i podłącz go do MetaMask.

Nagrody · region

Promień pokrycia i unikalność regionu

Sieć premiuje nody tam, gdzie ich brakuje. Prosta zasada: im mniej sąsiadów w Twojej okolicy, tym wyższy mnożnik nagród. Samotny node w regionie dostaje 1.5×; node w gęstym skupisku — 0.8×:

200 km — zostajesz przy ≤ 2 sąsiadach1.5×
150 km — ≤ 31.4×
100 km — ≤ 41.3×
50 km — ≤ 51.2×
20 km — ≤ 61.1×
10 km — ≤ 71.0×
5 km — ≤ 80.9×
2 km / 1 km — dno drabiny0.8×

Jak to liczymy: algorytm schodzi po drabinie promieni od 200 km w dół i zatrzymuje się na pierwszym szczeblu, na którym liczba żywych sąsiadów (prawdziwych nodów z potwierdzoną pozycją, online w ostatniej dobie) mieści się w limicie. Dzięki temu samotny node z odległym miastem „za miedzą" nie jest karany za tamto skupisko, a nody offline po dobie przestają się liczyć — mnożniki odbudowują się same.

Co potrafi node

Więcej niż czujnik

Pomiary to dopiero początek. Node ma na pokładzie kilka narzędzi, które robią z niego małą, lokalną automatykę — wszystko działa na samej płytce, bez chmury:

Encje

Odczyty publiczne (pub.*) i własne (own.*) — podgląd w aplikacji i na mapie.

Skrypty

Proste automatyzacje na nodzie: „jeśli napięcie spadnie poniżej X → zrób Y" (do 4 kroków).

Akcje wiadomości

Gdy node odbierze wiadomość → wyślij push, zapisz dane lub uruchom skrypt.

Subskrypcje

Kupuj dane innego noda — pojawią się u Ciebie jako osobne encje.

Własny monitoring

Akcja ping w skrypcie mierzy Twój serwer lub usługę i robi z wyniku encję — domowy uptime-monitor. (Globalne sondy zleca sieć — tych nie konfigurujesz.)

Fetch z web

Node pobiera wartość z dowolnego API (HTTP GET + ścieżka JSON) i używa jej jak odczytu czujnika. Gotowe przepisy na Shelly i Fronius: Integracje.

Zdalny dostęp

Twój LAN w kieszeni — bez VPN

Node i tak cały czas utrzymuje połączenie wychodzące do sieci — tym samym kanałem możesz z telefonu wejść do swojego domowego LAN-u, z dowolnego miejsca na świecie. Bez publicznego IP, bez przekierowania portów, także za CGNAT — czyli tam, gdzie VPN po prostu nie wchodzi w grę.

Terminal SSH

Terminal do maszyn w Twojej sieci, prosto z telefonu. SSH jest szyfrowany end-to-end w aplikacji — node i sieć przekazują wyłącznie zaszyfrowane bajty.

Panel Home Assistant

Podgląd i sterowanie encjami Twojego HA — bez wystawiania Home Assistanta na internet.

Strony urządzeń

Panele WWW urządzeń w Twoim LAN (HTTP) dostępne przez tunel noda.

Jak włączyć

W aplikacji: Nody → wybierz node → integracje → Terminal. Tam znajdziesz przełącznik „Remote access na nodzie" — domyślnie wyłączony.

Model bezpieczeństwa

Dostęp ma wyłącznie właściciel noda — każde otwarcie tunelu jest podpisywane Twoim portfelem. Node akceptuje wyłącznie adresy prywatne (LAN) — przez tunel fizycznie nie da się wyjść na publiczny internet. Zasoby są przydzielane dopiero przy otwarciu sesji i zwalniane po jej zamknięciu.

Kompromis: node z włączonym remote access jest rzadziej wybierany do monitorów sieci (sieć preferuje wtedy innych kandydatów) — apka poinformuje Cię o tym przy włączaniu.

Powiadomienia

Sieć Cię informuje

Gdy zdarzy się coś ważnego (alarm, spadek napięcia, wiadomość), node może wysłać powiadomienie push na Twój telefon. Skonfigurujesz to w sekcji „Akcje" w ustawieniach noda — tytuł i treść z podpowiedziami (np. nadawca, treść wiadomości).

Home Assistant

Integracja bez chmury

Sensmos działa z Home Assistant lokalnie (HACS). Dane nodów pojawiają się jako sensory HA, a dane z HA możesz „wkarmić" do noda — z automatycznym przeliczaniem jednostek. Bez brokera, bez chmury.

Bezpieczeństwo

Twoje klucze, Twoje urządzenie

Klucz na telefonie

Klucz portfela nigdy nie opuszcza Twojego urządzenia; node ma własny klucz generowany lokalnie.

Ceremonia trust

Krótkie potwierdzenie przez Bluetooth, że to fizyczne urządzenie — chroni sieć przed symulatorami.

Kopia portfela

Zaszyfrowaną kopię portfela można trzymać na nodzie i odzyskać przez Bluetooth (po PIN-ie).

Przycisk serwisowy

Przytrzymanie przycisku na nodzie → tryb Bluetooth (zmiana WiFi, odzysk) lub reset.

Prywatność pozycji

Publiczna pozycja noda jest domyślnie rozmyta (fuzz). Tryb ghost zdejmuje node z mapy całkowicie — dalej uczestniczy w sieci, z obniżoną nagrodą. Adres IP nigdy nie jest publikowany.

Podpisane komendy i OTA

Komendy sieci (restart, aktualizacja) są podpisane kluczem sieci i jednorazowym nonce — node odrzuca wszystko inne. Firmware OTA weryfikuje SHA-256 i podpis; nieudany flash sam się cofa.

Dla zaawansowanych

API noda, encje i konfiguracja

Każdy node wystawia w Twojej sieci lokalne HTTP API — możesz nim sterować ze skryptu, integracji lub własnego narzędzia. Wszystkie wywołania (poza /info) wymagają nagłówka Authorization: Bearer <PIN>.

HTTP API (sieć lokalna)
GET/info
device_id, owner, wersja FW, status — bez autoryzacji
GET/POST/config
GPS (z apki), PIN, push_token, integration_url
GET/data/status
stan buforów: pub / own / pool
GET/data/native
whitelista encji natywnych pub.*
POST/data
{entity_id, value, unit} — dodaj jeden odczyt
POST/data/batch
{entities:[…]} — wiele odczytów naraz
GET/POST/DELETE/config/scripts
skrypty użytkownika
GET/POST/DELETE/config/messages
akcje wiadomości
GET/message/inbox
skrzynka — odbierz wiadomości
POST/message/ack
potwierdź odbiór wiadomości
POST/message/send
{to, message_id, payload} — wyślij wiadomość do innego noda
GET/node/log
ostatnie zdarzenia noda (wysyłki, wiadomości, błędy)
GET/remote/available
lista nodów, których dane można kupić
POST/remote/subscribe
{esp_id, days, prefix} — subskrybuj dane innego noda
GET/remote/data
jednorazowy zakup: wszystkie encje wskazanego noda
GET/wallet/balance
saldo (proxy do sieci)
GET/wallet/proof
dowód Merkle do wypłaty
POST/node/ble_mode
restart w tryb Bluetooth (re-atestacja, serwis)
POST/factory-reset
reset fabryczny — czyści konfig, zostawia klucz noda
Przykład. Wstrzyknięcie własnego odczytu z dowolnego urządzenia w sieci:
curl -X POST http://<ip-noda>/data \ -H "Authorization: Bearer 1234" \ -H "Content-Type: application/json" \ -d '{"entity_id":"own.temp_kotlownia","value":21.4,"unit":"°C"}'
Model encji

Encje grupowane są po prefiksie w entity_id — prefiks decyduje, gdzie odczyt trafia i czy idzie do sieci.

pub.*natywne pomiary z whitelisty — widoczne na mapie, liczą się do nagród
own.*Twoje dane / z integracji — wysyłane do sieci, ale nie publiczne na mapie
sub.* · get.* · msg.*subskrypcje, pobrania z web, wiadomości — bufor lokalny
tmp.*bufor roboczy skryptów — znika po restarcie
Skrypty i akcje

Skrypty (do 4 kroków)

Reguła {if, action, cooldown_s, data}. Akcje: webhook, push, send (wiadomość do innego noda), calc, aggregate, ping, fetch, report.

Akcje wiadomości

Trigger po message_id (lub *) → webhook / prefix (zapis do {prefix}.*) / script. Do 3 slotów.

Subskrypcje danych

POST /remote/subscribe {esp_id, days, prefix} — dane innego noda spływają do bufora jako <prefix>.*. Rozliczane dobowo.

Integracja (webhook out)

integration_url — node POST-uje zdarzenia (message_received, batch_sent, sub_received, ws_connected) jako {device_id, action, data}.

Konfiguracja (POST /config)
gps_lat, gps_lon, fuzzpozycja z GPS apki (city liczone serwerowo) — ręcznie się nie ustawia
pinPIN do API i Bluetooth — koniecznie zmień domyślny
push_tokentoken telefonu do powiadomień push
integration_urladres wychodzącego webhooka (np. Home Assistant)
Provisioning i serwis (Bluetooth)

Przy pierwszym starcie (lub po przytrzymaniu przycisku) node wchodzi w tryb BLE jako SENSMOS-xxxxxx. Aplikacja używa komend: auth (PIN, zapamiętywany przy pierwszym połączeniu), register (właściciel + WiFi + podpis challenge-response), trust_round/trust_sign (ceremonia atestacji), factory_reset. WiFi i Bluetooth nigdy nie działają naraz — przełączenie zawsze przez restart urządzenia.

Szczegóły kryptografii (klucze secp256k1, podpisywanie batchy, ceremonia trust przeciw symulatorom) — patrz sekcja Bezpieczeństwo.

FAQ

Częste pytania

Czy potrzebuję wiedzy technicznej?

Nie. Firmware wgrywasz z przeglądarki, node dodajesz w aplikacji przez Bluetooth i podajesz WiFi. Resztą zajmuje się aplikacja.

Ile to kosztuje?

Płytka ESP32 to kilka dolarów w dowolnym sklepie z elektroniką. Firmware i aplikacja są darmowe, node pobiera poniżej 1 W prądu. Żadnych opłat ani subskrypcji.

Skąd pobrać aplikację? Jest wersja na iOS?

Android: sensmos.apk — instalujesz raz, potem aplikacja sama proponuje aktualizacje. Wersji na iOS nie ma.

Co jeśli zgubię telefon?

Jeśli wcześniej zapisałeś kopię portfela na nodzie, odzyskasz go na nowym telefonie przez Bluetooth (po PIN-ie noda). Możesz też wyeksportować klucz do MetaMask.

Czy mogę wypłacić GALU od razu?

Możesz wypłacić tylko to, co zarobisz powyżej ewentualnego długu. Nie ma darmowych środków na start.

Czy node musi działać 24/7?

Nie musi, ale im wyższy uptime, tym wyższa nagroda. Node liczony jest proporcjonalnie do czasu online.

Czy moje dane są prywatne?

Publiczne encje trafiają do sieci i na mapę. Dane „własne" zostają lokalnie, chyba że sam je udostępnisz.

Aplikacja nie znajduje noda przez Bluetooth

Najczęstsza przyczyna: na Androidzie 11 i starszych skanowanie Bluetooth wymaga włączonej lokalizacji (GPS). Włącz lokalizację i Bluetooth, trzymaj telefon blisko noda i odśwież skan. Node rozgłasza się jako SENSMOS-xxxxxx przy pierwszym starcie albo po przytrzymaniu przycisku serwisowego.

Jakiej sieci WiFi potrzebuję?

2,4 GHz. ESP32 nie łączy się z sieciami 5 GHz.

Jak aktualizuję firmware?

Wcale — node robi to sam (OTA). Pobiera podpisany obraz, sprawdza sumę SHA-256 i restartuje się; nieudana aktualizacja cofa się automatycznie.

Wgrałem firmware od nowa i node ma nowe ID

Przy dodawaniu w aplikacji włącz „Odtwórz ID noda" i wybierz z listy swój node offline — płytka przejmie starą tożsamość i historię. Wymaga świeżego firmware i ponownej atestacji.

Czy pomiary internetu obciążają moje łącze?

Nie — to pojedyncze pakiety, rzędu kilku KB na minutę. Nie zauważysz ich nawet na słabym łączu.

Czy sieć publikuje mój adres IP?

Nie. Na mapie widać pozycję (z rozmyciem), kraj i wyniki pomiarów — adres IP nie jest publikowany.

What is Sensmos

Sensors that measure your real world

Sensmos is a network of small devices — nodes — built on the ESP32 board. A node sits in your home and measures what happens around it: mains voltage, WiFi strength, temperature, humidity, anything you plug into it. You see the readings in the app and on a shared map, and the node can react to them locally — with an alert, an automation, or through Home Assistant. No cloud, no account to create.

GALU is the token the network pays for keeping a node online. You don't have to care about it to use Sensmos — but what you collect is genuinely yours: the wallet and the keys live on your phone, not with us.

Measures

The node collects sensor readings and publishes them as "entities".

Shares

Data flows to the network and the live map; you can also share it with neighbors.

Earns

Every day rewards in GALU are credited proportionally to your contribution.

How it works

From sensor to token

The node batches its public readings and sends them to the network. Once a day the network tallies who contributed what — that daily cycle is called an epoch — and grants GALU. You see all of it in the app; withdrawing to your own wallet is one tap.

Node
measures surroundings
→
Network
collects & verifies
→
Epoch
computes rewards
→
GALU
lands in your wallet

Nodes can also talk to each other (data subscriptions) and to Home Assistant — no cloud, locally on your network.

The internet observatory

Your node probes the internet — home to home

Your node does one more thing, entirely in the background: together with the rest of the network it measures how the internet really works — as seen from homes, not datacenters. A speedtest tells you how fast your link is to the nearest test server; Sensmos looks at what happens on the routes between ordinary homes, through real routers and neighborhood links. You configure nothing and you won't feel a thing.

Home-to-home probes (punch)

The network pairs two nodes up, and the measurement runs directly between them — no server in the middle. The result: real latency, jitter and packet loss, the kind homes actually experience, not datacenters.

Probe cycle

Every few minutes the node checks services and peers four ways: icmp, tcp, dns, http. When a target goes silent, the node traces the packet route (traceroute) to find out where they vanish.

Directed monitors

The network hands out service checks to nodes on its own — is a site up, how fast does it respond, measured from many countries at once. Your node simply runs them; there is nothing to configure here. Your own checks are done with scripts (see "What a node can do").

Live results

It all lands on the map: latency between countries, a web of fresh measurements, and the node leaderboard — a 0–100 score from latency, loss and measurement-partner count.

Cost & privacy. Probes are single packets — a few KB per minute. The node's IP address is never published: the map shows only a fuzzed position, the country and measurement results.
No hardware

No node? Push the data you already have

No ESP32? No problem. Anything that can send an HTTP request — Home Assistant, ESPHome, a script on a Raspberry Pi — can publish readings to the map as a software node (purple), live, with history and charts. This is the "data only" path: no wallet, no GALU, no sign-up. A good way to try things out before you buy a board.

ESPHome

A component and a few lines of YAML — point at your sensors and they're on the map. It also reads: pull another node's data back as your own sensor. Repo →

Home Assistant

A HACS integration in "data only" mode: pick your HA entities and publish them to the map — or pull any node's data into HA as sensors. Repo →

Any source

One POST /v1/ingest with a key (≥32 chars) and a list of values. A script, a server, a Raspberry Pi — anything that speaks HTTP.

Memory-tight hardware with no RAM for TLS (e.g. a big BLE stack)? In ESPHome add insecure: true — it sends over plain HTTP.

Get started

From a bare board to a running node

The whole path from zero: buy a board, flash the firmware from your browser, install the app and connect the two over Bluetooth. No soldering, no compiling, no account to create.

Get an ESP32 board
A bare board for a few dollars is all it takes. Supported: ESP32-WROOM (DevKit), ESP32-S3 (DevKitC-1), ESP32-S3 N16R8 and ESP32-C3 (SuperMini). Plus a USB cable that carries data — not every "charging" cable does.
Flash the firmware from your browser
Open sensmos.com/flash on a computer (Chrome or Edge), plug the board in over USB, pick your model and click Install. Nothing to install — flashing runs straight from the browser.
Install the app
Android: download sensmos.apk and install it (the system will ask you to allow installs from outside the store — that's normal). The app keeps itself up to date.
Connect the node
Power the board, tap "Connect node" in the app and turn Bluetooth on. A freshly flashed node advertises as SENSMOS-xxxxxx — pick it from the list.
Enter WiFi
2.4 GHz network name + password (ESP32 can't see 5 GHz networks). Leave the default PIN — you'll change it later in the node settings.
Wait a moment
The app configures the node, creates (or restores) your wallet and runs a short attestation — a Bluetooth proof that this is a physical device, not a simulator.
Done
The node connects to WiFi, starts measuring and shows up on your list and on the map. GALU is credited once a day.
Node not showing up in the scan? On Android 11 and older, Bluetooth scanning requires Location (GPS) to be enabled — turn it on and scan again. Also make sure the node is in setup mode: it advertises as SENSMOS-xxxxxx on first boot or after holding the service button.
Updates are automatic. You flash the firmware once — the node fetches new versions itself (OTA), verifying the network signature and the SHA-256 checksum. A failed update rolls back to the previous version.
Reflashed the board? After a fresh flash the device gets a new ID. When adding it in the app, enable "Restore node ID" and pick your offline node from the list — the board takes over its previous identity and history (keys stay fresh; the node goes through attestation again).
Already have a node? On a new phone just tap "Connect node" — if the device holds a wallet backup, the app offers to restore it over Bluetooth.
Wallet & GALU

Earn, spend, withdraw

Your wallet is created with your first node and lives on your phone — we have no access to it. GALU is earned for time online and node activity.

No free points

There are no free starter funds — for anyone. You can use the network's paid features right away, "on credit" (your balance goes negative, up to a limit), but you can only withdraw what you genuinely earn: rewards pay off the debt first, the rest is yours. That way every GALU in circulation is backed by real node work.

Sending a message0.50 GALU
Push notification0.30 GALU
Data subscription (per day)7 GALU
One-off purchase of a node's data0.50 GALU

Spent GALU doesn't vanish: it flows back into the reward pool, and a slice is burned. Every reward is backed by tokens deposited in the on-chain contract — the network doesn't print "virtual" points.

Deposit

Move GALU from your wallet into the network — funds the pool nodes spend from.

Claim

Withdraw earned GALU from the network to your wallet (on-chain, Polygon).

MetaMask

Export your wallet key (behind the node PIN) and import it into MetaMask.

Rewards · region

Coverage radius and region uniqueness

The network rewards nodes where they're scarce. The simple rule: the fewer neighbors around you, the higher your reward multiplier. A lone node in a region gets 1.5×; a node in a dense cluster — 0.8×:

200 km — you stay with ≤ 2 neighbors1.5×
150 km — ≤ 31.4×
100 km — ≤ 41.3×
50 km — ≤ 51.2×
20 km — ≤ 61.1×
10 km — ≤ 71.0×
5 km — ≤ 80.9×
2 km / 1 km — bottom of the ladder0.8×

How it's computed: the algorithm walks down a ladder of radii from 200 km and stops at the first rung where the number of live neighbors (real nodes with a verified location, online within the last day) fits the limit. That way a lone node with a distant city "next door" isn't punished for that cluster, and offline nodes stop counting after a day — multipliers recover on their own.

What a node can do

More than a sensor

Measuring is just the start. The node carries a few tools that turn it into a small, local automation hub — everything runs on the board itself, no cloud:

Entities

Public readings (pub.*) and your own (own.*) — visible in the app and on the map.

Scripts

Simple on-node automations: "if voltage drops below X → do Y" (up to 4 steps).

Message actions

When a node receives a message → send a push, store data or run a script.

Subscriptions

Buy another node's data — it shows up as separate entities on your side.

Your own monitoring

The ping script action measures your server or service and turns the result into an entity — a home uptime monitor. (Global probes are assigned by the network — you don't configure those.)

Fetch from the web

The node pulls a value from any API (HTTP GET + a JSON path) and uses it like a sensor reading. Ready-made recipes for Shelly and Fronius: Integrations.

Remote access

Your LAN in your pocket — no VPN

The node keeps an outbound connection to the network at all times anyway — and over that same channel you can reach your home LAN from your phone, anywhere in the world. No public IP, no port forwarding, and it works behind CGNAT — exactly where a VPN simply isn't an option.

SSH terminal

A terminal into machines on your network, straight from your phone. SSH is encrypted end-to-end in the app — the node and the network relay only encrypted bytes.

Home Assistant panel

View and control your HA entities — without exposing Home Assistant to the internet.

Device pages

Web panels of devices on your LAN (HTTP), reached through the node's tunnel.

How to enable it

In the app: Nodes → pick a node → integrations → Terminal. There you'll find the "Remote access on the node" switch — off by default.

Security model

Only the node's owner has access — every tunnel opening is signed with your wallet. The node accepts private (LAN) addresses only — the tunnel physically cannot reach the public internet. Resources are allocated only when a session opens and freed when it closes.

The tradeoff: a node with remote access enabled is picked less often for network monitors (the network prefers other candidates) — the app tells you this when you flip the switch.

Notifications

The network keeps you posted

When something important happens (an alarm, a voltage drop, a message), a node can send a push notification to your phone. You configure it in the "Actions" section of the node settings — title and body with handy placeholders (e.g. sender, message content).

Home Assistant

Cloud-free integration

Sensmos works with Home Assistant locally (HACS). Node data shows up as HA sensors, and you can "feed" HA data into a node — with automatic unit conversion. No broker, no cloud.

Security

Your keys, your device

Key on your phone

The wallet key never leaves your device; the node has its own key generated locally.

Trust ceremony

A short Bluetooth proof that it's a physical device — protects the network from simulators.

Wallet backup

An encrypted wallet backup can live on the node and be restored over Bluetooth (behind the PIN).

Service button

Hold the button on the node → Bluetooth mode (change WiFi, recover) or reset.

Position privacy

A node’s public position is fuzzed by default. Ghost mode removes it from the map entirely — it keeps participating, at a reduced reward. The IP address is never published.

Signed commands & OTA

Network commands (reboot, update) are signed with the network key and a one-time nonce — the node rejects anything else. OTA firmware is verified by SHA-256 and signature; a failed flash rolls itself back.

For power users

Node API, entities & configuration

Every node exposes a local HTTP API on your network — drive it from a script, an integration or your own tool. Every call (except /info) needs the Authorization: Bearer <PIN> header.

HTTP API (local network)
GET/info
device_id, owner, FW version, status — no auth
GET/POST/config
GPS (from the app), PIN, push_token, integration_url
GET/data/status
buffer state: pub / own / pool
GET/data/native
whitelist of native pub.* entities
POST/data
{entity_id, value, unit} — add one reading
POST/data/batch
{entities:[…]} — many readings at once
GET/POST/DELETE/config/scripts
user scripts
GET/POST/DELETE/config/messages
message actions
GET/message/inbox
message inbox
POST/message/ack
acknowledge a message
POST/message/send
{to, message_id, payload} — send a message to another node
GET/node/log
recent node events (sends, messages, errors)
GET/remote/available
nodes whose data you can buy
POST/remote/subscribe
{esp_id, days, prefix} — subscribe to another node's data
GET/remote/data
one-off purchase: all entities of a given node
GET/wallet/balance
balance (proxy to network)
GET/wallet/proof
Merkle proof for claim
POST/node/ble_mode
reboot into Bluetooth mode (re-attest, service)
POST/factory-reset
factory reset — clears config, keeps the node key
Example. Inject your own reading from any device on the network:
curl -X POST http://<node-ip>/data \ -H "Authorization: Bearer 1234" \ -H "Content-Type: application/json" \ -d '{"entity_id":"own.temp_boiler","value":21.4,"unit":"°C"}'
Entity model

Entities are grouped by the prefix in entity_id — the prefix decides where a reading goes and whether it reaches the network.

pub.*native measurements from the whitelist — shown on the map, count toward rewards
own.*your data / integration — sent to the network but not public on the map
sub.* · get.* · msg.*subscriptions, web fetches, messages — local buffer
tmp.*scratch buffer for scripts — cleared on restart
Scripts & actions

Scripts (up to 4 steps)

A rule {if, action, cooldown_s, data}. Actions: webhook, push, send (message to another node), calc, aggregate, ping, fetch, report.

Message actions

Triggered by message_id (or *) → webhook / prefix (store into {prefix}.*) / script. Up to 3 slots.

Data subscriptions

POST /remote/subscribe {esp_id, days, prefix} — another node's data flows into the buffer as <prefix>.*. Billed daily.

Integration (webhook out)

integration_url — the node POSTs events (message_received, batch_sent, sub_received, ws_connected) as {device_id, action, data}.

Configuration (POST /config)
gps_lat, gps_lon, fuzzposition from the app's GPS (city computed server-side) — not set manually
pinPIN for API and Bluetooth — change the default
push_tokenphone token for push notifications
integration_urloutgoing webhook address (e.g. Home Assistant)
Provisioning & service (Bluetooth)

On first boot (or after holding the button) the node enters BLE mode as SENSMOS-xxxxxx. The app uses the commands: auth (PIN, remembered on first connect), register (owner + WiFi + challenge-response signature), trust_round/trust_sign (attestation ceremony), factory_reset. WiFi and Bluetooth never run at the same time — switching always goes through a device restart.

Crypto details (secp256k1 keys, batch signing, the anti-simulator trust ceremony) — see the Security section.

FAQ

Common questions

Do I need technical knowledge?

No. You flash the firmware from your browser, add the node in the app over Bluetooth and enter WiFi. The app handles the rest.

How much does it cost?

An ESP32 board is a few dollars at any electronics shop. The firmware and the app are free, and the node draws under 1 W of power. No fees, no subscriptions.

Where do I get the app? Is there an iOS version?

Android: sensmos.apk — install it once, then the app offers updates on its own. There is no iOS version.

What if I lose my phone?

If you saved a wallet backup on the node, you can restore it on a new phone over Bluetooth (behind the node PIN). You can also export the key to MetaMask.

Can I withdraw GALU right away?

You can only withdraw what you earn above any debt. There are no free starter funds.

Does the node need to run 24/7?

It doesn't have to, but higher uptime means higher rewards. A node is counted proportionally to its online time.

Is my data private?

Public entities go to the network and the map. "Own" data stays local unless you choose to share it.

The app can't find my node over Bluetooth

Most common cause: on Android 11 and older, Bluetooth scanning requires Location (GPS) to be enabled. Turn on Location and Bluetooth, keep the phone close to the node and refresh the scan. The node advertises as SENSMOS-xxxxxx on first boot or after holding the service button.

What WiFi do I need?

2.4 GHz. ESP32 does not connect to 5 GHz networks.

How do I update the firmware?

You don't — the node does it itself (OTA). It downloads a signed image, checks the SHA-256 sum and restarts; a failed update rolls back automatically.

I reflashed the board and the node has a new ID

When adding it in the app, enable "Restore node ID" and pick your offline node from the list — the board takes over the old identity and history. Requires recent firmware and re-attestation.

Do the internet probes load my connection?

No — they are single packets, a few KB per minute. You won't notice them even on a weak link.

Does the network publish my IP address?

No. The map shows a fuzzed position, the country and measurement results — the IP address is never published.