V našem domě topíme tepelným čerpadlem (TČ) země-voda NIBE F-1245-6. S postupem času u mě vyvstala potřeba vědět, jak se tepelné čerpadlo chová v závislosti na venkovních podmínkách, případně jak reaguje na změnu pokojové teploty. Začal jsem tedy řešit, jak s tepelným čerpadlem komunikovat.

První a velice aktuální myšlenka byla propojení Loxone a TČ pomocí rozšíření čerpadla o jednotku MODBUS-40, která podporuje Modbus. Toto řešení má obrovskou výhodu v tom, že lze s TČ komunikovat lokálně, bez nutnosti komunikace přes internet. Nevýhodou je cena jednotky (11 tis) a také nutnost pořídit si Modbus extension (nebo Modbus-TCP konvertor). Právě cena byla důvodem pro neustálé odkládání realizace tohoto řešení.

Další možnost, která se naskytla, byla propojit Loxone s TČ pomocí PHP skriptu a virtuálních vstupů na Loxone, kdy se data stahují ze služby Nibe Uplink pomocí API. Toto řešení se mi zdá lepší, zejména z důvodu nízké pořizovací ceny. Jediné, co je k tomu potřeba, je Linuxový server nebo Raspberry. Co už ale není tak super, je v tomto případě nutnost ukládat statistiky přímo v Loxone. Časté zápisy na SD kartu totiž nejsou pro Loxone zdraví prospěšné a existují případy, kdy SD karta v Loxone miniserveru prostě odešla. Navíc, proč mít v data od TČ v Loxone aplikaci, když naprostou většinu dat k normálnímu životu člověk nepotřebuje a navíc ty Loxone statistiky nejsou úplně uživatelsky přívětivé.

Naskýtá se zde třetí možnost. Využít NibeUplink API k tomu, aby bylo možné data ukládat do databáze InfluxDB a následně je zobrazovat v Grafana. Nová TČ NIBE (ta s barevným displayem) by měla NibeUplink podporovat. K tomu aby TČ s Uplink komunikovalo, musí být připojeno k internetu. TČ pak pravidelně odesílá informace do  Nibe Uplink. V placené verzi umí NibeUplink tepelné čerpadlo také ovládat. Pro naše účely postačí verze zdarma, která umožňuje přistupovat k nasbíraným datům pomocí webového prohlížeče,  prostřednictvím iOS či Android aplikace a nebo právě pomocí rozhraní API.

Po prostudování několika internetových zdrojů jsem si napsal skript, který pravidelně stahuje data přes API a ukládá je do InfluxDB. Návodů na komunkaci přes Nibe API není zrovna mnoho, a když už se nějaký rozumný návod objeví, zapojuje do logiky MQTT, což mi připadá jako zbytečný prvek v cestě.

Ze všeho nejsložitější bylo „pochopení“, jak funguje autentizace ke službě. OAuth2 umožňuje programu zasílat požadavky jménem uživatele bez nutnosti zadávat heslo. Perl modul LWP::Authen::OAuth2 mi hodně pomohl v řešení tohoto problému, protože výměna tokenu během API komunikace pro mě byla něco nepochopitelného a neřešitelného.

Vzhledem k tomu, že se mi podařilo komunikaci prolomit, zejména díky desítkám článků na internetu, napsal jsem Perl skript, který data stahuje a ukládá do databáze.

Upozornění: Tento postup funguje v mém prostředí a sem jej dávám zejména pro to, že by tento koncept mohl pomoci i dalším lidem, kteří potřebují dosáhnout stejného cíle, jako já. Možná se vám něco nebude dařit, možná vám to nebude fungovat. Také mohou nastat změny na straně NibeUplink API. Negarantuji, že na tyto změny budu reflektovat a skripty upravovat. Pokud se přeci jen rozhodnete jít podle tohoto postupu, vězte že jste sami zodpovědní za dodržování podmínek smlouvy o službách NIBE Uplink API a za zachování důvěrnosti identifikačního čísla, aplikace a všech generovaných uživatelských tokenů. Vše děláte na vlastní odpovědnost.

Tak dost bylo alibismu a dáme se do práce.

Jak to mám já

