Rozwiązanie to, które nazywa się polingiem, jest proste ale powoduje pewne problemy. Alternatywą jest technologia WebSockets.

Po pierwsze każde wywołanie http jest na tyle powolne, że jest dostrzegalne i denerwujące w użytkowaniu. Dzieje się tak ponieważ wiąże się nawiązaniem połączenia na nowo.

Po drugie moja aplikacja serwerowa jest uruchomiona w chmurze Google i jest chroniona przez mechanizmy powiązane z jej load-balancerem. Mechanizmy te dość szybko odcięły moje ESP8266 od aplikacji, ponieważ uznały je za próbę ataku DoS (Denial of Service) Wydłużenie czasu pomiędzy wywołaniami do 1.5 sekundy, sprawiało że mój domowy adres IP otrzymywał bana raz tydzień, a nie kilka razy dziennie.
Ban sprawiał że albo płytka odbierająca sygnał z pilota nie mogła go dostarczyć do aplikacji w chmurze, albo płytka sterująca diodami LED nie była w stanie odebrać oczekiwanego stanu.

Technologia WebSockets zamiast wielu krótkich połączeń, nawiązywane jest jedno połączenie długo-żyjące, umożliwiające komunikację dwustronną dzięki temu

• praca routerów związana z całym stosem TCP wykonywana jest rzadziej
• brama ogniowa jest odpytywana znacznie rzadziej o pozwolenie na wejście, więc nie traktuje tych zapytań jako ataku.

Obsługa webSockets nie jest może super-skomplikowana ale po co to robić jak istnieje kilka bibliotek pomagających obsłużyć tą technologię. Pierwszą, która mi zadziałała i miała fajne API, była WebSockets2_Generic.

Podobnie jak inne biblioteki, instaluje się ją klikając w Arduino studio Sketch -> Include library -> Manage libraries.

Na wyświetlonej liście powinien znajdować się element WebSockets2_Generic

Aby wykorzystać tą bibliotekę należy zaimportować biblioteki związane z konfiguracją WiFi oraz bibliotekę WebSockets2_Generic.

Biblioteka zawiera przestrzeń nazw websockets2_generic, a ta klasę WebsocketsClient.

#include <WebSockets2_Generic.h>

#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>
#include <WiFiClient.h>

ESP8266WiFiMulti WiFiMulti;

using namespace websockets2_generic;

WebsocketsClient client;

void setup() {
  WiFi.mode(WIFI_STA);
  WiFiMulti.addAP("<SSID>", "<Password>");

  pinMode(3, OUTPUT);

  client.onMessage(onClientMessage);
}

void onClientMessage(WebsocketsMessage message) {
  if(message.data() == "true") {
    digitalWrite(3, HIGH);
  } else {
    digitalWrite(3, LOW);
  }
}

void loop() {
  if (WiFiMulti.run() != WL_CONNECTED) {
    return;
  }
  if (!client.available()) 
  {
    if(!client.connect("<server-dns-name-or-ip>", 80, "<path>")) {
      return;
    }
  }

  client.poll();
}

Klasa posiada 5 metod:

• available – sprawdza czy połączenie z serwerem jest nawiązane
• connect – otwiera połączenie z serwerem, niestety metoda nie przyjmuje url tylko 3 argumenty: adres serwera, port na którym nasłuchuje serwer, ścieżka na serwerze
• send – wysyła wiadomość do serwera – w tym kodzie nie używana
• onMessage – przyjmuje jako parametr metodę wywołaną gdy serwer nada wiadomość
• poll – wywoływana w metodzie loop – zawiera komunikację z serwerem

To w zasadzie wszystkie zmiany po stronie urządzenia, pozostaje tylko tak zmienić kod serwera.

Po zastosowaniu tych zmian odbiornik reaguje praktycznie natychmiastowo.

Inne artykuły związane z Internetem rzeczy

Urządzenia oparte o ESP8266 mogą bardzo łatwo korzystać z dobrodziejstw tego rozwiązania.

