112 lines
4.3 KiB
C++
112 lines
4.3 KiB
C++
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
#pragma once
|
|
|
|
#include "Configuration.h"
|
|
#include <Hoymiles.h>
|
|
#include <optional>
|
|
#include <memory>
|
|
|
|
class PowerLimiterInverter {
|
|
public:
|
|
static std::unique_ptr<PowerLimiterInverter> create(bool verboseLogging, PowerLimiterInverterConfig const& config);
|
|
|
|
// send command(s) to inverter to reach desired target state (limit and
|
|
// production). return true if an update is pending, i.e., if the target
|
|
// state is NOT yet reached, false otherwise.
|
|
bool update();
|
|
|
|
// returns the timestamp of the oldest stats received for this inverter
|
|
// *after* its last command completed. return std::nullopt if new stats
|
|
// are pending after the last command completed.
|
|
std::optional<uint32_t> getLatestStatsMillis() const;
|
|
|
|
// the amount of times an update command issued to the inverter timed out
|
|
uint8_t getUpdateTimeouts() const { return _updateTimeouts; }
|
|
|
|
// maximum amount of AC power the inverter is able to produce
|
|
// (not regarding the configured upper power limit)
|
|
uint16_t getInverterMaxPowerWatts() const;
|
|
|
|
// maximum amount of AC power the inverter is allowed to produce as per
|
|
// upper power limit (additionally restricted by inverter's absolute max)
|
|
uint16_t getConfiguredMaxPowerWatts() const;
|
|
|
|
uint16_t getCurrentOutputAcWatts() const;
|
|
|
|
// this differs from current output power if new limit was assigned
|
|
uint16_t getExpectedOutputAcWatts() const;
|
|
|
|
// the maximum reduction of power output the inverter
|
|
// can achieve with or withouth going into standby.
|
|
virtual uint16_t getMaxReductionWatts(bool allowStandby) const = 0;
|
|
|
|
// the maximum increase of power output the inverter can achieve
|
|
// (is expected to achieve), possibly coming out of standby.
|
|
virtual uint16_t getMaxIncreaseWatts() const = 0;
|
|
|
|
// change the target limit such that the requested change becomes effective
|
|
// on the expected AC power output. returns the change in the range
|
|
// [0..reduction] that will become effective (once update() returns false).
|
|
virtual uint16_t applyReduction(uint16_t reduction, bool allowStandby) = 0;
|
|
virtual uint16_t applyIncrease(uint16_t increase) = 0;
|
|
|
|
// stop producing AC power. returns the change in power output
|
|
// that will become effective (once update() returns false).
|
|
virtual uint16_t standby() = 0;
|
|
|
|
// wake the inverter from standby and set it to produce
|
|
// as much power as permissible by its upper power limit.
|
|
void setMaxOutput();
|
|
|
|
void restart();
|
|
|
|
float getDcVoltage(uint8_t input);
|
|
bool isSendingCommandsEnabled() const { return _spInverter->getEnableCommands(); }
|
|
bool isReachable() const { return _spInverter->isReachable(); }
|
|
bool isProducing() const { return _spInverter->isProducing(); }
|
|
|
|
uint64_t getSerial() const { return _config.Serial; }
|
|
char const* getSerialStr() const { return _serialStr; }
|
|
bool isBehindPowerMeter() const { return _config.IsBehindPowerMeter; }
|
|
virtual bool isSolarPowered() const = 0;
|
|
|
|
void debug() const;
|
|
|
|
protected:
|
|
PowerLimiterInverter(bool verboseLogging, PowerLimiterInverterConfig const& config);
|
|
|
|
// returns false if the inverter cannot participate
|
|
// in achieving the requested change in power output
|
|
bool isEligible() const;
|
|
|
|
uint16_t getCurrentLimitWatts() const;
|
|
|
|
void setTargetPowerLimitWatts(uint16_t power) { _oTargetPowerLimitWatts = power; }
|
|
void setTargetPowerState(bool enable) { _oTargetPowerState = enable; }
|
|
void setExpectedOutputAcWatts(uint16_t power) { _expectedOutputAcWatts = power; }
|
|
|
|
// copied to avoid races with web UI
|
|
PowerLimiterInverterConfig _config;
|
|
|
|
// Hoymiles lib inverter instance
|
|
std::shared_ptr<InverterAbstract> _spInverter = nullptr;
|
|
|
|
bool _verboseLogging;
|
|
char _logPrefix[32];
|
|
|
|
private:
|
|
virtual void setAcOutput(uint16_t expectedOutputWatts) = 0;
|
|
|
|
char _serialStr[16];
|
|
|
|
// track (target) state
|
|
uint8_t _updateTimeouts = 0;
|
|
std::optional<uint32_t> _oUpdateStartMillis = std::nullopt;
|
|
std::optional<uint16_t> _oTargetPowerLimitWatts = std::nullopt;
|
|
std::optional<bool> _oTargetPowerState = std::nullopt;
|
|
mutable std::optional<uint32_t> _oStatsMillis = std::nullopt;
|
|
|
|
// the expected AC output (possibly is different from the target limit)
|
|
uint16_t _expectedOutputAcWatts = 0;
|
|
};
|