V tuto chvíli mám již registrovaný účet v NibeUplink, tepelné čerpadlo mám připojeno k internetu a pomocí kombinace sériového čísla a párovacího řetězce mám TČ propojeno s NibeUplink (po přihlášení stačí kliknout na nabídku „Připojit systém„). Po přihlášení do Uplink vidím, že data jsou z TČ načítána a mohu je zobrazit. Toto je pre-rekvizita potřebná k tomu, aby bylo možné pokračovat dál.

Pre-rekvizity

  • Registrovaný účet v NibeUplink a do něj zaregistrované TČ, nasbíraná data jsou viditelná po přihlášení do web rozhraní nebo ve smart phone aplikaci
  • Linuxový server, který je připojený k internetu a lze na něm spouštět Perl skripty pro stahování dat pomocí API
    • Není potřeba žádný super výkonný server, Raspberry Pi je plne dostačujícím „serverem“.
    • Skripty fungují i v prostředí MS Azure (testováno)
    • Není potřeba grafické rozhraní ani web prohlížeč. SSH přístup je plně dostačující
    • Je potřeba mít nainstalován Perl modul Perl LWP::Authen::OAuth2 (Debian: sudo apt-get install liblwp-authen-oauth2-perl). V tomto návodu se nebudu zabývat instalací a konfigurací Linux prostředí
  • Počítač připojený k internetu, který disponuje web prohlížečem (né nutně ten stejný jako v předchozím bodě)
  • Základní znalosti skriptování v jazyce Perl, zkušenosti s instalací doplňkových modulů

NIBE Uplink API – Dokumentace a podpůrné technologie

Oficiální dokumentace k API je po přihlášení dostupná na adrese https://api.nibeuplink.com/docs/v1. K přihlášení použijte stejné údaje, které používáte k přihlášení do NibeUplink. Dokumentace popisuje komunikaci s API v hlubším detailu, ale ve zkratce:

  • Jedná se o REST API dostupné přes HTTPS
  • Výměna dat probíhá ve formátu JSON
  • Všechny požadavky jsou ověřovány pomocí OAuth2
    • Tohle je největší výzva, protože jednak musíte obdržet validní token, ale také jej musíte obnovit v případě, kdy expiruje

Můj největší problém byl v tom, pochopit, o čem pojednává OAuth2 Callback URL. Domníval jsem se, že je potřeba volat jej pravidelně, ale nakonec jsem zjistil, že jej stačí zavolat pouze jednou, abych získat Access Token. Jak to celé ve zkratce funguje:

  • Pokud se přihlásíte pomocí prohlížeče (zadáte své uživatelské údaje) a poskytnete souhlas s povolením, že vaše aplikace může přistupovat k datům, NibeUplink do okna prohlížeče vrátí své pověření NIBE Uplink a souhlasí s tím, že udělí vaší aplikaci přístup k jejím datům, webová stránka NIBE Uplink následně stránku přesměruje na Callback URL a připojí Autorizační kód (Authorization Code), jenž je platný pouze po omezenou dobu a může být zobrazen / předán pouze jednou.
  • Před vypršením platnosti kódu je nutné jej zprostředkovat na Nibe Uplink Token URL společně s dalšími parametry, aby byl přidělen Access Token a Refresh Token

Abych to celé zjednodušil. Vlastní Callback URL si můžete vytvořit sami. Bohužel je k tomu potřeba trochu zručnosti a web server, který umí obsluhovat PHP skripty. Já jsem k tomu například použil server, na kterém provozuji tento blog.

INFO: Zdá se, že Nibe Uplink API nově podporuje pouze HTTPS, myslete na to ve chvíli, kdy budete nahrávat index.php na internet. Přes klasické HTTP to nemusí fungovat

Skript jednoduše zobrazí vygenerovaný Authorization Code, nebo zobrazí chybovou hlášku. Pokud tedy máte možnost spustit skript na vlastním web serveru, vytvořte si soubor index.php a do něj vložte tento kód:

<?php
// oauth2callback/index.php

echo "OAuth2 Callback Script<br>";

if ( isset( $_GET['code'] ) ) {
    echo "Parameter 'code' found, value is: ";
    $code = $_GET['code'];
    echo "$code<br>";
} else {
    echo "Parametr 'code' nenalezen<br>";
}

if ( isset( $_GET['state'] ) ) {
    echo "Parametr 'state' nalezen, hodnota je: ";
    $state = $_GET['state'];
    echo "$state<br>";
}