Pod względem sprzętowym wystarczy jeden czujnik podczerwieni. Przykładem takiego czujnika jest VS1838B. Układ ten jest fotorezystorem opakowanym w plastik, który znacznie lepiej przepuszcza podczerwień niż światło widzialne. Dodatkowo układ ten zawiera serię filtrów i wzmacniaczy, których zadaniem jest oddzielić sygnał wysłany przez pilot od innych źródeł podczerwieni w otoczeniu (np. nagrzewającej się elektroniki).

Całość zamknięta jest w metalową obudowę, która wpuszcza tylko promieniowanie biegnące od przodu układu, co zabezpiecza przed odbieraniem sygnałów odbitych od ścian.

Najważniejszą zaletą tego układu jest cena. W Polsce można go dostać poniżej złotówki za sztukę, a na znanym chińskim portalu bez problemu udało mi się znaleźć ofertę po 25 groszy przy zakupie 100 sztuk.

Układ posiada 3 nóżki (od lewej): zasilanie, masa i wyjście. Ich podłączenie jest dość intuicyjne: nóżkę zasilania należy połączyć z zasilaniem ESP8266, masę z masą układu, a wyjście z dowolnym wejściem.

Producent zaleca dodatkowo dodanie trzech elementów, nie znalazłem jednak uzasadnienia ich użycia (działa bez nich). Elementy te to:

• Opornik 100 Ohm między źródłem zasilania, a wejściem VCC – prawdopodobnie służy ograniczeniu prądu płynącego przez układ
• Opornik 20 kOhm między nóżkami VCC i OUT – wiele układów cyfrowych potrafi się nie uruchomić jeżeli któreś jego wejście jest połączone z masą, w przypadku ESP8266 są to złącza IO2, IO4 i RX – przy czym nie sam nie zaobserwowałem tego problemu w połączeniu z VS1828B
• Kondensator 100 mikro-Farad między zasilaniem, a masą – absolutnie nie mam pojęcia jaką rolę w tym układzie pełni ten element – pewnie jakbym miał oscyloskop to mógłbym sprawdzić.

Układ wysyła szeregowo otrzymaną treść. Dekodowanie tej treści nie jest łatwym zadaniem na szczęście, są gotowe biblioteki, które to robią.

Dla układów Arduino istnieje biblioteka IRremote, niestety nie można jej wykorzystać przy pracy z ESP8266, istnieje jednak jej port IRremoteESP8266.

Aby ją zainstalować otworzyłem Arduino studio i kliknąć Sketch -> Include Library -> Manage Libraries.

W polu wyszukiwania wpisałem „IRremoteESP8266” i kliknąć przycisk „Install”.

Biblioteka zawiera dużą ilość klas i narzędzi, jednak do odbioru sygnału z pilota wystarczy moduł IRrecv, który zawiera klasy IRrecv oraz decode_results. Instancję pierwszej należy zainicjować oraz zadeklarować instancję drugiej.

#include <IRrecv.h>

IRrecv irrecv(2);
decode_results results;

void setup() {
  irrecv.enableIRIn();
}

void loop() {
  if (irrecv.decode(&results)){
    int resVal = results.value;

    // TODO: Do something with resVal

    irrecv.resume();
  }
  delay(100);
}

Metoda setup zawiera wywołanie enableIRIn, która przygotowuje układ i klasę do odbioru sygnału. Metoda loop zawiera wywołanie metody decode, metoda ta zwraca true jeżeli klasie udało się zdekodować sygnał.

Metoda przyjmuje jako parametr wskaźnik na pole typu decode_results w które wpisywane są wyniki dekodowania sygnału.

Najważniejszym polem wyników jest value – kod wciśniętego przycisku.

Po zakończeniu obsługi sygnały należy wywołać metodę resume – dającą bibliotece sygnał, że można dekodować kolejną wartość.

Inne artykuły związane z Internetem rzeczy

Na szczęście istnieją sposoby na wzmocnienie sygnału cyfrowego.

Skoro mikrokontroler nie jest w stanie zasilić odbiornika, odbiornik musi mieć swoje własne źródło zasilania, które jest podłączane gdy mikrokontroler dostarczy sygnału i odłączone gdy sygnał ustaje. Urządzeniem które tak działa jest przekaźnik.

