mirror of
https://github.com/fhem/fhem-mirror.git
synced 2025-05-04 22:19:38 +00:00
1035 lines
28 KiB
Perl
1035 lines
28 KiB
Perl
###############################################################################
|
|
#
|
|
# Developed with Kate
|
|
#
|
|
# (c) 2017-2021 Copyright: Marko Oldenburg (fhemdevelopment at cooltux dot net)
|
|
# All rights reserved
|
|
#
|
|
# This script is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# any later version.
|
|
#
|
|
# The GNU General Public License can be found at
|
|
# http://www.gnu.org/copyleft/gpl.html.
|
|
# A copy is found in the textfile GPL.txt and important notices to the license
|
|
# from the author is found in LICENSE.txt distributed with these scripts.
|
|
#
|
|
# This script is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
#
|
|
# $Id$
|
|
#
|
|
###############################################################################
|
|
##
|
|
##
|
|
## Das JSON Modul immer in einem eval aufrufen
|
|
# $data = eval{decode_json($data)};
|
|
#
|
|
# if($@){
|
|
# Log3($SELF, 2, "$TYPE ($SELF) - error while request: $@");
|
|
#
|
|
# readingsSingleUpdate($hash, "state", "error", 1);
|
|
#
|
|
# return;
|
|
# }
|
|
#
|
|
#######
|
|
#######
|
|
# URLs zum Abrufen diverser Daten
|
|
# https://<ip-Powerwall>/api/system_status/soe
|
|
# https://<ip-Powerwall>/api/meters/aggregates
|
|
# https://<ip-Powerwall>/api/site_info
|
|
# https://<ip-Powerwall>/api/sitemaster
|
|
# https://<ip-Powerwall>/api/powerwalls
|
|
# https://<ip-Powerwall>/api/networks
|
|
# https://<ip-Powerwall>/api/system/networks
|
|
# https://<ip-Powerwall>/api/operation
|
|
#
|
|
##
|
|
##
|
|
|
|
package FHEM::Tesla::Powerwall;
|
|
|
|
use strict;
|
|
use warnings;
|
|
use GPUtils qw(GP_Import GP_Export);
|
|
use HttpUtils;
|
|
use Data::Dumper;
|
|
|
|
# try to use JSON::MaybeXS wrapper
|
|
# for chance of better performance + open code
|
|
eval {
|
|
require JSON::MaybeXS;
|
|
import JSON::MaybeXS qw( decode_json encode_json );
|
|
1;
|
|
};
|
|
|
|
if ($@) {
|
|
$@ = undef;
|
|
|
|
# try to use JSON wrapper
|
|
# for chance of better performance
|
|
eval {
|
|
|
|
# JSON preference order
|
|
local $ENV{PERL_JSON_BACKEND} =
|
|
'Cpanel::JSON::XS,JSON::XS,JSON::PP,JSON::backportPP'
|
|
unless ( defined( $ENV{PERL_JSON_BACKEND} ) );
|
|
|
|
require JSON;
|
|
import JSON qw( decode_json encode_json );
|
|
1;
|
|
};
|
|
|
|
if ($@) {
|
|
$@ = undef;
|
|
|
|
# In rare cases, Cpanel::JSON::XS may
|
|
# be installed but JSON|JSON::MaybeXS not ...
|
|
eval {
|
|
require Cpanel::JSON::XS;
|
|
import Cpanel::JSON::XS qw(decode_json encode_json);
|
|
1;
|
|
};
|
|
|
|
if ($@) {
|
|
$@ = undef;
|
|
|
|
# In rare cases, JSON::XS may
|
|
# be installed but JSON not ...
|
|
eval {
|
|
require JSON::XS;
|
|
import JSON::XS qw(decode_json encode_json);
|
|
1;
|
|
};
|
|
|
|
if ($@) {
|
|
$@ = undef;
|
|
|
|
# Fallback to built-in JSON which SHOULD
|
|
# be available since 5.014 ...
|
|
eval {
|
|
require JSON::PP;
|
|
import JSON::PP qw(decode_json encode_json);
|
|
1;
|
|
};
|
|
|
|
if ($@) {
|
|
$@ = undef;
|
|
|
|
# Fallback to JSON::backportPP in really rare cases
|
|
require JSON::backportPP;
|
|
import JSON::backportPP qw(decode_json encode_json);
|
|
1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
## Import der FHEM Funktionen
|
|
#-- Run before package compilation
|
|
BEGIN {
|
|
|
|
# Import from main context
|
|
GP_Import(
|
|
qw(
|
|
readingsSingleUpdate
|
|
readingsBulkUpdate
|
|
readingsBulkUpdateIfChanged
|
|
readingsBeginUpdate
|
|
readingsEndUpdate
|
|
setKeyValue
|
|
getKeyValue
|
|
getUniqueId
|
|
CommandAttr
|
|
defs
|
|
Log3
|
|
readingFnAttributes
|
|
HttpUtils_NonblockingGet
|
|
AttrVal
|
|
ReadingsVal
|
|
IsDisabled
|
|
deviceEvents
|
|
init_done
|
|
gettimeofday
|
|
InternalTimer
|
|
RemoveInternalTimer)
|
|
);
|
|
}
|
|
|
|
#-- Export to main context with different name
|
|
GP_Export(
|
|
qw(
|
|
Initialize
|
|
Timer_GetData
|
|
Write
|
|
)
|
|
);
|
|
|
|
my %paths = (
|
|
'statussoe' => 'system_status/soe',
|
|
'aggregates' => 'meters/aggregates',
|
|
'meterssite' => 'meters/site',
|
|
'meterssolar' => 'meters/solar',
|
|
'siteinfo' => 'site_info',
|
|
'sitename' => 'site_info/site_name',
|
|
'sitemaster' => 'sitemaster',
|
|
'powerwalls' => 'powerwalls',
|
|
'registration' => 'customer/registration',
|
|
'status' => 'status',
|
|
'gridstatus' => 'system_status/grid_status',
|
|
);
|
|
|
|
my %cmdPaths = (
|
|
'powerwallsstop' => 'sitemaster/stop',
|
|
'powerwallsrun' => 'sitemaster/run',
|
|
);
|
|
|
|
sub Define {
|
|
my $hash = shift;
|
|
my $aArg = shift;
|
|
|
|
return $@ unless ( FHEM::Meta::SetInternals($hash) );
|
|
use version 0.60; our $VERSION = FHEM::Meta::Get( $hash, 'version' );
|
|
|
|
return q{too few parameters: define <name> TeslaPowerwall2AC <HOST>}
|
|
if ( scalar( @{$aArg} ) != 3 );
|
|
|
|
my $name = $aArg->[0];
|
|
my $host = $aArg->[2];
|
|
|
|
$hash->{HOST} = $host;
|
|
$hash->{INTERVAL} = 300;
|
|
$hash->{VERSION} = version->parse($VERSION)->normal;
|
|
$hash->{NOTIFYDEV} = qq(global,${name});
|
|
$hash->{actionQueue} = [];
|
|
|
|
CommandAttr( undef, $name . q{ room Tesla} )
|
|
if ( AttrVal( $name, 'room', 'none' ) eq 'none' );
|
|
Log3($name, 3,
|
|
qq(TeslaPowerwall2AC \(${name}\) - defined TeslaPowerwall2AC Device with Host ${host} and Interval $hash->{INTERVAL}));
|
|
|
|
return;
|
|
}
|
|
|
|
sub Undef {
|
|
my $hash = shift;
|
|
my $name = shift;
|
|
|
|
RemoveInternalTimer($hash);
|
|
Log3($name, 3, qq(TeslaPowerwall2AC \(${name}\) - Device ${name} deleted));
|
|
|
|
return;
|
|
}
|
|
|
|
sub Attr {
|
|
my ( $cmd, $name, $attrName, $attrVal ) = @_;
|
|
my $hash = $defs{$name};
|
|
|
|
if ( $attrName eq 'disable' ) {
|
|
if ( $cmd eq 'set' && $attrVal eq '1' ) {
|
|
RemoveInternalTimer($hash);
|
|
readingsSingleUpdate( $hash, 'state', 'disabled', 1 );
|
|
Log3($name, 3, qq(TeslaPowerwall2AC \(${name}\) - disabled));
|
|
|
|
}
|
|
elsif ( $cmd eq 'del' ) {
|
|
Log3($name, 3, qq(TeslaPowerwall2AC \(${name}\) - enabled));
|
|
}
|
|
}
|
|
|
|
if ( $attrName eq 'disabledForIntervals' ) {
|
|
if ( $cmd eq 'set' ) {
|
|
return
|
|
'check disabledForIntervals Syntax HH:MM-HH:MM or \'HH:MM-HH:MM HH:MM-HH:MM ...\''
|
|
unless ( $attrVal =~ /^((\d{2}:\d{2})-(\d{2}:\d{2})\s?)+$/ );
|
|
Log3($name, 3, qq(TeslaPowerwall2AC \(${name}\) - disabledForIntervals));
|
|
readingsSingleUpdate( $hash, 'state', 'disabled', 1 );
|
|
|
|
}
|
|
elsif ( $cmd eq 'del' ) {
|
|
Log3($name, 3, qq(TeslaPowerwall2AC \(${name}\) - enabled));
|
|
readingsSingleUpdate( $hash, 'state', 'active', 1 );
|
|
}
|
|
}
|
|
|
|
if ( $attrName eq 'interval' ) {
|
|
if ( $cmd eq 'set' ) {
|
|
if ( $attrVal < 60 ) {
|
|
Log3($name, 3,
|
|
qq(TeslaPowerwall2AC \(${name}\) - interval too small, please use something >= 60 (sec), default is 300 (sec)));
|
|
return
|
|
q{interval too small, please use something >= 60 (sec), default is 300 (sec)};
|
|
|
|
}
|
|
else {
|
|
RemoveInternalTimer($hash);
|
|
$hash->{INTERVAL} = $attrVal;
|
|
Log3($name, 3,
|
|
qq(TeslaPowerwall2AC \(${name}\) - set interval to ${attrVal}));
|
|
Timer_GetData($hash);
|
|
}
|
|
}
|
|
elsif ( $cmd eq 'del' ) {
|
|
RemoveInternalTimer($hash);
|
|
$hash->{INTERVAL} = 300;
|
|
Log3($name, 3,
|
|
qq(TeslaPowerwall2AC \(${name}\) - set interval to default));
|
|
Timer_GetData($hash);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
sub Notify {
|
|
my $hash = shift;
|
|
my $dev = shift;
|
|
|
|
my $name = $hash->{NAME};
|
|
return if ( IsDisabled($name) );
|
|
|
|
my $devname = $dev->{NAME};
|
|
my $devtype = $dev->{TYPE};
|
|
my $events = deviceEvents( $dev, 1 );
|
|
return if ( !$events );
|
|
|
|
Timer_GetData($hash)
|
|
if (
|
|
( grep /^INITIALIZED$/, @{$events}
|
|
or grep /^ATTR.$name.emailaddr$/, @{$events}
|
|
or grep /^DELETEATTR.$name.disable$/, @{$events}
|
|
or grep /^DELETEATTR.$name.interval$/, @{$events}
|
|
or grep /^DEFINED.$name$/, @{$events} )
|
|
and $init_done
|
|
);
|
|
return;
|
|
}
|
|
|
|
sub Get {
|
|
my $hash = shift;
|
|
my $aArg = shift;
|
|
|
|
my $name = shift @$aArg;
|
|
my $cmd = shift @$aArg // return qq(get ${name} needs at least one argument);
|
|
my $arg;
|
|
|
|
if ( $cmd eq 'statusSOE' ) {
|
|
|
|
$arg = lc($cmd);
|
|
|
|
}
|
|
elsif ( $cmd eq 'aggregates' ) {
|
|
|
|
$arg = lc($cmd);
|
|
|
|
}
|
|
elsif ( $cmd eq 'siteinfo' ) {
|
|
|
|
$arg = lc($cmd);
|
|
|
|
}
|
|
elsif ( $cmd eq 'powerwalls' ) {
|
|
|
|
$arg = lc($cmd);
|
|
|
|
}
|
|
elsif ( $cmd eq 'sitemaster' ) {
|
|
|
|
$arg = lc($cmd);
|
|
|
|
}
|
|
elsif ( $cmd eq 'registration' ) {
|
|
|
|
$arg = lc($cmd);
|
|
|
|
}
|
|
elsif ( $cmd eq 'status' ) {
|
|
|
|
$arg = lc($cmd);
|
|
|
|
}
|
|
else {
|
|
|
|
my $list = '';
|
|
$list .=
|
|
'statusSOE:noArg aggregates:noArg siteinfo:noArg sitemaster:noArg powerwalls:noArg registration:noArg status:noArg'
|
|
if( AttrVal($name,'emailaddr','none') ne 'none'
|
|
&& defined(ReadPassword($hash, $name))
|
|
&& defined($hash->{TOKEN}) );
|
|
|
|
return 'Unknown argument ' . $cmd . ', choose one of ' . $list;
|
|
}
|
|
|
|
return 'There are still path commands in the action queue'
|
|
if ( defined( $hash->{actionQueue} )
|
|
&& scalar( @{ $hash->{actionQueue} } ) > 0 );
|
|
|
|
unshift( @{ $hash->{actionQueue} }, $arg );
|
|
Write($hash);
|
|
|
|
return;
|
|
}
|
|
|
|
sub Set {
|
|
my $hash = shift;
|
|
my $aArg = shift;
|
|
my $hArg = shift;
|
|
|
|
my $name = shift @$aArg;
|
|
my $cmd = shift @$aArg // return qq(set ${name} needs at least one argument);
|
|
my $arg;
|
|
|
|
|
|
if ( $cmd eq 'powerwalls' ) {
|
|
$arg = lc( $cmd . $aArg->[0] );
|
|
}
|
|
elsif ( lc $cmd eq 'setpassword' ) {
|
|
return q{please set Attribut emailaddr first}
|
|
if ( AttrVal( $name, 'emailaddr', 'none' ) eq 'none' );
|
|
return qq(usage: ${cmd} pass=<password>) if ( scalar( @{$aArg} ) != 0
|
|
|| scalar(keys %{$hArg}) != 1 );
|
|
|
|
StorePassword( $hash, $name, $hArg->{'pass'} );
|
|
return Timer_GetData($hash);
|
|
}
|
|
elsif ( lc $cmd eq 'removepassword' ) {
|
|
return "usage: $cmd" if ( scalar( @{$aArg} ) != 0 );
|
|
|
|
DeletePassword($hash);
|
|
return Timer_GetData($hash);
|
|
}
|
|
else {
|
|
|
|
my $list = ( defined(ReadPassword($hash, $name)) ? 'removePassword:noArg ' : 'setPassword ');
|
|
$list .= 'powerwalls:run,stop'
|
|
if ( AttrVal( $name, 'devel', 0 ) == 1
|
|
&& defined(ReadPassword($hash, $name))
|
|
&& defined($hash->{TOKEN}) );
|
|
|
|
return 'Unknown argument ' . $cmd . ', choose one of ' . $list;
|
|
}
|
|
|
|
unshift( @{ $hash->{actionQueue} }, $arg );
|
|
Write($hash);
|
|
|
|
return;
|
|
}
|
|
|
|
sub Timer_GetData {
|
|
my $hash = shift;
|
|
my $name = $hash->{NAME};
|
|
|
|
RemoveInternalTimer($hash);
|
|
|
|
if ( defined( $hash->{actionQueue} )
|
|
&& scalar( @{ $hash->{actionQueue} } ) == 0 )
|
|
{
|
|
if ( !IsDisabled($name) ) {
|
|
return readingsSingleUpdate( $hash, 'state',
|
|
'please set Attribut emailaddr first', 1 )
|
|
if ( AttrVal( $name, 'emailaddr', 'none' ) eq 'none' );
|
|
return readingsSingleUpdate( $hash, 'state',
|
|
'please set password first', 1 )
|
|
if ( !defined( ReadPassword( $hash, $name ) ) );
|
|
|
|
if ( !defined( $hash->{TOKEN}) ) {
|
|
unshift( @{ $hash->{actionQueue} }, 'login' );
|
|
}
|
|
else {
|
|
while ( my $obj = each %paths ) {
|
|
unshift( @{ $hash->{actionQueue} }, $obj );
|
|
}
|
|
}
|
|
|
|
Write($hash);
|
|
}
|
|
else {
|
|
return readingsSingleUpdate( $hash, 'state', 'disabled', 1 );
|
|
}
|
|
}
|
|
|
|
InternalTimer( gettimeofday() + $hash->{INTERVAL},
|
|
'Powerwall_Timer_GetData', $hash );
|
|
Log3($name, 4,
|
|
qq(TeslaPowerwall2AC \(${name}\) - Call InternalTimer Timer_GetData));
|
|
}
|
|
|
|
sub Write {
|
|
my $hash = shift;
|
|
my $name = $hash->{NAME};
|
|
|
|
my ( $uri, $method, $header, $data, $path ) =
|
|
CreateUri( $hash, pop( @{ $hash->{actionQueue} } ) );
|
|
|
|
readingsSingleUpdate(
|
|
$hash,
|
|
'state',
|
|
'fetch data - '
|
|
. scalar( @{ $hash->{actionQueue} } )
|
|
. ' entries in the Queue',
|
|
1
|
|
);
|
|
|
|
HttpUtils_NonblockingGet(
|
|
{
|
|
url => 'https://' . $uri,
|
|
timeout => 5,
|
|
method => $method,
|
|
data => $data,
|
|
header => $header,
|
|
hash => $hash,
|
|
setCmd => $path,
|
|
doTrigger => 1,
|
|
callback => \&ErrorHandling,
|
|
}
|
|
);
|
|
|
|
Log3($name, 4, qq(TeslaPowerwall2AC \(${name}\) - Send with URI: https://${uri}));
|
|
}
|
|
|
|
sub ErrorHandling {
|
|
my $param = shift;
|
|
my $err = shift;
|
|
my $data = shift;
|
|
|
|
my $hash = $param->{hash};
|
|
my $name = $hash->{NAME};
|
|
|
|
### Begin Error Handling
|
|
|
|
if ( defined($err) ) {
|
|
if ( $err ne '' ) {
|
|
|
|
readingsBeginUpdate($hash);
|
|
readingsBulkUpdate( $hash, 'state', $err, 1 );
|
|
readingsBulkUpdate( $hash, 'lastRequestError', $err, 1 );
|
|
readingsEndUpdate( $hash, 1 );
|
|
|
|
Log3($name, 3, qq(TeslaPowerwall2AC \(${name}\) - RequestERROR: ${err}));
|
|
|
|
$hash->{actionQueue} = [];
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( $data eq ''
|
|
&& exists($param->{code})
|
|
&& $param->{code} != 200 )
|
|
{
|
|
|
|
readingsBeginUpdate($hash);
|
|
readingsBulkUpdate( $hash, 'state', $param->{code}, 1 );
|
|
|
|
readingsBulkUpdate( $hash, 'lastRequestError', $param->{code}, 1 );
|
|
|
|
Log3($name, 3,
|
|
qq(TeslaPowerwall2AC \(${name}\) - RequestERROR: " . $param->{code}));
|
|
|
|
readingsEndUpdate( $hash, 1 );
|
|
|
|
Log3($name, 5,
|
|
qq(TeslaPowerwall2AC \(${name}\) - RequestERROR: received http code "
|
|
. $param->{code}
|
|
. " without any data after requesting));
|
|
|
|
$hash->{actionQueue} = [];
|
|
return;
|
|
}
|
|
|
|
if ( $data =~ m#{"code":(\d+),"error":"(.+)","message":"(.+)"}$# ) {
|
|
|
|
readingsBeginUpdate($hash);
|
|
|
|
readingsBulkUpdate( $hash, 'state', $1, 1 );
|
|
readingsBulkUpdate(
|
|
$hash,
|
|
'lastRequestError',
|
|
'Path: '
|
|
. $param->{setCmd} . ' '
|
|
. $1
|
|
. ' - Error: '
|
|
. $2
|
|
. ' Messages: '
|
|
. $3,
|
|
1
|
|
);
|
|
|
|
readingsEndUpdate( $hash, 1 );
|
|
}
|
|
#### End Error Handling
|
|
|
|
InternalTimer( gettimeofday() + 3, 'Powerwall_Write', $hash )
|
|
if ( defined( $hash->{actionQueue} )
|
|
&& scalar( @{ $hash->{actionQueue} } ) > 0 );
|
|
|
|
Log3($name, 4, qq(TeslaPowerwall2AC \(${name}\) - Recieve JSON data: ${data}));
|
|
|
|
ResponseProcessing( $hash, $param->{setCmd}, $data );
|
|
}
|
|
|
|
sub ResponseProcessing {
|
|
my $hash = shift;
|
|
my $path = shift;
|
|
my $json = shift;
|
|
|
|
my $name = $hash->{NAME};
|
|
my $decode_json;
|
|
my $readings;
|
|
|
|
$decode_json = eval { decode_json($json) };
|
|
if ($@) {
|
|
Log3($name, 4, qq(TeslaPowerwall2AC \(${name}\) - error while request: $@));
|
|
readingsBeginUpdate($hash);
|
|
readingsBulkUpdate( $hash, 'JSON Error', $@ );
|
|
readingsBulkUpdate( $hash, 'state', 'JSON error' );
|
|
readingsEndUpdate( $hash, 1 );
|
|
return;
|
|
}
|
|
|
|
return
|
|
if ( ref($decode_json) eq 'HASH'
|
|
&& defined($decode_json->{error})
|
|
&& $decode_json->{error}
|
|
&& defined($decode_json->{code})
|
|
&& $decode_json->{code} );
|
|
|
|
#### Verarbeitung der Readings zum passenden Path
|
|
|
|
if ( $path eq 'aggregates' ) {
|
|
$readings = ReadingsProcessing_Aggregates( $hash, $decode_json );
|
|
}
|
|
elsif ( $path eq 'powerwalls' ) {
|
|
$readings = ReadingsProcessing_Powerwalls( $hash, $decode_json );
|
|
}
|
|
elsif ( $path eq 'login' ) {
|
|
$hash->{TOKEN} = $decode_json->{token};
|
|
return Timer_GetData($hash);
|
|
}
|
|
elsif ( $path eq 'meterssite' ) {
|
|
$readings = ReadingsProcessing_Meters_Site( $hash, $decode_json );
|
|
}
|
|
elsif ( $path eq 'meterssolar' ) {
|
|
$readings = ReadingsProcessing_Meters_Solar( $hash, $decode_json );
|
|
}
|
|
else {
|
|
$readings = $decode_json;
|
|
}
|
|
|
|
WriteReadings( $hash, $path, $readings );
|
|
}
|
|
|
|
sub WriteReadings {
|
|
my $hash = shift;
|
|
my $path = shift;
|
|
my $readings = shift;
|
|
|
|
my $name = $hash->{NAME};
|
|
|
|
Log3($name, 4, qq(TeslaPowerwall2AC \(${name}\) - Write Readings));
|
|
|
|
readingsBeginUpdate($hash);
|
|
while ( my ( $r, $v ) = each %{$readings} ) {
|
|
readingsBulkUpdate( $hash, $path . '-' . $r, $v );
|
|
}
|
|
|
|
readingsBulkUpdate( $hash, 'batteryLevel',
|
|
sprintf( "%.1f", $readings->{percentage} ) )
|
|
if ( defined( $readings->{percentage} ) );
|
|
readingsBulkUpdate(
|
|
$hash,
|
|
'batteryPower',
|
|
sprintf(
|
|
"%.1f",
|
|
(
|
|
ReadingsVal( $name, 'siteinfo-nominal_system_energy_kWh', 0 ) /
|
|
100
|
|
) * ReadingsVal( $name, 'statussoe-percentage', 0 )
|
|
)
|
|
);
|
|
|
|
readingsBulkUpdateIfChanged( $hash, 'actionQueue',
|
|
scalar( @{ $hash->{actionQueue} } ) . ' entries in the Queue' );
|
|
readingsBulkUpdateIfChanged(
|
|
$hash, 'state',
|
|
(
|
|
defined( $hash->{actionQueue} )
|
|
&& scalar( @{ $hash->{actionQueue} } ) == 0
|
|
? 'ready'
|
|
: 'fetch data - '
|
|
. scalar( @{ $hash->{actionQueue} } )
|
|
. ' paths in actionQueue'
|
|
)
|
|
);
|
|
|
|
readingsEndUpdate( $hash, 1 );
|
|
}
|
|
|
|
sub ReadingsProcessing_Aggregates {
|
|
my $hash = shift;
|
|
my $decode_json = shift;
|
|
|
|
my $name = $hash->{NAME};
|
|
my %readings;
|
|
|
|
if ( ref($decode_json) eq 'HASH' ) {
|
|
while ( my $obj = each %{$decode_json} ) {
|
|
while ( my ( $r, $v ) = each %{ $decode_json->{$obj} } ) {
|
|
$readings{ $obj . '-' . $r } = $v;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
$readings{'error'} = q{aggregates response is not a Hash};
|
|
}
|
|
|
|
return \%readings;
|
|
}
|
|
|
|
sub ReadingsProcessing_Powerwalls {
|
|
my $hash = shift;
|
|
my $decode_json = shift;
|
|
|
|
my $name = $hash->{NAME};
|
|
my %readings;
|
|
|
|
if ( ref($decode_json) eq 'HASH' ) {
|
|
for (keys %{$decode_json}) {
|
|
$readings{$_} = $decode_json->{$_}
|
|
if ( ref($decode_json->{$_}) ne 'ARRAY'
|
|
&& defined($decode_json->{$_}) );
|
|
|
|
if ( ref($decode_json->{$_}) eq 'ARRAY' ) {
|
|
my $i = 0;
|
|
my $r1 = $_;
|
|
for my $hRef (@{$decode_json->{$_}}) {
|
|
for (keys %{$hRef}) {
|
|
$r1 =~ s/s$//g;
|
|
$readings{qq(${r1}_${i}_${_})} = $hRef->{$_}
|
|
if ( ref($hRef->{$_}) ne 'ARRAY'
|
|
&& ref($hRef->{$_}) ne 'HASH'
|
|
&& defined($hRef->{$_}) );
|
|
|
|
if ( ref($hRef->{$_}) eq 'HASH' ) {
|
|
my $r2 = $_;
|
|
my $r3 = $hRef->{$_};
|
|
for (keys %{$r3}) {
|
|
$readings{qq(${r1}_${i}_${r2}_${_})} = $r3->{$_}
|
|
if ( ref($r3->{$_}) ne 'ARRAY'
|
|
&& defined($r3->{$_}) );
|
|
|
|
if ( ref($r3->{$_}) eq 'ARRAY' ) {
|
|
my $ii = 0;
|
|
my $r4 = $_;
|
|
for $hRef (@{$r3->{$_}}) {
|
|
for (keys %{$hRef}) {
|
|
$r4 =~ s/s$//g;
|
|
$readings{qq(${r1}_${i}_${r2}_${r4}_${ii}_${_})} = $hRef->{$_}
|
|
if ( ref($hRef->{$_}) ne 'HASH'
|
|
&& defined($hRef->{$_}) );
|
|
}
|
|
|
|
$ii++
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$i++;
|
|
}
|
|
|
|
$readings{'numberOfWalls'} = $i;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
$readings{'error'} = q{powerwalls response is not a Hash};
|
|
}
|
|
|
|
return \%readings;
|
|
}
|
|
|
|
sub ReadingsProcessing_Site_Info {
|
|
my $hash = shift;
|
|
my $decode_json = shift;
|
|
|
|
my $name = $hash->{NAME};
|
|
my %readings;
|
|
|
|
if ( ref($decode_json) eq 'HASH' ) {
|
|
while ( my $obj = each %{$decode_json} ) {
|
|
while ( my ( $r, $v ) = each %{ $decode_json->{$obj} } ) {
|
|
$readings{ $obj . '-' . $r } = $v;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
$readings{'error'} = q{siteinfo response is not a Hash};
|
|
}
|
|
|
|
return \%readings;
|
|
}
|
|
|
|
sub ReadingsProcessing_Meters_Site {
|
|
my $hash = shift;
|
|
my $decode_json = shift;
|
|
|
|
my $name = $hash->{NAME};
|
|
my %readings;
|
|
|
|
if ( ref($decode_json) eq 'ARRAY'
|
|
&& scalar( @{$decode_json} ) > 0 )
|
|
{
|
|
if ( ref( $decode_json->[0] ) eq 'HASH' ) {
|
|
while ( my $obj = each %{ $decode_json->[0] } ) {
|
|
if ( ref( $decode_json->[0]->{$obj} ) eq 'ARRAY'
|
|
|| ref( $decode_json->[0]->{$obj} ) eq 'HASH' )
|
|
{
|
|
if ( ref( $decode_json->[0]->{$obj} ) eq 'HASH' ) {
|
|
while ( my ( $r, $v ) =
|
|
each %{ $decode_json->[0]->{$obj} } )
|
|
{
|
|
if ( ref($v) ne 'HASH' ) {
|
|
$readings{ $obj . '-' . $r } = $v;
|
|
}
|
|
else {
|
|
while ( my ( $r2, $v2 ) =
|
|
each %{ $decode_json->[0]->{$obj}->{$r} } )
|
|
{
|
|
$readings{ $obj . '-' . $r . '-' . $r2 } =
|
|
$v2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
elsif ( ref( $decode_json->[0]->{$obj} ) eq 'ARRAY' ) {
|
|
|
|
}
|
|
}
|
|
else {
|
|
$readings{$obj} = $decode_json->[0]->{$obj};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
$readings{'error'} = q{metes site response is not a Array};
|
|
}
|
|
|
|
return \%readings;
|
|
}
|
|
|
|
sub ReadingsProcessing_Meters_Solar {
|
|
my $hash = shift;
|
|
my $decode_json = shift;
|
|
|
|
my $name = $hash->{NAME};
|
|
my %readings;
|
|
|
|
if ( ref($decode_json) eq 'ARRAY'
|
|
&& scalar( @{$decode_json} ) > 0 )
|
|
{
|
|
if ( ref( $decode_json->[0] ) eq 'HASH' ) {
|
|
while ( my $obj = each %{ $decode_json->[0] } ) {
|
|
if ( ref( $decode_json->[0]->{$obj} ) eq 'ARRAY'
|
|
|| ref( $decode_json->[0]->{$obj} ) eq 'HASH' )
|
|
{
|
|
if ( ref( $decode_json->[0]->{$obj} ) eq 'HASH' ) {
|
|
while ( my ( $r, $v ) =
|
|
each %{ $decode_json->[0]->{$obj} } )
|
|
{
|
|
if ( ref($v) ne 'HASH' ) {
|
|
$readings{ $obj . '-' . $r } = $v;
|
|
}
|
|
else {
|
|
while ( my ( $r2, $v2 ) =
|
|
each %{ $decode_json->[0]->{$obj}->{$r} } )
|
|
{
|
|
$readings{ $obj . '-' . $r . '-' . $r2 } =
|
|
$v2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
elsif ( ref( $decode_json->[0]->{$obj} ) eq 'ARRAY' ) {
|
|
|
|
}
|
|
}
|
|
else {
|
|
$readings{$obj} = $decode_json->[0]->{$obj};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
$readings{'error'} = q{metes solar response is not a Array};
|
|
}
|
|
|
|
return \%readings;
|
|
}
|
|
|
|
sub CreateUri {
|
|
my $hash = shift;
|
|
my $path = shift;
|
|
|
|
my $name = $hash->{NAME};
|
|
my $host = $hash->{HOST};
|
|
my $header = ( defined($hash->{TOKEN}) ? 'Cookie: AuthCookie=' . $hash->{TOKEN} : undef );
|
|
my $method = 'GET';
|
|
my $uri = ( $path ne 'login' ? $host . '/api/' . $paths{$path} : $host . '/api/login/Basic' );
|
|
my $data;
|
|
|
|
|
|
if ( $path eq 'login' ) {
|
|
$method = 'POST';
|
|
$header = 'Content-Type: application/json';
|
|
$data =
|
|
'{"username":"customer","password":"'
|
|
. ReadPassword( $hash, $name )
|
|
. '","email":"'
|
|
. AttrVal($name,'emailaddr','test@test.de')
|
|
. '","force_sm_off":false}'
|
|
}
|
|
elsif ( $path eq 'powerwallsstop'
|
|
|| $path eq 'powerwallsruns' )
|
|
{
|
|
$uri = $host . '/api/' . $cmdPaths{$path};
|
|
}
|
|
|
|
return ( $uri, $method, $header, $data, $path );
|
|
}
|
|
|
|
sub StorePassword {
|
|
my $hash = shift;
|
|
my $name = shift;
|
|
my $password = shift;
|
|
|
|
my $index = $hash->{TYPE} . q{_} . $name . q{_passwd};
|
|
my $key = getUniqueId() . $index;
|
|
my $enc_pwd = q{};
|
|
|
|
if ( eval qq(use Digest::MD5;1) ) {
|
|
|
|
$key = Digest::MD5::md5_hex( unpack "H*", $key );
|
|
$key .= Digest::MD5::md5_hex($key);
|
|
}
|
|
|
|
for my $char ( split //, $password ) {
|
|
|
|
my $encode = chop($key);
|
|
$enc_pwd .= sprintf( "%.2x", ord($char) ^ ord($encode) );
|
|
$key = $encode . $key;
|
|
}
|
|
|
|
my $err = setKeyValue( $index, $enc_pwd );
|
|
return qq(error while saving the password - ${err})
|
|
if ( defined($err) );
|
|
|
|
return q{password successfully saved};
|
|
}
|
|
|
|
sub ReadPassword {
|
|
my $hash = shift;
|
|
my $name = shift;
|
|
|
|
my $index = $hash->{TYPE} . q{_} . $name . q{_passwd};
|
|
my $key = getUniqueId() . $index;
|
|
my ( $password, $err );
|
|
|
|
Log3($name, 4, qq(TeslaPowerwall2AC \(${name}\) - Read password from file));
|
|
|
|
( $err, $password ) = getKeyValue($index);
|
|
|
|
if ( defined($err) ) {
|
|
|
|
Log3($name, 3,
|
|
qq(TeslaPowerwall2AC \(${name}\) - unable to read password from file: ${err}));
|
|
return;
|
|
|
|
}
|
|
|
|
if ( defined($password) ) {
|
|
if ( eval qq(use Digest::MD5;1) ) {
|
|
|
|
$key = Digest::MD5::md5_hex( unpack "H*", $key );
|
|
$key .= Digest::MD5::md5_hex($key);
|
|
}
|
|
|
|
my $dec_pwd = '';
|
|
|
|
for my $char ( map { pack( 'C', hex($_) ) } ( $password =~ /(..)/g ) ) {
|
|
|
|
my $decode = chop($key);
|
|
$dec_pwd .= chr( ord($char) ^ ord($decode) );
|
|
$key = $decode . $key;
|
|
}
|
|
|
|
return $dec_pwd;
|
|
|
|
}
|
|
else {
|
|
|
|
Log3($name, 3, qq(TeslaPowerwall2AC \(${name}\) - No password in file));
|
|
return;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
sub DeletePassword {
|
|
my $hash = shift;
|
|
|
|
setKeyValue( $hash->{TYPE} . q{_} . $hash->{NAME} . q{_passwd}, undef );
|
|
|
|
return;
|
|
}
|
|
|
|
sub Rename {
|
|
my $new = shift;
|
|
my $old = shift;
|
|
|
|
my $hash = $defs{$new};
|
|
|
|
StorePassword( $hash, $new, ReadPassword( $hash, $old ) );
|
|
setKeyValue( $hash->{TYPE} . q{_} . $old . q{_passwd}, undef );
|
|
|
|
return;
|
|
}
|
|
|
|
# My little Helpers
|
|
sub PathTimestamp {
|
|
my $hash = shift;
|
|
my $path = shift // return;
|
|
|
|
$hash->{helper}->{pathTimestamp}->{$path}->{TIME} =
|
|
gettimeofday();
|
|
}
|
|
|
|
sub PathTimeAge {
|
|
my $hash = shift;
|
|
my $path = shift;
|
|
|
|
$hash->{helper}{updateTimeCallBattery} = 0
|
|
if ( not defined( $hash->{helper}{updateTimeCallBattery} ) );
|
|
my $UpdateTimeAge = gettimeofday() - $hash->{helper}{updateTimeCallBattery};
|
|
|
|
return $UpdateTimeAge;
|
|
}
|
|
|
|
sub IsPathTimeAgeToOld {
|
|
my $hash = shift;
|
|
my $maxAge = shift;
|
|
|
|
return ( CallBattery_UpdateTimeAge($hash) > $maxAge ? 1 : 0 );
|
|
}
|
|
|
|
1;
|