if ( isset( $_GET['error'] ) ) {
    $error = $_GET['error'];
    echo $error;
}

?>

Vytvořený soubor nahrejte na libovolný web server, který je dostupný z internetu například: http://vasserver.cz/nibe/index.php

Použitý Perl modul LWP::Authen::OAuth2 jsem použil (inspiroval jsem se) z toho důvodu, že řeší veškerou komplexitu OAuth2. Existuje velmi dobrá dokumentace, nicméně, díky postupu níže vůbec nemusíte chápat, jak to vlastně funguje.

Jak na to – krok za krokem

Krok 0: Příprava Linux serveru

Server, který obsluhuje skript komunikující s Nibe Uplink API je třeba trochu připravit a nainstalovat nezbytné Perl moduly. V mém případě používám Raspbian Stretch, příkazy se mohou lišit v závislosti na distribuci Linuxu (Debian a Ubuntu to mají stejné nebo velmi podobné).

1. Zjistíme, zda-li je Perl nainstalován a zjistíme, kde se nachází:

$ which perl

Očekávaný výstup: /usr/bin/perl

2. Pokud jste tak ještě neučinili, je nejvyšší čas nainstalovar Per modul LWP::Authen::OAuth2. Pokud je již nainstalován, tak příkaz nic neprovede:

$ sudo apt-get install liblwp-authen-oauth2-perl

Krok 1: Registrace aplikace

1. Připojte se pomocí webového prohlížeče na adresu https://api.nibeuplink.com/. Nemusíte přistupovat z Linux serveru, postačí jakýkoliv počítač připojený k internetu.

2. Přihlaste se jménem a heslem, kterým se běžně hlásíte do Nibe Uplink

3. Klikněte na položku v menu „MY APPLICATIONS

4. Klikněte na tlačítko „Create application

5. Vyplňte údaje o tepelném čerpadle

  • Name – libovolné jméno aplikace
  • Description – libovolný popis, může být prázdný
  • Callback URL – adresa k souboru index.php, který jste vytvořili a nahráli na web server

6. Seznamte se s podmínkami (Services Agreement) a pokud souhlasíte, klikněte na tlačítko „Create Application

7. Poznamenejte si přidělený identifikátor (Identifer) a bezpečnostní řetězec (Secret) a bezpečně si je uložte.

Poznámka: pokud nemáte k dispozici vlastní web server, můžete použít jako Callback URL tuhle adresu: http://stavba.web-systemy.net/nibe/index.php

Krok 2: Získání Autorizačního kódu

Nyní to bude chtít trochu zručnosti. Potřebujeme získat autorizační kód z autorizačního endpointu Nibe Uplink. K tomu budete potřebovat znát Identifer, který jste si uložili předchozím kroku.

1. Je třeba „poskládat“ URL a otevřít ji v internetovém prohlížeči. Položku [Identifer] je třeba nahradit hodnotou, kterou jste získali.

https://api.nibeuplink.com/oauth/authorize?response_type=code&client_id=[Identifier]&scope=READSYSTEM&redirect_uri=[adresa web serveru]&state=STATE