Na zdjęciu widać 3 urządzenia po lewej znajduje się przekaźnik elektromagnetyczny, po środku znajduje się urządzenie sprzedawane jako „moduł przekaźnika” czyli przekaźnik opakowany w kilka elementów elektronicznych sprawiających że łatwiej go użyć majsterkowiczom. Trzecim urządzeniem jest moduł przekaźnika półprzewodnikowego SSR (solid-state-relay).

Przekaźniki elektromagnetyczne zawierają przełącznik i cewkę, po podaniu napięcia na cewkę przełącznik zostaje włączony/wyłączony, a po odjęciu zasilania wraca na pierwotną pozycję.

Przekaźniki półprzewodnikowe nie posiadają ruchomych części, dzięki czemu podczas pracy nie wydają dźwięku i się mniej psują. Dodatkowo nie posiadają też elementów magnetycznych . Niestety mają trochę wyższą cenę. Należy też je dobierać do zastosowania, ponieważ mają wąsko określony typ sterowanego prądu (stały, zmienny) oraz moc. przekaźnik elektromagnetyczny jest bardziej elastyczny.

Standardowym układem pokazującym pracę przekaźnika jest sterowanie napięciem 220V przy pomocy małego przycisku i baterii.

Osobiście zbudowałem podobny układ w którym mały przełącznik przez który może płynąć do 50mA steruje listwami LED wymagającymi 2A.

Cały układ można by zbudować bez przekaźnika, wykorzystując większy przełącznik, jednak w tym przypadku musiał on się zmieścić w szczelinie drzwi szafy. Aby ograniczyć prąd płynący przez przełącznik wystarczyło zastosować silny opornik. Jako ciekawostkę podam, że moduły przekaźników zazwyczaj posiadają taki opornik.

Cyfrowy bliźniak

Podczas projektowania systemów IoT często wykorzystuje się wzorzec architektoniczny „Cyfrowy bliźniak”.

Polega on na stworzeniu cyfrowego modelu fizycznego przedmiotu, zawierającego jego oczekiwany stan oraz opis zachowań w reakcji na zdarzenia. Model ten może ulegać częstym zmianom i poprawkom więc umieszczenie go na serwerze dostawcy albo w chmurze obliczeniowej jest rozsądnym rozwiązaniem.

Fizyczny obiekt jest opleciony czujnikami, pozwalającymi obserwować zarówno jego samego jak i jego otoczenie, oraz elementami sterującymi (silniki, grzałki, chłodnice, diody) pozwalającymi ten obiekt zmieniać. Elementy te są połączone z kilkoma układami cyfrowymi. Kod na tych układach jest dość prosty: pobrać dane z serwera na temat oczekiwanego stanu sterowanych elementów, ewentualnie wysłać na serwer informacje o istotnych odczytach z czujników (zdarzeniach).

Kod serwera

W przypadku tego projektu kod serwera jest prosty. Serwer ma mieć dwa kanały komunikacji: jeden pozwalający lampce dowiedzieć się czy jest włączona i drugi którym przycisk przekazuje informację że został wciśnięty. Ważną zaletą tego rozwiązania jest fakt że przycisk nie wie że lampa istnieje i vice versa. Pozwala to rozszerzać układ o dodatkowe elementy (czujniki ruchu, nauczanie maszynowe) bez konieczności zmiany kodu na urządzeniach.

Serwer zrealizowałem jako aplikację web, wykorzystującą protokół http, która posiada dwa punkty końcowe: /led i /button odpowiadające urządzeniom.

Oczekiwany stan urządzenia jest zwracany jako odpowiedź na wywołanie GET, ponieważ układ z przyciskiem nie posiada oczekiwanego stanu jest on zaimplementowany tylko dla diody. Punkt /led zwraca wartość „ON” albo „OFF” w zależności od tego czy w danym momencie dioda ma być włączona czy zgaszona.

Zdarzenia są rejestrowane w obsłudze wywołań POST, która pozwala na przesłanie szczegółów zdarzenia w ciele metody. Układ z diodą LED nie generuje żadnych zdarzeń, więc punkt działa tylko dla przycisku. Wciśnięcie przycisku przycisku nie niesie ze sobą żadnych dodatkowych informacji więc ciało wywołania jest ignorowane. Stan diody jest przechowywany w pamięci RAM co ułatwia implementację.

Aplikację można zrealizować w dowolnej nowoczesnej technologii, ja zdecydowałem się ASP.Net MVC Core. Można ją jednak zaimplementować w dowolnej technologii.

Drobna uwaga dotycząca technologii PHP. Zmienne statyczne w tej technologii są dostępne w zakresie wywołania, przez co stan diody nie może być przechowywany w pamięci należy ją przechowywać w zewnętrznym magazynie np. plik, cache Redis albo baza danych.

Aplikację stworzyłem tworząc katalog Twin, otwierając w nim okno poleceń i wpisując w nią:

dotnet new webapi

Polecenie wymaga wcześniejszego zainstalowania środowiska .Net core dostępnego na stronie https://dotnet.microsoft.com/download pod przyciskiem „Download .Net Core SDK”

Następnie usunąłem klasę ValueController znajdującą się w katalogu Controllers oraz dodałem klasę IndexController.

using Microsoft.AspNetCore.Mvc;

namespace Twin.Controllers
{
    [ApiController]
    public class ValuesController : ControllerBase
    {
        private static string _ledState = "ON";
        
        [HttpGet("led")]
        public ActionResult<string> Get()
        {
            return _ledState;
        }

        
        [HttpPost("button")]
        public void Post()
        {
            _ledState = _ledState == "ON" ? "OFF" : "ON";
        }
    }
}

Szablony w .net core domyślnie wymuszają szyfrowaną komunikację (https), co jest wskazane dla rozwiązań produkcyjnych, jednak nadmiarowo komplikuje ten przykład. Aby wyłączyć to zachowanie należy z pliku Startup.cs usunąć linijkę:

app.UseHttpsRedirection();

Natomiast w pliku Program.cs zmienić metodę CreateWebHostBuilder na:

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .UseKestrel(opt => { opt.ListenAnyIP(5000); })
        .UseStartup<Startup>();
}

Ostateczna wersja programu jest do pobrania pod tym linkiem: Twin.zip. Aby go uruchomić należy rozpakować archiwum, otworzyć wiersz poleceń w katalogu gdzie je rozpakowano i wpisać:

dotnet run

Aplikacja zacznie nasłuchiwać na połączenia na porcie 5000.

Nowe wpisy przestały się pojawiać w Elastic search. Sprawdziłem czy procesy działają, ale działały. Następnie zajrzałem do logów Logstasha i znalazłem tam wpis z komunikatem:

"reason"=>"blocked by: [FORBIDDEN/12/index read-only / allow delete (api)];"

Był tam też drugi wpis wskazujący, że chodzi o index nazywający się logstash-2019.12.28-0002. Logstash tworzy domyślnie politykę w ES, która ustawia flagę „read_only_allow_delete” na starych indeksach. Stwierdziłem, że któraś z usług wygenerowała dziwny wpis, z datą z przeszłości i że wskazany powyżej index należy odblokować. Tak też zrobiłem, co odblokowało cały mechanizm.

Niestety na drugi dzień problem się powtórzył. Okazało się że mam tylko dwa indeksy z przedrostkiem „logstash-” i oba z 28-go grudnia. Śledztwo doprowadziło mnie do tego błędu zgłoszonego na Github. Okazuje się, że domyślny format nazwy indeksu używany przez Logstash – „logstash-%{+YYYY.MM.dd}”, zawiera duże litery Y, co oznacza, że nazwa indeksu powinna zawierać rok bieżącej epoki, w przypadku naszego kręgu kulturowego jest to ilość lat od błędnie wyznaczonej daty narodzenia Chrystusa. Okazuje się, że na niektórych platformach ten format nie działa, a ja miałem pecha używać takowej.

Rozwiązaniem jest zmiana formatu indeksu na taki zawierający małe litery y.

index => "logstash-%{+yyyy.MM.dd}"

Także na zakończenie tego wpisu, życzę wam wszystkim żeby ludzkość jak najszybciej przeszła na UTC.

Ponieważ istnieje pewna grupa ludzi czepiająca się definicji, doprecyzuję, że jako przycisk w dalszej części artykułu rozumiem: przełącznik monostabilny – czyli taki który po naciśnięciu wraca do oryginalnego stanu: np. dzwonek do drzwi albo klawisz w klawiaturze.