Kde [adresa web serveru] je hodnota, kterou jste zadali do Callback URL při registraci aplikace (nebo můžete použít http://stavba.web-systemy.net/nibe/index.php).

Řetězec state může obsahovat libovolný řetězec, který znáte pouze vy. Stejný řetězec se vrátí od Nibe Uplink API.

2. Otevřete v prohlížeči výše uvedenou adresu

3. Pokud jste stále přihlášeni k Nibe Uplink API (ve kterém jste registrovali vaši aplikaci), tak po vás prohlížeč nebude vyžadovat jméno a heslo. Pokud jste se již stihli odhlásit, budete vyzváni k zadání uživatelského jména a hesla.

4. Zobrazí se stránka (viz níže), na které uvidíte název vaší aplikace (Na obrázku je uvedeno „Simple API script)

5. Potvrďte že nejste robot a klikněte na tlačítko „Accept

6. Pokud jste vše provedli správně a vše zafungovalo, zobrazí se vám jednoduchá stránka, podobná té na obrázku:

7. Hodnota Parameter ‚code‘ (na obrázku „zamlženo“) je váš Autorizační kód, který si zkopírujte a uložte, protože jej budete potřebovat v následujícím kroku. Pokud nebudete dostatečně rychlí a kód expiruje, bude nutné tento krok opakovat.

Krok 3: Přeměna Autorizačního kódu na Access Token

Nyní se připojte pomocí SSH na Linux server, který bude obsluhovat skripty. Nejprve je třeba vytvořit Perl skript, který použije Authorization Code společně s dalšími údaji (zejména Identifer a Secret, které jste získali dříve) a požádá o Access Token, který bude použit pro volání NIBE Uplink API.

1. Vytvořte soubor request_tokens.pl, například příkazem nano /data/nibeuplink/request_token.pl a do něj vložte následující text:

#!/usr/bin/perl

use strict;
use warnings;
use LWP::Authen::OAuth2;

our $filename = $ENV{ "HOME" }.'/.NIBE_Uplink_API_Tokens.json';

sub save_tokens {
my $token_string = shift;
open( my $fh, '>', $filename );
print $fh $token_string;
close $fh;
}

my $oauth2 = LWP::Authen::OAuth2->new(
client_id => '[Identifier]',
client_secret => '[Secret]',
token_endpoint => 'https://api.nibeuplink.com/oauth/token',
redirect_uri => 'http://stavba.web-systemy.net/nibe/index.php',
request_required_params => [ 'redirect_uri', 'state', 'scope', 'grant_type', 'client_id', 'client_secret', 'code' ],
scope => 'READSYSTEM',
save_tokens => \&save_tokens
);

print "Create a new Authorization Code and enter (copy-and-paste) it here\n";
my $code = <STDIN>;
chomp $code;

$oauth2->request_tokens(
code=> $code,
state => 'STATE'
);

exit;

2. Ve skriptu přepište zvýrazněné údaje. Ponechejte jednoduché uvozovky a změňte jen text uvnitř uvozovek:

  • [Identifer] – získali jste v kroku 1
  • [Secret] – získali jste v kroku 1
  • redirect_uri – použijte adresu k souboru index.php nebo ponechejte tak

3. změňte oprávnění k vytvořeném skriptu

$ chmod u+x /data/nibeuplink/request_tokens.pl

4. Spusťte skript

$ /data/nibeuplink/request_tokens.pl

nebo

$ sh /data/nibeuplink/request_tokens.pl

5. Pokud vše proběhlo správně, neuvidíte žádný textový výstup, ale ve vašem domovském adresáři najdete nově soubor “.NIBE_Uplink_API_Tokens.json”, který obsahuje Access Token a Refresh Token ve formátu JSON. Při spouštění skriptu buďte trpělivý, vygenerování tokenu pár vteřin vezme.

6. Opatrujte soubor s tokenem stejně pečlivě, jako opatrujete své SSH klíče. Doporučuji soubor zahrnout do pravidelných záloh. V ideálním případě přidělte k souboru práva pouze ke čtení:

$ chmod 600 ~/.NIBE_Uplink_API_Tokens.json

7. Pokud namísto souboru s tokenem obdržíte chybovou hlášku

OAuth2 error: invalid_request at ./request_tokens.pl line 30.

s nejvyšší pravděpodobností NIBE Uplink nevyhověl vaší žádosti, typicky z důvodu že Authorization Code expiroval nebo byl volán více než právě jednou. Zkontrolujte postup a zkuste to znovu.

8. Pokud se zobrazí jiná chyba, je možné že systém Nibe Uplink neodpovídá, je chyba ve výše uvedením skriptu, nebo v systému chybí nějaký obslužný modul. Zde nemohu poradit víc, než jen zkoušet a kontrolovat postup.

Krok 4: Volání NIBE Uplink API

Nyní máme Access Token a můžeme konečně volat API. Nyní už nás tolik netlačí čas, protože Token již bude automaticky obnoven pokaždé, když to bude třeba.

1. Vytvořte soubor nibe_uplink_api.pl, například příkazem nano /data/nibeuplink/nibe_uplink_api.pl a do něj vložte následující text:

#!/usr/bin/perl

use strict;
use warnings;
use JSON;
use LWP::Authen::OAuth2;

# File-scope variables, available to Main Program and Subroutines
our $filename = $ENV{ "HOME" }.'/.NIBE_Uplink_API_Tokens.json';

# Subroutine to save Access and Refresh tokens when those change
sub save_tokens {
my $token_string = shift;
open( my $fh, '>', $filename );
print $fh $token_string;
close $fh;
}
# Main Program

# Local variables
my $token_string;
my $url;
my $response;
my $decoded;

# Read saved token_string from file
open( my $fh, '<', $filename )
    or die "Could not open file $filename: $!";
$token_string = <$fh>;
chomp $token_string;
close( $fh );

# Construct the OAuth2 object
my $oauth2 = LWP::Authen::OAuth2->new(
client_id => '[Identifier]',
client_secret => '[Secret]',
token_endpoint => 'https://api.nibeuplink.com/oauth/token',
redirect_uri => 'http://stavba.web-systemy.net/nibe/index.php',
request_required_params => [ 'redirect_uri', 'state', 'scope', 'grant_type', 'client_id', 'client_secret', 'code' ],
scope => 'READSYSTEM',
token_string => $token_string,
save_tokens => \&save_tokens
);

# Make a simple NIBE Uplink API call - Get the Systems for this Account
$url = "https://api.nibeuplink.com/api/v1/systems";
$response = $oauth2->get( $url );
if ( $response->is_error ) { print $response->error_as_HTML }
if ( $response->is_success ) {
    $decoded = decode_json( $response->content );
# Expect $decoded to be a Reference to a Hash
    my $objects = $decoded->{ 'objects' };
    # Expect $objects to be a Reference to an Array of Hashes
    for my $hashref ( @ { $objects } ) {
        my $system = $hashref->{ 'systemId' };
print "systemId = ".$system."\n";
}
}

exit;

Ze všeho nejdůležitější je řádek $response = $oauth2->get( $url ); , který odvádí asi nejvíc práce. Stará se o poskytování Access Tokenu při volání API, kontroluje jestli token již neexpiroval a případně jej automaticky obnoví. Získá obnovený nový Token a uloží jej zpět do .json souboru, takže je token připravený k dalšímu použití.

2. Změňte oprávnění souboru/skriptu tak, aby byl spustitelný:

$ chmod u+x /data/nibeuplink/nibe_uplink_api.pl

3. Spusťte skript

$ /data/nibeuplink/nibe_uplink_api.pl

nebo

$ sh /data/nibeuplink/nibe_uplink_api.pl

Pokud vše funguje jak má, zobrazí se systemId všech tepelných čerpadel, která máte v Nibe Uplink zaregistrována.

Další postup

Nyní máme dobrý základ pro to, abychom mohli data získávat a ukládat je do InfluxDB. Někteří vývojáři data posílají do MQTT a z něj teprve do InfluxDB. My to uděláme trochu jinak. Pokusíme se data do InfluxDB posílat rovnou ze skriptu, který komunikuje s API.

Připravíme si tedy databázi, upravíme/vytvoříme nový skript, který se nám postará o ukládání dat a pokud se vše podaří, vytvoříme si dashboard v Grafana, kde si veškerá data zobrazíme.

Ukládání dat z Nibe Uplink do InfluxDB

1. Ze všeho nejdříve je třeba si vytvořit databázi, do které budeme ukládat jednotlivá měření.

# sudo influx

> create database nibeuplinkapi

2. Zazálohujte, přejmenujte nebo přesuňte již vytvořený soubor  nibe_uplink_api.pl

3. Vytvořte/upravte soubor nibe_uplink_api.pl, například příkazem nano /data/nibeuplink/nibe_uplink_api.pl a do něj vložte následující text:

#!/usr/bin/perl

use strict;
use warnings;
use JSON;
use LWP::Authen::OAuth2;

# File-scope variables, available to Main Program and Subroutines
our $filename = $ENV{ "HOME" }.'/.NIBE_Uplink_API_Tokens.json';

# Subroutine to save Access and Refresh tokens when those change
sub save_tokens {
my $token_string = shift;
open( my $fh, '>', $filename );
print $fh $token_string;
close $fh;
}
# Main Program

# Local variables
my $token_string;
my $url;
my $response;
my $decoded;

#Timestamp (NOW)
my $timestamp=time();
my $data;

# Read saved token_string from file
open( my $fh, '<', $filename )
or die "Could not open file $filename: $!";
$token_string = <$fh>;
chomp $token_string;
close( $fh );

# Construct the OAuth2 object
my $oauth2 = LWP::Authen::OAuth2->new(
client_id => '[Identifier]',
client_secret => '[Secret]',
token_endpoint => 'https://api.nibeuplink.com/oauth/token',
redirect_uri => 'http://stavba.web-systemy.net/nibe/index.php',
request_required_params => [ 'redirect_uri', 'state', 'scope', 'grant_type', 'client_id', 'client_secret', 'code' ],
scope => 'READSYSTEM',
token_string => $token_string,
save_tokens => \&save_tokens
);

# Make a simple NIBE Uplink API call - Get the Systems for this Account
$url = "https://api.nibeuplink.com/api/v1/systems";
$response = $oauth2->get( $url );
if ( $response->is_error ) { print $response->error_as_HTML }

if ( $response->is_success ) {
$decoded = decode_json( $response->content );
# Expect $decoded to be a Reference to a Hash
my $objects = $decoded->{ 'objects' };
# Expect $objects to be a Reference to an Array of Hashes

# Expect $objects to be a Reference to an Array of Hashes
for my $hashref ( @ { $objects } ) {
my $system = $hashref->{ 'systemId' };

#print "systemId = ".$system."\n";

# Get the Categories for this System
$url = "https://api.nibeuplink.com/api/v1/systems/$system/serviceinfo/categories";
$response = $oauth2->get( $url );

if ( $response->is_error ) { print $response->error_as_HTML }
if ( $response->is_success ) {
$decoded = decode_json( $response->content );
# Expect $decoded to be a Reference to an Array of Hashes
for my $hashref ( @ { $decoded } ) {
my $category = $hashref->{ 'categoryId' };

#print "\nCategory: $category\n";

#Dont save SYSTEM_INFO values
if($category eq 'SYSTEM_INFO' || $category eq 'AUX_IN_OUT'){
next;
}

# Get the Parameters for this Category
$url = "https://api.nibeuplink.com/api/v1/systems/$system/serviceinfo/categories/status?categoryId=$category";
$response = $oauth2->get( $url );
if ( $response->is_error ) { print $response->error_as_HTML }
if ( $response->is_success ) {
$decoded = decode_json( $response->content );

# Expect $decoded to be a Reference to an Array of Hashes
for my $hashref ( @ { $decoded } ) {

my $parameterid = $hashref->{ 'parameterId' };
my $name = $hashref->{ 'name' };
$name =~ s/\s//g;
my $title = $hashref->{ 'title' };
$title =~ s/\s/_/g;
$title =~ s/\.//g;
my $designation = $hashref->{ 'designation' };
my $unit = $hashref->{ 'unit' };
my $displayValue = $hashref->{ 'displayValue' };
my $rawvalue = $hashref->{ 'rawValue' };
#my $floatvalue = $rawvalue / 10;
my $topic = "raw/nibeuplink/$system/$designation/temperature";

$data .= $category."_".$title.",source=nibeuplinkapi,category=".$category." ";
$data .= $title."=".$rawvalue." ".$timestamp."\n";

#print "Parameterid: $parameterid | name: ".$name." | title: $title | designation: $designation | unit: $unit | displayValue: $displayValue | rawvalue: $rawvalue\n";

}

#print $data;
my $curl = `curl -i -XPOST 'http://localhost:8086/write?db=nibeuplinkapi&precision=s' --data-binary '$data'`;
print $curl;

}
}
}
}
}

exit;

Jak jste si jistě všimly, skripty jsou si podobné.

Jak skript funguje

Skript se nejprve dotáže API, aby mu vrátilo seznam všech zařízení, která jsou v NIBE Uplink registrovaná:

$url = "https://api.nibeuplink.com/api/v1/systems";

$response = $oauth2->get( $url );

Následně je spuštěn cyklus, který prochází všechna zařízení a získává z nich potřebná data

for my $hashref ( @ { $objects } ) {
my $system = $hashref->{ 'systemId' };

Smazáním znaku „#“ si můžete ID těchto zařízení zobrazit:

#print "systemId = ".$system."\n";

Pro každý systém se skript dotáže API na seznam kategorií

$url = "https://api.nibeuplink.com/api/v1/systems/$system/serviceinfo/categories";

Další cyklus projde všechny kategorie a získá parametry dané kategorie

for my $hashref ( @ { $decoded } ) {
my $category = $hashref->{ 'categoryId' };

Každá kategorie obsahuje několik parametrů

for my $hashref ( @ { $decoded } ) {

my $parameterid = $hashref->{ 'parameterId' };

my $name = $hashref->{ 'name' };
$name =~ s/\s//g;
my $title = $hashref->{ 'title' };
$title =~ s/\s/_/g;
$title =~ s/\.//g;
my $designation = $hashref->{ 'designation' };
my $unit = $hashref->{ 'unit' };
my $displayValue = $hashref->{ 'displayValue' };
my $rawvalue = $hashref->{ 'rawValue' };

  • $name – název parametru
  • $title – popis parametru
  • $designation – označení parametru
  • $unit – měrná jednotka
  • $displayValue – hodnota parametru ve formátu pro čtení (řetězec)
  • $rawvalue – surová hodnota parametru

Když máme vstupní hodnoty, můžeme připravit data ($data) pro vložení do InfluxDB

$data .= $category."_".$title.",source=nibeuplinkapi,category=".$category." ";
$data .= $title."=".$rawvalue." ".$timestamp."\n";

Složeninou proměnných $category a $title si vytvoříme hodnotu „measurement“ pro vložení do influxDB.

Field key pro InfluxDB je v tomto případě proměnná $title s hodnotou je proměnná $rawvalue.

O uložení dat do InfluxDB databáze nibeuplinkapi se pak postará příkaz

my $curl = `curl -i -XPOST 'http://localhost:8086/write?db=nibeuplinkapi&precision=s' --data-binary '$data'`;

Změňte oprávnění souboru/skriptu tak, aby byl spustitelný:

$ chmod u+x /data/nibeuplink/nibe_uplink_api.pl

Spusťte skript

$ /data/nibeuplink/nibe_uplink_api.pl

nebo

$ sh /data/nibeuplink/nibe_uplink_api.pl

Pokud nemáte ve svém systému CURL nainstalovaný, stačí jej doinstalovat pomocí příkazu

sudo apt-get install curl

Pokud vše dopadlo dobře, vypíše se na obrazovku výsledek volání curl.

Že se do influxDB uložila nějaká data ověříme tak, že spustíme influxdb a dáme dotaz na zobrazení dat

# sudo influx

> use nibeuplinkapi

> show measurements

Zobrazí se seznam měřených hodnot, které sbíráme právě pomocí výše uvedeného skriptu.

Vezmeme si například hodnotu „CPR_INFO_EP14_compressor_starts“, což je počet startů kompresoru.

> select * from CPR_INFO_EP14_compressor_starts

Pokud se zobrazí hodnoty, znamená to, že skript funguje. Nyní můžeme nastavit pravidelné volání, které zabezpečí uložení hodnot, třeba každých 10 minu. Spusťe příkaz

crontab -e

A vložte nový řádek

*/10 * * * * sudo /data//nibeuplink/nibe_uplink_api.pl

Tak, lze konstatovat, že data úspěšně sbíráme, řekněme v 10 minutových intervalech. Ale co dál? Jak data použít, jak je vizualizovat?

Grafana

O tom, jak vložit nový Data Source do Grafana jsem psal již ve článku, jak vizualizovat data z meteo stanice. Postupujte úplně stejně s tím rozdílem, že název databáze bude v tomto případě nibeuplinkapi. Ke stažení je i JSON dashboard, abyste nemuseli dashboard složitě „vyklikávat“. Jak si nový dashboard naimportovat je patrné také z článku o meteostanici.

Ke stažení

Odkazy

Tepelné čerpadlo NIBE v přehledných grafech
Štítky:                            

1 komentář u „Tepelné čerpadlo NIBE v přehledných grafech

  • 15.2.2019 (22:02)
    Trvalý odkaz

    Ahoj, už dva dny pročítám všechny články které tu zde píšeš. Osobně také stavím RD, a řeším domácí automatizaci, a mám pár dotazu, myslíš ze by bylo možné si o tom pobavit? Nenašel jsem tu na tebe kontakt, tak snad se to dostane i tak k tobě.
    Předem díky.

    Reagovat

Napsat komentář

Vaše emailová adresa nebude zveřejněna.

This site uses Akismet to reduce spam. Learn how your comment data is processed.