Osobom którzy chcą nauczyć się czegoś więcej o przełącznikach i przyciskach polecam ten klip z kanału RS Elektronika.

O ile poprzedni projekt dało się zrealizować posiadając tylko układ i programator. Płytka nie posiada jednak wbudowanego przycisku, należy więc podłączyć zewnętrzny. W mojej szafie znalazłem takie dwa:

Przycisk po lewej ma cztery nóżki. W stanie spoczynku prąd może przepływać pomiędzy nóżką 1 i 3 oraz między 2 i 4, po wciśnięciu prąd przepływa z dowolnej do dowolnej.

Przycisk jest tak naprawdę dwoma przyciskami powiązanymi mechanicznie. W stanie spoczynku prąd przepływa między nóżkami 1 i 3 oraz 2 i 4, po wciśnięciu prąd przepływa między przyciskami 3 i 5 oraz 4 i 6. Prąd nigdy nie przepływa między prawą i lewą kolumną. Na rynku dostępne są różne konstrukcje, dlatego w dalszej części założę, że przycisk jest podpięty tak aby przewodził prąd między wejściem i wyjściem gdy jest wciśnięty.

Ponieważ poprzedni projekt nie wymagał dodatkowych elementów, mogłem wykorzystać programator jako źródło zasilania, tym razem musiałem zdecydować się na koszyczek do baterii z lampki rowerowej, wykorzystałem trzy, połączone szeregowo, akumulatorki AA o napięciu 1,2V.

Do złożenia układu pomocna też była płytka prototypowa (tzw. breadboard). Płytka taka posiada wiele dziurek pozwalających na podłączenie przewodów lub elementów elektronicznych. Dziurki te są połączone ze sobą tak jak przedstawiono na zdjęciu: dwie boczne kolumny są połączone pionowo, a pozostałe zaś poziomo. Skrajne kolumny są, zwyczajowo, wykorzystywane do podłączenia zasilania. W sprzedaży są dostępne kable z końcówkami pasującymi do takich płytek.

Każde urządzenie musi zawierać podłączony do internetu komputer z zestawem wejść i wyjść aby móc to urządzenie monitorować i nim sterować. Komputer ten musi być tani, mały, pobierać niewiele energii i być programowalny.

Raspberry Pi oraz Arduino spełniają te wymagania, jest jednak układ który spełnia je bardziej: ESP8266 – chiński programowalny mikrokontroler wspierający TCP IP, WiFi, posiadający porty wejścia i wyjścia, niski pobór mocy. Jest on też naprawdę tani: od $0.50 w hurcie do $1 w detalu. Dodatkowo układ ten jest częściowo kompatybilny z Arduino dzięki czemu narzędzia stworzone dla tej popularnej płytki.

Sam chip nie nadaje się do zastosowań amatorskich ze względu na obudowę wymagającą montażu powieszchownego (SMD). Na szczęście są firmy sprzedające ten moduł przylutowany do płytki zawierającej prymitywną antenę wifi oraz bardziej przyjazne złącza. Przykładami takich płytek są NodeMCU oraz ESP01, Płytki te można w Polsce kupić między 10 a 20zł, w Chinach poniżej $3. Ja zdecydowałem się na zakup ESP01.

Płytka posiada 8 złączy:

• 3V3 – zasilanie zalecane napięcie to 3.3 Volt, zgodnie z tym wątkiem urządzenie działa stabilnie w zakresie 2.5-3.8V
• GND – masa
• Rx,Tx – Wykorzystywane do transmisji szeregowej, mogą też być przełączone w tryb „zwykłych” wejść/wyjść
• IO0, IO2 – piny wejścia/wyjścia
• RST – podanie napięcia na ten pin resetuje układ
• EN(CH_PD) – podanie napięcia na ten pin i reset pozwala przejść w tryb programowania.

Przygotowanie stanowiska pracy

Programy uruchamiane na ESP8266 można pisać w języku LUA albo w C++ w Arduino IDE. Ja wybrałem tą drugą opcję. Arduino IDE jest do pobrania na stronie: https://www.arduino.cc/en/Main/Software.

Arduino IDE instaluje sterowniki urządzeń USB, co wymaga uprawnień administratora.

Domyślnie Arduino IDE nie wspiera ESP, aby wspierało należy doinstalować „zarządcę płytków”. W oknie Arduino IDE należy wybrać File > Preferences i w polu „Additional board managers” wkleić:

https://arduino.esp8266.com/stable/package_esp8266com_index.json

Po restarcie Arduino IDE należy kliknąć „Tools > Board: „XXXXXXXXXXXXXX” > Boards Manager …”, w polu tekstowym wpisać „ESP8266” i kliknąć install na elemencie: „esp8266 by ESP8266 Community”.

Na koniec należy kliknąć „Tools > Board: XXXXXXXX > Generic ESP8266 Module”.

• Zmiana stanu obiektu gdy jest on przekazany do metody, zwłaszcza funkcji, której nazwa sugeruje że jest to bezpieczne
• Zmiana stanu w wyniku współbieżnego dostępu do jednego obiektu

Z pierwszym przypadkiem można sobie poradzić przez bardzo restrykcyjne pilnowanie innych członków zespołu na przeglądach kodu, to rozwiązanie zawodzi gdy korzystamy z zewnętrznych bibliotek.

Drugi problem nie występuje do puki nie współdzielimy obiektów między wątkami. Z taką sytuacją mamy do czynienia na początku rozwoju każdej aplikacji. Wystarczy jednak wprowadzić dodatkowy wątek (np. przez użycie niektórych metod asynchronicznych), albo dodać statyczne pole do kontrolera aby się na niego narazić.

Rozwiązaniem obu problemów są obiekty niezmienne, czyli takie, czyli takie których pola nie ulegają zmianie po utworzeniu. W C# i Javie aby stworzyć klasę, której instancje będą niezmienne należy zadeklarować wszystkie pola jako prywatne, ustawić je w konstruktorze i nie udostępnić żadnej metody je modyfikujące.

public class Address 
{
	private readonly string addressLine1;
	private readonly string addressLine2;
	private readonly string zipCode;
	private readonly string city;
	private readonly string stateArea;
	private readonly string country;

	public Address(string addressLine1, string addressLine2, string zipCode, string city, string stateArea, string country)
	{
		 this.addressLine1 = addressLine1;
		 this.addressLine2 = addressLine2;
		 this.zipCode = zipCode;
		 this.city = city;
		 this.stateArea = stateArea;
		 this.country = country;
	}

	public string AddressLine1 { get { return addressLine1; } }
	public string AddressLine2 { get { return addressLine2; } }
	public string ZipCode { get { return zipCode; } }
	public string City { get { return city; } }
	public string StateArea { get { return stateArea; } }
	public string Country { get { return country; } }
}

Problemy językowe

Obiekty niezmienne są jednak słabo wspierane przez C# i Javę.

Pierwszym problemem są pola opcjonalne, domyślnie konstruktor musi ustawić wszystkie, więc albo użytkownik takiego obiektu musi przekazać wartości domyślne do takiego obiektu.

Jeżeli obiekt ma wiele pól to konstruktor staje się długi, a pomyłki związane z przekazaniem wartości do złego pola trudno zauważalne. Poniższy kod zawiera błąd, jednak wcale nie wygląda podejrzanie:

var address = new Address (
	"Konwaliowa 31/20",
	"20036",
	"Lublin",
	"",
	"",
	"");

Jakimś rozwiązaniem jest zastosowanie przeciążeń konstruktora i wartości domyślnych dla jego parametrów, to rozwiązanie sprawdza się gdy klasa ma do 3-4 opcjonalnych pól, przy większej ilości szybko prowadzi do eksplozji kombinatorycznej ilości konstruktorów.

Problem staje się jeszcze bardziej dotkliwy gdy pojawia się potrzeba „zmodyfikowania” takiego obiektu, ponieważ obiektu nie da się zmienić, należy utworzyć nowy obiekt i przekazać do niego zarówno wartości zmienionych pól jak i tych, które zostają bez zmian.

var templateAddress = new Address(
	"Konwaliowa 31/20",
	"",
	"20036",
	"Lublin",
	"Lubelskie",
	"Polska");

var modifedAddress = new Address(
	"Konwaliowa 31/21",
	templateAddress.AddressLine2,
	templateAddress.ZipCode,
	templateAddress.City,
	templateAddress.StateArea,
	templateAddress.Country);

Zauważyłem też że powszechną, ale błędną, praktyką jest modyfikowanie wielu pól przy pomocy łańcucha poleceń set.

const newState = oldState
    .set('field1', 'value1')
    .set('field2', 'value2')
    .set('field3', 'value3');

Podejście to sprawia, że za każdym wywołaniem metody set tworzona jest nowa, na szczęście płytka, kopia mapy ze zmienionym jednym polem.

Poprawę wydajności można uzyskać wykorzystując metodę withMutations.

const newState = oldState.withMutations(map => {
    map
    	.set('field1', 'value1')
        .set('field2', 'value2')
        .set('field3', 'value3');
    });

Mierz wyniki

Użycie tej metody nie gwarantuje jednak poprawy wydajności. Poniższy test zawiera 2 skraje przypadki użycia obu podejść:

const Map = require('immutable').Map;
const {
  performance
} = require('perf_hooks');

function test(tested) {
	const before = performance.now();
	for (let i = 0; i < 1000; i++) {
		tested();
	}
	return performance.now() - before;
}

let map = new Map();
const mapSet1 = test(function() {
	map.set("field1", "value");
});

map = new Map();
const mapWithMutations1 = test(function() {
	map.withMutations(map2 => {
		map2.set("field1", "value");
	})
});

map = new Map();
const mapSet2 = test(function() {
	map
		.set("field1", "value1")
		.set("field2", "value2")
		.set("field3", "value3")
		.set("field4", "value4")
		.set("field5", "value5")
		.set("field6", "value6")
		.set("field7", "value7")
		.set("field8", "value8")
		.set("field9", "value9");
});

map = new Map();
const mapWithMutations2 = test(function() {
	map.withMutations(map2 => {
		map2.set("field1", "value1");
		map2.set("field2", "value2");
		map2.set("field3", "value3");
		map2.set("field4", "value4");
		map2.set("field5", "value5");
		map2.set("field6", "value6");
		map2.set("field7", "value7");
		map2.set("field8", "value8");
		map2.set("field9", "value9");
	})
});

console.log({
	mapSet1,
	mapWithMutations1,
	mapSet2,
	mapWithMutations2
});

Na mojej maszynie uzyskałem następujący wynik:

{
  mapSet1: 0.9362990260124207,
  mapWithMutations1: 1.4729009866714478,
  mapSet2: 23.789600014686584,
  mapWithMutations2: 13.4621000289917
}

Sales Tax

W Stanach ceny na półkach sklepowych nie zawierają podatku od sprzedaży (ST – Sales Tax). Podatek ten jest nawet wyliczony w podsumowaniu paragonu.

Ludzie żyjący w Stanach wrzucają ten podatek w kategorię „Podatki”. Z punktu widzenia konsumenta podatek ten jest podobny do VAT. Postanowiłem więc, za poradą Michała Szafrańskiego, doliczać go do poszczególnych kategorii.

Operacja ta robi się złożona, gdy kupujemy produkty różnych kategorii na raz. Część sklepów nie podaje nawet stawki ST przy produkcie, co sprawia że nawet żmudne, ręczne liczenie podatku jest niemożliwe. Dlatego sumę podatku rozdzielałem proporcjonalnie pomiędzy kategorie.

Wahania kursów walut

Podczas swojego pobytu, na potrzeby budżetu, stosowałem sztywny kurs dolara ustalony na przełomie miesięcy. Dzięki temu było mi łatwo utrzymać auto-walidację budżetu (cecha sprawiająca, że każdy zgubiony zarobek, bądź wydatek jest widoczny w budżecie).

Problem pojawiał się na koniec miesięca albo gdy musiałem kupić dolary za złotówki. Dodawałem wtedy jedną operację, która bilansowała mój stan posiadania z bierzącym kursem dolara.

Złotówkowe karty kredytowe i płatnicze

Czytając artykuły o finansach można znaleźć wiele powodów żeby nie używać złotówkowych kart za granicą. Nie znalazłem jednak informacji, że kwota zablokowana na karcie jest różna od tej, która zostaje zaksięgowana. Psuje to auto-walidację budżetu, albo zmusza nas do spisywania wydatków po kilku dniach od ich dokonania.