eswyft/inverter-tools
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rename stuff

Browse Source 
- Rename some commands
- Use more unified and correct terminology
This commit is contained in:
Evgeny Zinoviev 2022-09-01 22:17:29 +03:00
parent 9ba7a470ad
commit 6df6012edf
8 changed files with 282 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
src/inverterctl.cc
View File

@ -95,7 +95,7 @@ static void usage(const char* progname) {
" get-year-generated <yyyy>\n" " get-year-generated <yyyy>\n"
" get-month-generated <yyyy> <mm>\n" " get-month-generated <yyyy> <mm>\n"
" get-day-generated <yyyy> <mm> <dd>\n" " get-day-generated <yyyy> <mm> <dd>\n"
" get-series-number\n" " get-serial-number\n"
" get-cpu-version\n" " get-cpu-version\n"
" get-rated\n" " get-rated\n"
" get-status\n" " get-status\n"
@ -109,55 +109,55 @@ static void usage(const char* progname) {
" get-errors\n" " get-errors\n"
" get-flags\n" " get-flags\n"
" get-rated-defaults\n" " get-rated-defaults\n"
" get-allowed-charging-currents\n" " get-allowed-charge-currents\n"
" get-allowed-ac-charging-currents\n" " get-allowed-ac-charge-currents\n"
" get-ac-charging-time\n" " get-ac-charge-time\n"
" get-ac-loads-supply-time\n" " get-ac-supply-time\n"
" set-loads-supply 0|1\n" " set-ac-supply 0|1\n"
" set-flag <flag> 0|1\n" " set-flag <flag> 0|1\n"
" set-rated-defaults\n" " set-rated-defaults\n"
" set-max-charging-current <id> <amps>\n" " set-max-charge-current <id> <amps>\n"
" id: Parallel machine ID (use 0 for single model)\n" " id: Parallel machine ID\n"
" amps: Use get-allowed-charging-currents\n" " amps: Use get-allowed-charge-currents\n"
" to see a list of allowed values.\n" " to see a list of allowed values.\n"
"\n" "\n"
" set-max-ac-charging-current <id> <amps>\n" " set-max-ac-charge-current <id> <amps>\n"
" id: Parallel machine ID (use 0 for single model)\n" " id: Parallel machine ID\n"
" amps: Use get-allowed-ac-charging-currents\n" " amps: Use get-allowed-ac-charge-currents\n"
" to see a list of allowed values.\n" " to see a list of allowed values.\n"
"\n" "\n"
" set-ac-output-freq 50|60\n" " set-max-charge-voltage <cv> <fv>\n"
" set-max-charging-voltage <cv> <fv>\n"
" cv: Constant voltage (48.0 ~ 58.4).\n" " cv: Constant voltage (48.0 ~ 58.4).\n"
" fv: Float voltage (48.0 ~ 58.4).\n" " fv: Float voltage (48.0 ~ 58.4).\n"
"\n" "\n"
" set-ac-output-freq 50|60\n"
" set-ac-output-voltage <v>\n" " set-ac-output-voltage <v>\n"
" v: " << p18::ac_output_rated_voltages << "\n" " v: " << p18::ac_output_voltages << "\n"
"\n" "\n"
" set-output-source-priority SUB|SBU\n" " set-output-source-priority SUB|SBU\n"
" 'SUB' means " << p18::OutputSourcePriority::SolarUtilityBattery << "\n" " 'SUB' means " << p18::OutputSourcePriority::SolarUtilityBattery << "\n"
" 'SBU' means " << p18::OutputSourcePriority::SolarBatteryUtility << "\n" " 'SBU' means " << p18::OutputSourcePriority::SolarBatteryUtility << "\n"
"\n" "\n"
" set-charging-thresholds <cv> <dv>\n" " set-charge-thresholds <cv> <dv>\n"
" Set battery re-charging and re-discharging voltages when\n" " Set battery re-charge and re-discharge voltages when\n"
" utility is available.\n" " grid is connected.\n"
"\n" "\n"
" cv: re-charging voltage\n" " cv: re-charge voltage\n"
" For 12 V unit: " << p18::bat_ac_recharging_voltages_12v << "\n" " For 12 V unit: " << p18::bat_ac_recharge_voltages_12v << "\n"
" For 24 V unit: " << p18::bat_ac_recharging_voltages_24v << "\n" " For 24 V unit: " << p18::bat_ac_recharge_voltages_24v << "\n"
" For 48 V unit: " << p18::bat_ac_recharging_voltages_48v << "\n" " For 48 V unit: " << p18::bat_ac_recharge_voltages_48v << "\n"
"\n" "\n"
" dv: re-discharging voltage\n" " dv: re-discharge voltage\n"
" For 12 V unit: " << p18::bat_ac_redischarging_voltages_12v << "\n" " For 12 V unit: " << p18::bat_ac_redischarge_voltages_12v << "\n"
" For 24 V unit: " << p18::bat_ac_redischarging_voltages_24v << "\n" " For 24 V unit: " << p18::bat_ac_redischarge_voltages_24v << "\n"
" For 48 V unit: " << p18::bat_ac_redischarging_voltages_48v << "\n" " For 48 V unit: " << p18::bat_ac_redischarge_voltages_48v << "\n"
"\n" "\n"
" set-charging-source-priority <id> <priority>\n" " set-charge-source-priority <id> <priority>\n"
" id: Parallel machine ID (use 0 for a single model)\n" " id: Parallel machine ID\n"
" priority: SF|SU|S\n" " priority: SF|SU|S\n"
" 'SF' means " << p18::ChargerSourcePriority::SolarFirst << ",\n" " 'SF' means " << p18::ChargeSourcePriority::SolarFirst << ",\n"
" 'SU' means " << p18::ChargerSourcePriority::SolarAndUtility << "\n" " 'SU' means " << p18::ChargeSourcePriority::SolarAndUtility << "\n"
" 'S' means " << p18::ChargerSourcePriority::SolarOnly << "\n" " 'S' means " << p18::ChargeSourcePriority::SolarOnly << "\n"
"\n" "\n"
" set-solar-power-priority BLU|LBU\n" " set-solar-power-priority BLU|LBU\n"
" 'BLU' means " << p18::SolarPowerPriority::BatteryLoadUtility << "\n" " 'BLU' means " << p18::SolarPowerPriority::BatteryLoadUtility << "\n"
@ -165,16 +165,16 @@ static void usage(const char* progname) {
"\n" "\n"
" set-ac-input-voltage-range APPLIANCE|UPS\n" " set-ac-input-voltage-range APPLIANCE|UPS\n"
" set-battery-type AGM|FLOODED|USER\n" " set-battery-type AGM|FLOODED|USER\n"
" set-output-model <id> <model>\n" " set-output-mode <id> <mode>\n"
" id: Parallel machine ID (use 0 for a single model)\n" " id: Machine ID\n"
" model: SM|P|P1|P2|P3\n" " mode: S|P|1|2|3\n"
" SM: " << p18::OutputModelSetting::SingleModule << "\n" " S: " << p18::OutputMode::SingleOutput << "\n"
" P: " << p18::OutputModelSetting::ParallelOutput << "\n" " P: " << p18::OutputMode::ParallelOutput << "\n"
" P1: " << p18::OutputModelSetting::Phase1OfThreePhaseOutput << "\n" " 1: " << p18::OutputMode::Phase_1_of_3 << "\n"
" P2: " << p18::OutputModelSetting::Phase2OfThreePhaseOutput << "\n" " 2: " << p18::OutputMode::Phase_2_of_3 << "\n"
" P3: " << p18::OutputModelSetting::Phase3OfThreePhaseOutput << "\n" " 3: " << p18::OutputMode::Phase_3_of_3 << "\n"
"\n" "\n"
" set-battery-cut-off-voltage <v>\n" " set-battery-cutoff-voltage <v>\n"
" v: Cut-off voltage (40.0~48.0)\n" " v: Cut-off voltage (40.0~48.0)\n"
"\n" "\n"
" set-solar-configuration <id>\n" " set-solar-configuration <id>\n"
@ -191,14 +191,16 @@ static void usage(const char* progname) {
" mm: Minutes\n" " mm: Minutes\n"
" ss: Seconds\n" " ss: Seconds\n"
"\n" "\n"
" set-ac-charging-time <start> <end>\n" " set-ac-charge-time <start> <end>\n"
" start: Starting time, hh:mm format\n" " start: Starting time, hh:mm format\n"
" end: Ending time, hh:mm format\n" " end: Ending time, hh:mm format\n"
"\n" "\n"
" set-ac-loads-supply-time <start> <end>\n" " set-ac-supply-time <start> <end>\n"
" start: Starting time, hh:mm format\n" " start: Starting time, hh:mm format\n"
" end: Ending time, hh:mm format\n" " end: Ending time, hh:mm format\n"
"\n" "\n"
"Note: use 0 as parallel machine ID for single machine.\n"
"\n"
"Flags:\n"; "Flags:\n";
for (const p18::Flag& flag: p18::flags) for (const p18::Flag& flag: p18::flags)
std::cout << " " << flag.flag << ": " << flag.description << "\n"; std::cout << " " << flag.flag << ": " << flag.description << "\n";

52
src/p18/client.cc
View File

@ -65,42 +65,42 @@ std::shared_ptr<response_type::BaseResponse> Client::execute(p18::CommandType co
RESPONSE_CASE(YearGenerated) RESPONSE_CASE(YearGenerated)
RESPONSE_CASE(MonthGenerated) RESPONSE_CASE(MonthGenerated)
RESPONSE_CASE(DayGenerated) RESPONSE_CASE(DayGenerated)
RESPONSE_CASE(SeriesNumber) RESPONSE_CASE(SerialNumber)
RESPONSE_CASE(CPUVersion) RESPONSE_CASE(CPUVersion)
RESPONSE_CASE(RatedInformation) RESPONSE_CASE(RatedInformation)
RESPONSE_CASE(GeneralStatus) RESPONSE_CASE(GeneralStatus)
RESPONSE_CASE(WorkingMode) RESPONSE_CASE(WorkingMode)
RESPONSE_CASE(FaultsAndWarnings) RESPONSE_CASE(FaultsAndWarnings)
RESPONSE_CASE(FlagsAndStatuses) RESPONSE_CASE(FlagsAndStatuses)
RESPONSE_CASE(Defaults) RESPONSE_CASE(RatedDefaults)
RESPONSE_CASE(AllowedChargingCurrents) RESPONSE_CASE(AllowedChargeCurrents)
RESPONSE_CASE(AllowedACChargingCurrents) RESPONSE_CASE(AllowedACChargeCurrents)
RESPONSE_CASE(ParallelRatedInformation) RESPONSE_CASE(ParallelRatedInformation)
RESPONSE_CASE(ParallelGeneralStatus) RESPONSE_CASE(ParallelGeneralStatus)
RESPONSE_CASE(ACChargingTimeBucket) RESPONSE_CASE(ACChargeTimeBucket)
RESPONSE_CASE(ACLoadsSupplyTimeBucket) RESPONSE_CASE(ACSupplyTimeBucket)
case CommandType::SetLoads: case CommandType::SetACSupply:
case CommandType::SetFlag: case CommandType::SetFlag:
case CommandType::SetDefaults: case CommandType::SetDefaults:
case CommandType::SetBatteryMaxChargingCurrent: case CommandType::SetBatteryMaxChargeCurrent:
case CommandType::SetBatteryMaxACChargingCurrent: case CommandType::SetBatteryMaxACChargeCurrent:
case CommandType::SetACOutputFreq: case CommandType::SetACOutputFreq:
case CommandType::SetBatteryMaxChargingVoltage: case CommandType::SetBatteryMaxChargeVoltage:
case CommandType::SetACOutputRatedVoltage: case CommandType::SetACOutputVoltage:
case CommandType::SetOutputSourcePriority: case CommandType::SetOutputSourcePriority:
case CommandType::SetBatteryChargingThresholds: case CommandType::SetBatteryChargeThresholds:
case CommandType::SetChargingSourcePriority: case CommandType::SetChargeSourcePriority:
case CommandType::SetSolarPowerPriority: case CommandType::SetSolarPowerPriority:
case CommandType::SetACInputVoltageRange: case CommandType::SetACInputVoltageRange:
case CommandType::SetBatteryType: case CommandType::SetBatteryType:
case CommandType::SetOutputModel: case CommandType::SetOutputMode:
case CommandType::SetBatteryCutOffVoltage: case CommandType::SetBatteryCutOffVoltage:
case CommandType::SetSolarConfig: case CommandType::SetSolarConfig:
case CommandType::ClearGenerated: case CommandType::ClearGenerated:
case CommandType::SetDateTime: case CommandType::SetDateTime:
case CommandType::SetACChargingTimeBucket: case CommandType::SetACChargeTimeBucket:
case CommandType::SetACLoadsSupplyTimeBucket: case CommandType::SetACSupplyTimeBucket:
response = MKRESPONSE(SetResponse); response = MKRESPONSE(SetResponse);
break; break;
} }
@ -132,7 +132,7 @@ std::string Client::packArguments(p18::CommandType commandType, std::vector<std:
case CommandType::SetSolarPowerPriority: case CommandType::SetSolarPowerPriority:
case CommandType::SetACInputVoltageRange: case CommandType::SetACInputVoltageRange:
case CommandType::SetBatteryType: case CommandType::SetBatteryType:
case CommandType::SetLoads: case CommandType::SetACSupply:
buf << arguments[0]; buf << arguments[0];
break; break;
@ -153,8 +153,8 @@ std::string Client::packArguments(p18::CommandType commandType, std::vector<std:
buf << arguments[0]; buf << arguments[0];
break; break;
case CommandType::SetBatteryMaxChargingCurrent: case CommandType::SetBatteryMaxChargeCurrent:
case CommandType::SetBatteryMaxACChargingCurrent: case CommandType::SetBatteryMaxACChargeCurrent:
buf << arguments[0] << ","; buf << arguments[0] << ",";
buf << std::setw(3) << std::stoi(arguments[1]); buf << std::setw(3) << std::stoi(arguments[1]);
break; break;
@ -163,8 +163,8 @@ std::string Client::packArguments(p18::CommandType commandType, std::vector<std:
buf << std::setw(2) << std::stoi(arguments[0]); buf << std::setw(2) << std::stoi(arguments[0]);
break; break;
case CommandType::SetBatteryMaxChargingVoltage: case CommandType::SetBatteryMaxChargeVoltage:
case CommandType::SetBatteryChargingThresholds: { case CommandType::SetBatteryChargeThresholds: {
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
double val = std::stod(arguments[i]); double val = std::stod(arguments[i]);
buf << std::setw(3) << (int)round(val*10); buf << std::setw(3) << (int)round(val*10);
@ -174,13 +174,13 @@ std::string Client::packArguments(p18::CommandType commandType, std::vector<std:
break; break;
} }
case CommandType::SetACOutputRatedVoltage: { case CommandType::SetACOutputVoltage: {
buf << std::setw(4) << (std::stoi(arguments[0])*10); buf << std::setw(4) << (std::stoi(arguments[0])*10);
break; break;
} }
case CommandType::SetChargingSourcePriority: case CommandType::SetChargeSourcePriority:
case CommandType::SetOutputModel: case CommandType::SetOutputMode:
buf << arguments[0] << "," << arguments[1]; buf << arguments[0] << "," << arguments[1];
break; break;
@ -210,8 +210,8 @@ std::string Client::packArguments(p18::CommandType commandType, std::vector<std:
break; break;
} }
case CommandType::SetACChargingTimeBucket: case CommandType::SetACChargeTimeBucket:
case CommandType::SetACLoadsSupplyTimeBucket: case CommandType::SetACSupplyTimeBucket:
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
buf << std::setw(2) << std::stoi(arguments[i]); buf << std::setw(2) << std::stoi(arguments[i]);
if (i == 1) if (i == 1)

70
src/p18/commands.cc
View File

@ -24,41 +24,41 @@ const std::map<std::string, p18::CommandType> client_commands = {
{"get-year-generated", p18::CommandType::GetYearGenerated}, {"get-year-generated", p18::CommandType::GetYearGenerated},
{"get-month-generated", p18::CommandType::GetMonthGenerated}, {"get-month-generated", p18::CommandType::GetMonthGenerated},
{"get-day-generated", p18::CommandType::GetDayGenerated}, {"get-day-generated", p18::CommandType::GetDayGenerated},
{"get-series-number", p18::CommandType::GetSeriesNumber}, {"get-serial-number", p18::CommandType::GetSerialNumber},
{"get-cpu-version", p18::CommandType::GetCPUVersion}, {"get-cpu-version", p18::CommandType::GetCPUVersion},
{"get-rated", p18::CommandType::GetRatedInformation}, {"get-rated", p18::CommandType::GetRatedInformation},
{"get-status", p18::CommandType::GetGeneralStatus}, {"get-status", p18::CommandType::GetGeneralStatus},
{"get-mode", p18::CommandType::GetWorkingMode}, {"get-mode", p18::CommandType::GetWorkingMode},
{"get-errors", p18::CommandType::GetFaultsAndWarnings}, {"get-errors", p18::CommandType::GetFaultsAndWarnings},
{"get-flags", p18::CommandType::GetFlagsAndStatuses}, {"get-flags", p18::CommandType::GetFlagsAndStatuses},
{"get-rated-defaults", p18::CommandType::GetDefaults}, {"get-rated-defaults", p18::CommandType::GetRatedDefaults},
{"get-allowed-charging-currents", p18::CommandType::GetAllowedChargingCurrents}, {"get-allowed-charge-currents", p18::CommandType::GetAllowedChargeCurrents},
{"get-allowed-ac-charging-currents", p18::CommandType::GetAllowedACChargingCurrents}, {"get-allowed-ac-charge-currents", p18::CommandType::GetAllowedACChargeCurrents},
{"get-p-rated", p18::CommandType::GetParallelRatedInformation}, {"get-p-rated", p18::CommandType::GetParallelRatedInformation},
{"get-p-status", p18::CommandType::GetParallelGeneralStatus}, {"get-p-status", p18::CommandType::GetParallelGeneralStatus},
{"get-ac-charging-time", p18::CommandType::GetACChargingTimeBucket}, {"get-ac-charge-time", p18::CommandType::GetACChargeTimeBucket},
{"get-ac-loads-supply-time", p18::CommandType::GetACLoadsSupplyTimeBucket}, {"get-ac-supply-time", p18::CommandType::GetACSupplyTimeBucket},
{"set-loads-supply", p18::CommandType::SetLoads}, {"set-ac-supply", p18::CommandType::SetACSupply},
{"set-flag", p18::CommandType::SetFlag}, {"set-flag", p18::CommandType::SetFlag},
{"set-rated-defaults", p18::CommandType::SetDefaults}, {"set-rated-defaults", p18::CommandType::SetDefaults},
{"set-max-charging-current", p18::CommandType::SetBatteryMaxChargingCurrent}, {"set-max-charge-current", p18::CommandType::SetBatteryMaxChargeCurrent},
{"set-max-ac-charging-current", p18::CommandType::SetBatteryMaxACChargingCurrent}, {"set-max-ac-charge-current", p18::CommandType::SetBatteryMaxACChargeCurrent},
{"set-ac-output-freq", p18::CommandType::SetACOutputFreq}, {"set-ac-output-freq", p18::CommandType::SetACOutputFreq},
{"set-max-charging-voltage", p18::CommandType::SetBatteryMaxChargingVoltage}, {"set-max-charge-voltage", p18::CommandType::SetBatteryMaxChargeVoltage},
{"set-ac-output-voltage", p18::CommandType::SetACOutputRatedVoltage}, {"set-ac-output-voltage", p18::CommandType::SetACOutputVoltage},
{"set-output-source-priority", p18::CommandType::SetOutputSourcePriority}, {"set-output-source-priority", p18::CommandType::SetOutputSourcePriority},
{"set-charging-thresholds", p18::CommandType::SetBatteryChargingThresholds}, /* Battery re-charging and re-discharging voltage when utility is available */ {"set-charge-thresholds", p18::CommandType::SetBatteryChargeThresholds}, /* Battery re-charge and re-discharge voltage when utility is available */
{"set-charging-source-priority", p18::CommandType::SetChargingSourcePriority}, {"set-charge-source-priority", p18::CommandType::SetChargeSourcePriority},
{"set-solar-power-priority", p18::CommandType::SetSolarPowerPriority}, {"set-solar-power-priority", p18::CommandType::SetSolarPowerPriority},
{"set-ac-input-voltage-range", p18::CommandType::SetACInputVoltageRange}, {"set-ac-input-voltage-range", p18::CommandType::SetACInputVoltageRange},
{"set-battery-type", p18::CommandType::SetBatteryType}, {"set-battery-type", p18::CommandType::SetBatteryType},
{"set-output-model", p18::CommandType::SetOutputModel}, {"set-output-mode", p18::CommandType::SetOutputMode},
{"set-battery-cut-off-voltage", p18::CommandType::SetBatteryCutOffVoltage}, {"set-battery-cutoff-voltage", p18::CommandType::SetBatteryCutOffVoltage},
{"set-solar-configuration", p18::CommandType::SetSolarConfig}, {"set-solar-configuration", p18::CommandType::SetSolarConfig},
{"clear-generated-data", p18::CommandType::ClearGenerated}, {"clear-generated-data", p18::CommandType::ClearGenerated},
{"set-date-time", p18::CommandType::SetDateTime}, {"set-date-time", p18::CommandType::SetDateTime},
{"set-ac-charging-time", p18::CommandType::SetACChargingTimeBucket}, {"set-ac-charge-time", p18::CommandType::SetACChargeTimeBucket},
{"set-ac-loads-supply-time", p18::CommandType::SetACLoadsSupplyTimeBucket}, {"set-ac-supply-time", p18::CommandType::SetACSupplyTimeBucket},
}; };
static void validate_date_args(const std::string* ys, const std::string* ms, const std::string* ds) { static void validate_date_args(const std::string* ys, const std::string* ms, const std::string* ds) {
@ -200,7 +200,7 @@ p18::CommandType validate_input(std::string& command,
throw std::invalid_argument("invalid argument"); throw std::invalid_argument("invalid argument");
break; break;
case p18::CommandType::SetLoads: { case p18::CommandType::SetACSupply: {
GET_ARGS(1); GET_ARGS(1);
std::string &arg = arguments[0]; std::string &arg = arguments[0];
if (arg != "0" && arg != "1") if (arg != "0" && arg != "1")
@ -229,8 +229,8 @@ p18::CommandType validate_input(std::string& command,
break; break;
} }
case p18::CommandType::SetBatteryMaxChargingCurrent: case p18::CommandType::SetBatteryMaxChargeCurrent:
case p18::CommandType::SetBatteryMaxACChargingCurrent: { case p18::CommandType::SetBatteryMaxACChargeCurrent: {
GET_ARGS(2); GET_ARGS(2);
auto id = static_cast<unsigned>(std::stoul(arguments[0])); auto id = static_cast<unsigned>(std::stoul(arguments[0]));
@ -254,7 +254,7 @@ p18::CommandType validate_input(std::string& command,
break; break;
} }
case p18::CommandType::SetBatteryMaxChargingVoltage: { case p18::CommandType::SetBatteryMaxChargeVoltage: {
GET_ARGS(2); GET_ARGS(2);
float cv = std::stof(arguments[0]); float cv = std::stof(arguments[0]);
@ -269,13 +269,13 @@ p18::CommandType validate_input(std::string& command,
break; break;
} }
case p18::CommandType::SetACOutputRatedVoltage: { case p18::CommandType::SetACOutputVoltage: {
GET_ARGS(1); GET_ARGS(1);
auto v = static_cast<unsigned>(std::stoul(arguments[0])); auto v = static_cast<unsigned>(std::stoul(arguments[0]));
bool matchFound = false; bool matchFound = false;
for (const auto &item: p18::ac_output_rated_voltages) { for (const auto &item: p18::ac_output_voltages) {
if (v == item) { if (v == item) {
matchFound = true; matchFound = true;
break; break;
@ -301,26 +301,26 @@ p18::CommandType validate_input(std::string& command,
break; break;
} }
case p18::CommandType::SetBatteryChargingThresholds: { case p18::CommandType::SetBatteryChargeThresholds: {
GET_ARGS(2); GET_ARGS(2);
float cv = std::stof(arguments[0]); float cv = std::stof(arguments[0]);
float dv = std::stof(arguments[1]); float dv = std::stof(arguments[1]);
if (index_of(p18::bat_ac_recharging_voltages_12v, cv) == -1 && if (index_of(p18::bat_ac_recharge_voltages_12v, cv) == -1 &&
index_of(p18::bat_ac_recharging_voltages_24v, cv) == -1 && index_of(p18::bat_ac_recharge_voltages_24v, cv) == -1 &&
index_of(p18::bat_ac_recharging_voltages_48v, cv) == -1) index_of(p18::bat_ac_recharge_voltages_48v, cv) == -1)
throw std::invalid_argument("invalid CV"); throw std::invalid_argument("invalid CV");
if (index_of(p18::bat_ac_redischarging_voltages_12v, dv) == -1 && if (index_of(p18::bat_ac_redischarge_voltages_12v, dv) == -1 &&
index_of(p18::bat_ac_redischarging_voltages_24v, dv) == -1 && index_of(p18::bat_ac_redischarge_voltages_24v, dv) == -1 &&
index_of(p18::bat_ac_redischarging_voltages_48v, dv) == -1) index_of(p18::bat_ac_redischarge_voltages_48v, dv) == -1)
throw std::invalid_argument("invalid DV"); throw std::invalid_argument("invalid DV");
break; break;
} }
case p18::CommandType::SetChargingSourcePriority: { case p18::CommandType::SetChargeSourcePriority: {
GET_ARGS(2); GET_ARGS(2);
auto id = static_cast<unsigned>(std::stoul(arguments[0])); auto id = static_cast<unsigned>(std::stoul(arguments[0]));
@ -370,14 +370,14 @@ p18::CommandType validate_input(std::string& command,
break; break;
} }
case p18::CommandType::SetOutputModel: { case p18::CommandType::SetOutputMode: {
GET_ARGS(2); GET_ARGS(2);
auto id = static_cast<unsigned>(std::stoul(arguments[0])); auto id = static_cast<unsigned>(std::stoul(arguments[0]));
if (!p18::is_valid_parallel_id(id)) if (!p18::is_valid_parallel_id(id))
throw std::invalid_argument("invalid id"); throw std::invalid_argument("invalid id");
std::array<std::string, 5> allowed({"SM", "P", "P1", "P2", "P3"}); std::array<std::string, 5> allowed({"S", "P", "1", "2", "3"});
long index = index_of(allowed, arguments[1]); long index = index_of(allowed, arguments[1]);
if (index == -1) if (index == -1)
throw std::invalid_argument("invalid model"); throw std::invalid_argument("invalid model");
@ -414,8 +414,8 @@ p18::CommandType validate_input(std::string& command,
break; break;
} }
case p18::CommandType::SetACChargingTimeBucket: case p18::CommandType::SetACChargeTimeBucket:
case p18::CommandType::SetACLoadsSupplyTimeBucket: { case p18::CommandType::SetACSupplyTimeBucket: {
GET_ARGS(2); GET_ARGS(2);
std::vector<std::string> start = split(arguments[0], ':'); std::vector<std::string> start = split(arguments[0], ':');

124
src/p18/defines.cc
View File

@ -8,60 +8,60 @@
namespace p18 { namespace p18 {
const std::map<CommandType, std::string> raw_commands = { const std::map<CommandType, std::string> raw_commands = {
{CommandType::GetProtocolID, "PI"}, {CommandType::GetProtocolID, "PI"},
{CommandType::GetCurrentTime, "T"}, {CommandType::GetCurrentTime, "T"},
{CommandType::GetTotalGenerated, "ET"}, {CommandType::GetTotalGenerated, "ET"},
{CommandType::GetYearGenerated, "EY"}, {CommandType::GetYearGenerated, "EY"},
{CommandType::GetMonthGenerated, "EM"}, {CommandType::GetMonthGenerated, "EM"},
{CommandType::GetDayGenerated, "ED"}, {CommandType::GetDayGenerated, "ED"},
{CommandType::GetSeriesNumber, "ID"}, {CommandType::GetSerialNumber, "ID"},
{CommandType::GetCPUVersion, "VFW"}, {CommandType::GetCPUVersion, "VFW"},
{CommandType::GetRatedInformation, "PIRI"}, {CommandType::GetRatedInformation, "PIRI"},
{CommandType::GetGeneralStatus, "GS"}, {CommandType::GetGeneralStatus, "GS"},
{CommandType::GetWorkingMode, "MOD"}, {CommandType::GetWorkingMode, "MOD"},
{CommandType::GetFaultsAndWarnings, "FWS"}, {CommandType::GetFaultsAndWarnings, "FWS"},
{CommandType::GetFlagsAndStatuses, "FLAG"}, {CommandType::GetFlagsAndStatuses, "FLAG"},
{CommandType::GetDefaults, "DI"}, {CommandType::GetRatedDefaults, "DI"},
{CommandType::GetAllowedChargingCurrents, "MCHGCR"}, {CommandType::GetAllowedChargeCurrents, "MCHGCR"},
{CommandType::GetAllowedACChargingCurrents, "MUCHGCR"}, {CommandType::GetAllowedACChargeCurrents, "MUCHGCR"},
{CommandType::GetParallelRatedInformation, "PRI"}, {CommandType::GetParallelRatedInformation, "PRI"},
{CommandType::GetParallelGeneralStatus, "PGS"}, {CommandType::GetParallelGeneralStatus, "PGS"},
{CommandType::GetACChargingTimeBucket, "ACCT"}, {CommandType::GetACChargeTimeBucket, "ACCT"},
{CommandType::GetACLoadsSupplyTimeBucket, "ACLT"}, {CommandType::GetACSupplyTimeBucket, "ACLT"},
{CommandType::SetLoads, "LON"}, {CommandType::SetACSupply, "LON"},
{CommandType::SetFlag, "P"}, {CommandType::SetFlag, "P"},
{CommandType::SetDefaults, "PF"}, {CommandType::SetDefaults, "PF"},
{CommandType::SetBatteryMaxChargingCurrent, "MCHGC"}, {CommandType::SetBatteryMaxChargeCurrent, "MCHGC"},
{CommandType::SetBatteryMaxACChargingCurrent, "MUCHGC"}, {CommandType::SetBatteryMaxACChargeCurrent, "MUCHGC"},
/* The protocol documentation defines two commands, "F50" and "F60", /* The protocol documentation defines two commands, "F50" and "F60",
but it's identical as if there were just one "F" command with an argument. */ but it's identical as if there were just one "F" command with an argument. */
{CommandType::SetACOutputFreq, "F"}, {CommandType::SetACOutputFreq, "F"},
{CommandType::SetBatteryMaxChargingVoltage, "MCHGV"}, {CommandType::SetBatteryMaxChargeVoltage, "MCHGV"},
{CommandType::SetACOutputRatedVoltage, "V"}, {CommandType::SetACOutputVoltage, "V"},
{CommandType::SetOutputSourcePriority, "POP"}, {CommandType::SetOutputSourcePriority, "POP"},
{CommandType::SetBatteryChargingThresholds, "BUCD"}, {CommandType::SetBatteryChargeThresholds, "BUCD"},
{CommandType::SetChargingSourcePriority, "PCP"}, {CommandType::SetChargeSourcePriority, "PCP"},
{CommandType::SetSolarPowerPriority, "PSP"}, {CommandType::SetSolarPowerPriority, "PSP"},
{CommandType::SetACInputVoltageRange, "PGR"}, {CommandType::SetACInputVoltageRange, "PGR"},
{CommandType::SetBatteryType, "PBT"}, {CommandType::SetBatteryType, "PBT"},
{CommandType::SetOutputModel, "POPM"}, {CommandType::SetOutputMode, "POPM"},
{CommandType::SetBatteryCutOffVoltage, "PSDV"}, {CommandType::SetBatteryCutOffVoltage, "PSDV"},
{CommandType::SetSolarConfig, "ID"}, {CommandType::SetSolarConfig, "ID"},
{CommandType::ClearGenerated, "CLE"}, {CommandType::ClearGenerated, "CLE"},
{CommandType::SetDateTime, "DAT"}, {CommandType::SetDateTime, "DAT"},
{CommandType::SetACChargingTimeBucket, "ACCT"}, {CommandType::SetACChargeTimeBucket, "ACCT"},
{CommandType::SetACLoadsSupplyTimeBucket, "ACLT"}, {CommandType::SetACSupplyTimeBucket, "ACLT"},
}; };
const std::array<int, 5> ac_output_rated_voltages = {202, 208, 220, 230, 240}; const std::array<int, 5> ac_output_voltages = {202, 208, 220, 230, 240};
const std::array<float, 8> bat_ac_recharging_voltages_12v = {11, 11.3, 11.5, 11.8, 12, 12.3, 12.5, 12.8}; const std::array<float, 8> bat_ac_recharge_voltages_12v = {11, 11.3, 11.5, 11.8, 12, 12.3, 12.5, 12.8};
const std::array<float, 8> bat_ac_recharging_voltages_24v = {22, 22.5, 23, 23.5, 24, 24.5, 25, 25.5}; const std::array<float, 8> bat_ac_recharge_voltages_24v = {22, 22.5, 23, 23.5, 24, 24.5, 25, 25.5};
const std::array<float, 8> bat_ac_recharging_voltages_48v = {44, 45, 46, 47, 48, 49, 50, 51}; const std::array<float, 8> bat_ac_recharge_voltages_48v = {44, 45, 46, 47, 48, 49, 50, 51};
const std::array<float, 12> bat_ac_redischarging_voltages_12v = {0, 12, 12.3, 12.5, 12.8, 13, 13.3, 13.5, 13.8, 14, 14.3, 14.5}; const std::array<float, 12> bat_ac_redischarge_voltages_12v = {0, 12, 12.3, 12.5, 12.8, 13, 13.3, 13.5, 13.8, 14, 14.3, 14.5};
const std::array<float, 12> bat_ac_redischarging_voltages_24v = {0, 24, 24.5, 25, 25.5, 26, 26.5, 27, 27.5, 28, 28.5, 29}; const std::array<float, 12> bat_ac_redischarge_voltages_24v = {0, 24, 24.5, 25, 25.5, 26, 26.5, 27, 27.5, 28, 28.5, 29};
const std::array<float, 12> bat_ac_redischarging_voltages_48v = {0, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58}; const std::array<float, 12> bat_ac_redischarge_voltages_48v = {0, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58};
const std::map<int, std::string> fault_codes = { const std::map<int, std::string> fault_codes = {
{1, "Fan is locked"}, {1, "Fan is locked"},
@ -133,13 +133,13 @@ ENUM_STR(OutputSourcePriority) {
ENUM_STR_DEFAULT; ENUM_STR_DEFAULT;
} }
ENUM_STR(ChargerSourcePriority) { ENUM_STR(ChargeSourcePriority) {
switch (val) { switch (val) {
case ChargerSourcePriority::SolarFirst: case ChargeSourcePriority::SolarFirst:
return os << "Solar-First"; return os << "Solar-First";
case ChargerSourcePriority::SolarAndUtility: case ChargeSourcePriority::SolarAndUtility:
return os << "Solar-and-Utility"; return os << "Solar-and-Utility";
case ChargerSourcePriority::SolarOnly: case ChargeSourcePriority::SolarOnly:
return os << "Solar-only"; return os << "Solar-only";
} }
ENUM_STR_DEFAULT; ENUM_STR_DEFAULT;
@ -161,18 +161,18 @@ ENUM_STR(Topology) {
ENUM_STR_DEFAULT; ENUM_STR_DEFAULT;
} }
ENUM_STR(OutputModelSetting) { ENUM_STR(OutputMode) {
switch (val) { switch (val) {
case OutputModelSetting::SingleModule: case OutputMode::SingleOutput:
return os << "Single module"; return os << "Single output";
case OutputModelSetting::ParallelOutput: case OutputMode::ParallelOutput:
return os << "Parallel output"; return os << "Parallel output";
case OutputModelSetting::Phase1OfThreePhaseOutput: case OutputMode::Phase_1_of_3:
return os << "Phase 1 of three phase output"; return os << "Phase 1 of 3-phase output";
case OutputModelSetting::Phase2OfThreePhaseOutput: case OutputMode::Phase_2_of_3:
return os << "Phase 2 of three phase output"; return os << "Phase 2 of 3-phase output";
case OutputModelSetting::Phase3OfThreePhaseOutput: case OutputMode::Phase_3_of_3:
return os << "Phase 3 of three phase"; return os << "Phase 3 of 3-phase";
} }
ENUM_STR_DEFAULT; ENUM_STR_DEFAULT;
} }

14
src/p18/defines.h
View File

@ -13,15 +13,15 @@ namespace p18 {
extern const std::map<CommandType, std::string> raw_commands; extern const std::map<CommandType, std::string> raw_commands;
extern const std::array<int, 5> ac_output_rated_voltages; extern const std::array<int, 5> ac_output_voltages;
extern const std::array<float, 8> bat_ac_recharging_voltages_12v; extern const std::array<float, 8> bat_ac_recharge_voltages_12v;
extern const std::array<float, 8> bat_ac_recharging_voltages_24v; extern const std::array<float, 8> bat_ac_recharge_voltages_24v;
extern const std::array<float, 8> bat_ac_recharging_voltages_48v; extern const std::array<float, 8> bat_ac_recharge_voltages_48v;
extern const std::array<float, 12> bat_ac_redischarging_voltages_12v; extern const std::array<float, 12> bat_ac_redischarge_voltages_12v;
extern const std::array<float, 12> bat_ac_redischarging_voltages_24v; extern const std::array<float, 12> bat_ac_redischarge_voltages_24v;
extern const std::array<float, 12> bat_ac_redischarging_voltages_48v; extern const std::array<float, 12> bat_ac_redischarge_voltages_48v;
extern const std::map<int, std::string> fault_codes; extern const std::map<int, std::string> fault_codes;

102
src/p18/response.cc
View File

@ -222,7 +222,7 @@ formattable_ptr TotalGenerated::format(formatter::Format format) {
} }
void SeriesNumber::unpack() { void SerialNumber::unpack() {
auto data = getData(); auto data = getData();
std::string buf(data, 2); std::string buf(data, 2);
@ -231,9 +231,9 @@ void SeriesNumber::unpack() {
id = std::string(data+2, len); id = std::string(data+2, len);
} }
formattable_ptr SeriesNumber::format(formatter::Format format) { formattable_ptr SerialNumber::format(formatter::Format format) {
RETURN_TABLE({ RETURN_TABLE({
LINE("sn", "Series number", id) LINE("sn", "Serial number", id)
}); });
} }
@ -298,15 +298,15 @@ void RatedInformation::unpack() {
battery_bulk_voltage = stou(list[11]); battery_bulk_voltage = stou(list[11]);
battery_float_voltage = stou(list[12]); battery_float_voltage = stou(list[12]);
battery_type = static_cast<BatteryType>(stou(list[13])); battery_type = static_cast<BatteryType>(stou(list[13]));
max_ac_charging_current = stou(list[14]); max_ac_charge_current = stou(list[14]);
max_charging_current = stou(list[15]); max_charge_current = stou(list[15]);
input_voltage_range = static_cast<InputVoltageRange>(stou(list[16])); input_voltage_range = static_cast<InputVoltageRange>(stou(list[16]));
output_source_priority = static_cast<OutputSourcePriority>(stou(list[17])); output_source_priority = static_cast<OutputSourcePriority>(stou(list[17]));
charger_source_priority = static_cast<ChargerSourcePriority>(stou(list[18])); charge_source_priority = static_cast<ChargeSourcePriority>(stou(list[18]));
parallel_max_num = stou(list[19]); parallel_max_num = stou(list[19]);
machine_type = static_cast<MachineType>(stou(list[20])); machine_type = static_cast<MachineType>(stou(list[20]));
topology = static_cast<Topology>(stou(list[21])); topology = static_cast<Topology>(stou(list[21]));
output_model_setting = static_cast<OutputModelSetting>(stou(list[22])); output_mode = static_cast<OutputMode>(stou(list[22]));
solar_power_priority = static_cast<SolarPowerPriority>(stou(list[23])); solar_power_priority = static_cast<SolarPowerPriority>(stou(list[23]));
mppt = list[24]; mppt = list[24];
} }
@ -327,15 +327,15 @@ formattable_ptr RatedInformation::format(formatter::Format format) {
LINE("battery_bulk_voltage", "Battery bulk voltage", battery_bulk_voltage / 10.0, Unit::V), LINE("battery_bulk_voltage", "Battery bulk voltage", battery_bulk_voltage / 10.0, Unit::V),
LINE("battery_float_voltage", "Battery float voltage", battery_float_voltage / 10.0, Unit::V), LINE("battery_float_voltage", "Battery float voltage", battery_float_voltage / 10.0, Unit::V),
LINE("battery_type", "Battery type", battery_type), LINE("battery_type", "Battery type", battery_type),
LINE("max_charging_current", "Max charging current", max_charging_current, Unit::A), LINE("max_charge_current", "Max charge current", max_charge_current, Unit::A),
LINE("max_ac_charging_current", "Max AC charging current", max_ac_charging_current, Unit::A), LINE("max_ac_charge_current", "Max AC charge current", max_ac_charge_current, Unit::A),
LINE("input_voltage_range", "Input voltage range", input_voltage_range), LINE("input_voltage_range", "Input voltage range", input_voltage_range),
LINE("output_source_priority", "Output source priority", output_source_priority), LINE("output_source_priority", "Output source priority", output_source_priority),
LINE("charge_source_priority", "Charge source priority", charger_source_priority), LINE("charge_source_priority", "Charge source priority", charge_source_priority),
LINE("parallel_max_num", "Parallel max num", parallel_max_num), LINE("parallel_max_num", "Parallel max num", parallel_max_num),
LINE("machine_type", "Machine type", machine_type), LINE("machine_type", "Machine type", machine_type),
LINE("topology", "Topology", topology), LINE("topology", "Topology", topology),
LINE("output_model_setting", "Output model setting", output_model_setting), LINE("output_mode", "Output mode", output_mode),
LINE("solar_power_priority", "Solar power priority", solar_power_priority), LINE("solar_power_priority", "Solar power priority", solar_power_priority),
LINE("mppt", "MPPT string", mppt) LINE("mppt", "MPPT string", mppt)
}); });
@ -385,7 +385,7 @@ void GeneralStatus::unpack() {
battery_voltage_scc = stou(list[8]); battery_voltage_scc = stou(list[8]);
battery_voltage_scc2 = stou(list[9]); battery_voltage_scc2 = stou(list[9]);
battery_discharge_current = stou(list[10]); battery_discharge_current = stou(list[10]);
battery_charging_current = stou(list[11]); battery_charge_current = stou(list[11]);
battery_capacity = stou(list[12]); battery_capacity = stou(list[12]);
inverter_heat_sink_temp = stou(list[13]); inverter_heat_sink_temp = stou(list[13]);
mppt1_charger_temp = stou(list[14]); mppt1_charger_temp = stou(list[14]);
@ -416,8 +416,8 @@ formattable_ptr GeneralStatus::format(formatter::Format format) {
LINE("battery_voltage", "Battery voltage", battery_voltage / 10.0, Unit::V), LINE("battery_voltage", "Battery voltage", battery_voltage / 10.0, Unit::V),
LINE("battery_voltage_scc", "Battery voltage from SCC", battery_voltage_scc / 10.0, Unit::V), LINE("battery_voltage_scc", "Battery voltage from SCC", battery_voltage_scc / 10.0, Unit::V),
LINE("battery_voltage_scc2", "Battery voltage from SCC2", battery_voltage_scc2 / 10.0, Unit::V), LINE("battery_voltage_scc2", "Battery voltage from SCC2", battery_voltage_scc2 / 10.0, Unit::V),
LINE("battery_discharging_current", "Battery discharging current", battery_discharge_current, Unit::A), LINE("battery_discharge_current", "Battery discharge current", battery_discharge_current, Unit::A),
LINE("battery_charging_current", "Battery charging current", battery_charging_current, Unit::A), LINE("battery_charge_current", "Battery charge current", battery_charge_current, Unit::A),
LINE("battery_capacity", "Battery capacity", battery_capacity, Unit::Percentage), LINE("battery_capacity", "Battery capacity", battery_capacity, Unit::Percentage),
LINE("inverter_heat_sink_temp", "Inverter heat sink temperature", inverter_heat_sink_temp, Unit::Celsius), LINE("inverter_heat_sink_temp", "Inverter heat sink temperature", inverter_heat_sink_temp, Unit::Celsius),
LINE("mppt1_charger_temp", "MPPT1 charger temperature", mppt1_charger_temp, Unit::Celsius), LINE("mppt1_charger_temp", "MPPT1 charger temperature", mppt1_charger_temp, Unit::Celsius),
@ -546,7 +546,7 @@ formattable_ptr FlagsAndStatuses::format(formatter::Format format) {
} }
void Defaults::unpack() { void RatedDefaults::unpack() {
auto list = getList({ auto list = getList({
4, // AAAA 4, // AAAA
3, // BBB 3, // BBB
@ -582,14 +582,14 @@ void Defaults::unpack() {
charging_bulk_voltage = stou(list[5]); charging_bulk_voltage = stou(list[5]);
battery_recharge_voltage = stou(list[6]); battery_recharge_voltage = stou(list[6]);
battery_redischarge_voltage = stou(list[7]); battery_redischarge_voltage = stou(list[7]);
max_charging_current = stou(list[8]); max_charge_current = stou(list[8]);
max_ac_charging_current = stou(list[9]); max_ac_charge_current = stou(list[9]);
battery_type = static_cast<BatteryType>(stou(list[10])); battery_type = static_cast<BatteryType>(stou(list[10]));
output_source_priority = static_cast<OutputSourcePriority>(stou(list[11])); output_source_priority = static_cast<OutputSourcePriority>(stou(list[11]));
charger_source_priority = static_cast<ChargerSourcePriority>(stou(list[12])); charge_source_priority = static_cast<ChargeSourcePriority>(stou(list[12]));
solar_power_priority = static_cast<SolarPowerPriority>(stou(list[13])); solar_power_priority = static_cast<SolarPowerPriority>(stou(list[13]));
machine_type = static_cast<MachineType>(stou(list[14])); machine_type = static_cast<MachineType>(stou(list[14]));
output_model_setting = static_cast<OutputModelSetting>(stou(list[15])); output_mode = static_cast<OutputMode>(stou(list[15]));
flag_buzzer = stou(list[16]) > 0; flag_buzzer = stou(list[16]) > 0;
flag_overload_restart = stou(list[17]) > 0; flag_overload_restart = stou(list[17]) > 0;
flag_over_temp_restart = stou(list[18]) > 0; flag_over_temp_restart = stou(list[18]) > 0;
@ -600,7 +600,7 @@ void Defaults::unpack() {
flag_lcd_escape_to_default_page_after_1min_timeout = stou(list[23]) > 0; flag_lcd_escape_to_default_page_after_1min_timeout = stou(list[23]) > 0;
} }
formattable_ptr Defaults::format(formatter::Format format) { formattable_ptr RatedDefaults::format(formatter::Format format) {
RETURN_TABLE({ RETURN_TABLE({
LINE("ac_output_voltage", "AC output voltage", ac_output_voltage / 10.0, Unit::V), LINE("ac_output_voltage", "AC output voltage", ac_output_voltage / 10.0, Unit::V),
LINE("ac_output_freq", "AC output frequency", ac_output_freq / 10.0, Unit::Hz), LINE("ac_output_freq", "AC output frequency", ac_output_freq / 10.0, Unit::Hz),
@ -608,16 +608,16 @@ formattable_ptr Defaults::format(formatter::Format format) {
LINE("battery_under_voltage", "Battery under voltage", battery_under_voltage / 10.0, Unit::V), LINE("battery_under_voltage", "Battery under voltage", battery_under_voltage / 10.0, Unit::V),
LINE("battery_bulk_voltage", "Charging bulk voltage", charging_bulk_voltage / 10.0, Unit::V), LINE("battery_bulk_voltage", "Charging bulk voltage", charging_bulk_voltage / 10.0, Unit::V),
LINE("battery_float_voltage", "Charging float voltage", charging_float_voltage / 10.0, Unit::V), LINE("battery_float_voltage", "Charging float voltage", charging_float_voltage / 10.0, Unit::V),
LINE("battery_recharging_voltage", "Battery re-charging voltage", battery_recharge_voltage / 10.0, Unit::V), LINE("battery_recharge_voltage", "Battery re-charge voltage", battery_recharge_voltage / 10.0, Unit::V),
LINE("battery_redischarging_voltage", "Battery re-discharging voltage", battery_redischarge_voltage / 10.0, Unit::V), LINE("battery_redischarge_voltage", "Battery re-discharge voltage", battery_redischarge_voltage / 10.0, Unit::V),
LINE("max_charging_current", "Max charging current", max_charging_current, Unit::A), LINE("max_charge_current", "Max charge current", max_charge_current, Unit::A),
LINE("max_ac_charging_current", "Max AC charging current", max_ac_charging_current, Unit::A), LINE("max_ac_charge_current", "Max AC charge current", max_ac_charge_current, Unit::A),
LINE("battery_type", "Battery type", battery_type), LINE("battery_type", "Battery type", battery_type),
LINE("output_source_priority", "Output source priority", output_source_priority), LINE("output_source_priority", "Output source priority", output_source_priority),
LINE("charger_source_priority", "Charger source priority", charger_source_priority), LINE("charge_source_priority", "Charge source priority", charge_source_priority),
LINE("solar_power_priority", "Solar power priority", solar_power_priority), LINE("solar_power_priority", "Solar power priority", solar_power_priority),
LINE("machine_type", "Machine type", machine_type), LINE("machine_type", "Machine type", machine_type),
LINE("output_model_setting", "Output model setting", output_model_setting), LINE("output_mode", "Output mode", output_mode),
LINE("buzzer_flag", "Buzzer flag", flag_buzzer), LINE("buzzer_flag", "Buzzer flag", flag_buzzer),
LINE("overload_bypass_flag", "Overload bypass function flag", flag_overload_bypass), LINE("overload_bypass_flag", "Overload bypass function flag", flag_overload_bypass),
LINE("escape_to_default_screen_after_1min_timeout_flag", "Escape to default screen after 1min timeout flag", flag_lcd_escape_to_default_page_after_1min_timeout), LINE("escape_to_default_screen_after_1min_timeout_flag", "Escape to default screen after 1min timeout flag", flag_lcd_escape_to_default_page_after_1min_timeout),
@ -629,14 +629,14 @@ formattable_ptr Defaults::format(formatter::Format format) {
}) })
} }
void AllowedChargingCurrents::unpack() { void AllowedChargeCurrents::unpack() {
auto list = getList({}); auto list = getList({});
for (const std::string& i: list) { for (const std::string& i: list) {
amps.emplace_back(stou(i)); amps.emplace_back(stou(i));
} }
} }
formattable_ptr AllowedChargingCurrents::format(formatter::Format format) { formattable_ptr AllowedChargeCurrents::format(formatter::Format format) {
std::vector<formatter::ListItem<VariantHolder>> v; std::vector<formatter::ListItem<VariantHolder>> v;
for (const auto& n: amps) for (const auto& n: amps)
v.emplace_back(n); v.emplace_back(n);
@ -663,23 +663,23 @@ void ParallelRatedInformation::unpack() {
1 // G 1 // G
}); });
parallel_id_connection_status = static_cast<ParallelConnectionStatus>(stou(list[0])); parallel_connection_status = static_cast<ParallelConnectionStatus>(stou(list[0]));
serial_number_valid_length = stou(list[1]); serial_number_valid_length = stou(list[1]);
serial_number = std::string(list[2], 0, serial_number_valid_length); serial_number = std::string(list[2], 0, serial_number_valid_length);
charger_source_priority = static_cast<ChargerSourcePriority>(stou(list[3])); charge_source_priority = static_cast<ChargeSourcePriority>(stou(list[3]));
max_charging_current = stou(list[4]); max_charge_current = stou(list[4]);
max_ac_charging_current = stou(list[5]); max_ac_charge_current = stou(list[5]);
output_model_setting = static_cast<OutputModelSetting>(stou(list[6])); output_mode = static_cast<OutputMode>(stou(list[6]));
} }
formattable_ptr ParallelRatedInformation::format(formatter::Format format) { formattable_ptr ParallelRatedInformation::format(formatter::Format format) {
RETURN_TABLE({ RETURN_TABLE({
LINE("parallel_id_connection_status", "Parallel ID connection status", parallel_id_connection_status), LINE("parallel_connection_status", "Parallel connection status", parallel_connection_status),
LINE("serial_number", "Serial number", serial_number), LINE("serial_number", "Serial number", serial_number),
LINE("charger_source_priority", "Charger source priority", charger_source_priority), LINE("charge_source_priority", "Charge source priority", charge_source_priority),
LINE("max_charging_current", "Max charging current", max_charging_current, Unit::A), LINE("max_charge_current", "Max charge current", max_charge_current, Unit::A),
LINE("max_ac_charging_current", "Max AC charging current", max_ac_charging_current, Unit::A), LINE("max_ac_charge_current", "Max AC charge current", max_ac_charge_current, Unit::A),
LINE("output_model_setting", "Output model setting", output_model_setting), LINE("output_mode", "Output mode", output_mode),
}) })
} }
@ -721,7 +721,7 @@ void ParallelGeneralStatus::unpack() {
// https://github.com/gch1p/inverter-tools/issues/1#issuecomment-981158688 // https://github.com/gch1p/inverter-tools/issues/1#issuecomment-981158688
}, 28); }, 28);
parallel_id_connection_status = static_cast<ParallelConnectionStatus>(stou(list[0])); parallel_connection_status = static_cast<ParallelConnectionStatus>(stou(list[0]));
work_mode = static_cast<p18::WorkingMode>(stou(list[1])); work_mode = static_cast<p18::WorkingMode>(stou(list[1]));
fault_code = stou(list[2]); fault_code = stou(list[2]);
grid_voltage = stou(list[3]); grid_voltage = stou(list[3]);
@ -736,8 +736,8 @@ void ParallelGeneralStatus::unpack() {
total_output_load_percent = stou(list[12]); total_output_load_percent = stou(list[12]);
battery_voltage = stou(list[13]); battery_voltage = stou(list[13]);
battery_discharge_current = stou(list[14]); battery_discharge_current = stou(list[14]);
battery_charging_current = stou(list[15]); battery_charge_current = stou(list[15]);
total_battery_charging_current = stou(list[16]); total_battery_charge_current = stou(list[16]);
battery_capacity = stou(list[17]); battery_capacity = stou(list[17]);
pv1_input_power = stou(list[18]); pv1_input_power = stou(list[18]);
pv2_input_power = stou(list[19]); pv2_input_power = stou(list[19]);
@ -757,7 +757,7 @@ void ParallelGeneralStatus::unpack() {
formattable_ptr ParallelGeneralStatus::format(formatter::Format format) { formattable_ptr ParallelGeneralStatus::format(formatter::Format format) {
auto table = new formatter::Table<VariantHolder>(format, { auto table = new formatter::Table<VariantHolder>(format, {
LINE("parallel_id_connection_status", "Parallel ID connection status", parallel_id_connection_status), LINE("parallel_connection_status", "Parallel connection status", parallel_connection_status),
LINE("mode", "Working mode", work_mode), LINE("mode", "Working mode", work_mode),
LINE("fault_code", "Fault code", fault_code), LINE("fault_code", "Fault code", fault_code),
LINE("grid_voltage", "Grid voltage", grid_voltage / 10.0, Unit::V), LINE("grid_voltage", "Grid voltage", grid_voltage / 10.0, Unit::V),
@ -772,11 +772,13 @@ formattable_ptr ParallelGeneralStatus::format(formatter::Format format) {
LINE("total_output_load_percent", "Total output load percent", total_output_load_percent, Unit::Percentage), LINE("total_output_load_percent", "Total output load percent", total_output_load_percent, Unit::Percentage),
LINE("battery_voltage", "Battery voltage", battery_voltage / 10.0, Unit::V), LINE("battery_voltage", "Battery voltage", battery_voltage / 10.0, Unit::V),
LINE("battery_discharge_current", "Battery discharge current", battery_discharge_current, Unit::A), LINE("battery_discharge_current", "Battery discharge current", battery_discharge_current, Unit::A),
LINE("battery_charging_current", "Battery charging current", battery_charging_current, Unit::A), LINE("battery_charge_current", "Battery charge current", battery_charge_current, Unit::A),
LINE("pv1_input_power", "PV1 Input power", pv1_input_power, Unit::Wh), LINE("total_battery_charge_current", "Total battery charge current", total_battery_charge_current, Unit::A),
LINE("pv2_input_power", "PV2 Input power", pv2_input_power, Unit::Wh), LINE("battery_capacity", "Battery capacity", battery_capacity, Unit::Percentage),
LINE("pv1_input_voltage", "PV1 Input voltage", pv1_input_voltage / 10.0, Unit::V), LINE("pv1_input_power", "PV1 input power", pv1_input_power, Unit::Wh),
LINE("pv2_input_voltage", "PV2 Input voltage", pv2_input_voltage / 10.0, Unit::V), LINE("pv2_input_power", "PV2 input power", pv2_input_power, Unit::Wh),
LINE("pv1_input_voltage", "PV1 input voltage", pv1_input_voltage / 10.0, Unit::V),
LINE("pv2_input_voltage", "PV2 input voltage", pv2_input_voltage / 10.0, Unit::V),
LINE("mppt1_charger_status", "MPPT1 charger status", mppt1_charger_status), LINE("mppt1_charger_status", "MPPT1 charger status", mppt1_charger_status),
LINE("mppt2_charger_status", "MPPT2 charger status", mppt2_charger_status), LINE("mppt2_charger_status", "MPPT2 charger status", mppt2_charger_status),
LINE("load_connected", "Load connection", load_connected), LINE("load_connected", "Load connection", load_connected),
@ -787,7 +789,7 @@ formattable_ptr ParallelGeneralStatus::format(formatter::Format format) {
if (max_temp_present) { if (max_temp_present) {
table->push( table->push(
LINE("max_temp", "Max. temperature", max_temp) LINE("max_temp", "Max. temperature", max_temp)
); );
} }
@ -795,7 +797,7 @@ formattable_ptr ParallelGeneralStatus::format(formatter::Format format) {
} }
void ACChargingTimeBucket::unpack() { void ACChargeTimeBucket::unpack() {
auto list = getList({4 /* AAAA */, 4 /* BBBB */}); auto list = getList({4 /* AAAA */, 4 /* BBBB */});
start_h = stouh(list[0].substr(0, 2)); start_h = stouh(list[0].substr(0, 2));
@ -812,7 +814,7 @@ static inline std::string get_time(unsigned short h, unsigned short m) {
return buf.str(); return buf.str();
} }
formattable_ptr ACChargingTimeBucket::format(formatter::Format format) { formattable_ptr ACChargeTimeBucket::format(formatter::Format format) {
RETURN_TABLE({ RETURN_TABLE({
LINE("start_time", "Start time", get_time(start_h, start_m)), LINE("start_time", "Start time", get_time(start_h, start_m)),
LINE("end_time", "End time", get_time(end_h, end_m)), LINE("end_time", "End time", get_time(end_h, end_m)),

62
src/p18/response.h
View File

@ -32,7 +32,7 @@ typedef std::variant<
std::string, std::string,
p18::BatteryType, p18::BatteryType,
p18::BatteryPowerDirection, p18::BatteryPowerDirection,
p18::ChargerSourcePriority, p18::ChargeSourcePriority,
p18::DC_AC_PowerDirection, p18::DC_AC_PowerDirection,
p18::InputVoltageRange, p18::InputVoltageRange,
p18::LinePowerDirection, p18::LinePowerDirection,
@ -40,7 +40,7 @@ typedef std::variant<
p18::MPPTChargerStatus, p18::MPPTChargerStatus,
p18::Topology, p18::Topology,
p18::OutputSourcePriority, p18::OutputSourcePriority,
p18::OutputModelSetting, p18::OutputMode,
p18::ParallelConnectionStatus, p18::ParallelConnectionStatus,
p18::SolarPowerPriority, p18::SolarPowerPriority,
p18::WorkingMode, p18::WorkingMode,
@ -62,7 +62,7 @@ public:
VariantHolder(std::string v) : v_(v) {} VariantHolder(std::string v) : v_(v) {}
VariantHolder(p18::BatteryType v) : v_(v) {} VariantHolder(p18::BatteryType v) : v_(v) {}
VariantHolder(p18::BatteryPowerDirection v) : v_(v) {} VariantHolder(p18::BatteryPowerDirection v) : v_(v) {}
VariantHolder(p18::ChargerSourcePriority v) : v_(v) {} VariantHolder(p18::ChargeSourcePriority v) : v_(v) {}
VariantHolder(p18::DC_AC_PowerDirection v) : v_(v) {} VariantHolder(p18::DC_AC_PowerDirection v) : v_(v) {}
VariantHolder(p18::InputVoltageRange v) : v_(v) {} VariantHolder(p18::InputVoltageRange v) : v_(v) {}
VariantHolder(p18::LinePowerDirection v) : v_(v) {} VariantHolder(p18::LinePowerDirection v) : v_(v) {}
@ -70,7 +70,7 @@ public:
VariantHolder(p18::MPPTChargerStatus v) : v_(v) {} VariantHolder(p18::MPPTChargerStatus v) : v_(v) {}
VariantHolder(p18::Topology v) : v_(v) {} VariantHolder(p18::Topology v) : v_(v) {}
VariantHolder(p18::OutputSourcePriority v) : v_(v) {} VariantHolder(p18::OutputSourcePriority v) : v_(v) {}
VariantHolder(p18::OutputModelSetting v) : v_(v) {} VariantHolder(p18::OutputMode v) : v_(v) {}
VariantHolder(p18::ParallelConnectionStatus v) : v_(v) {} VariantHolder(p18::ParallelConnectionStatus v) : v_(v) {}
VariantHolder(p18::SolarPowerPriority v) : v_(v) {} VariantHolder(p18::SolarPowerPriority v) : v_(v) {}
VariantHolder(p18::WorkingMode v) : v_(v) {} VariantHolder(p18::WorkingMode v) : v_(v) {}
@ -89,7 +89,7 @@ public:
bool isEnum = bool isEnum =
std::holds_alternative<p18::BatteryType>(v_) || std::holds_alternative<p18::BatteryType>(v_) ||
std::holds_alternative<p18::BatteryPowerDirection>(v_) || std::holds_alternative<p18::BatteryPowerDirection>(v_) ||
std::holds_alternative<p18::ChargerSourcePriority>(v_) || std::holds_alternative<p18::ChargeSourcePriority>(v_) ||
std::holds_alternative<p18::DC_AC_PowerDirection>(v_) || std::holds_alternative<p18::DC_AC_PowerDirection>(v_) ||
std::holds_alternative<p18::InputVoltageRange>(v_) || std::holds_alternative<p18::InputVoltageRange>(v_) ||
std::holds_alternative<p18::LinePowerDirection>(v_) || std::holds_alternative<p18::LinePowerDirection>(v_) ||
@ -97,7 +97,7 @@ public:
std::holds_alternative<p18::MPPTChargerStatus>(v_) || std::holds_alternative<p18::MPPTChargerStatus>(v_) ||
std::holds_alternative<p18::Topology>(v_) || std::holds_alternative<p18::Topology>(v_) ||
std::holds_alternative<p18::OutputSourcePriority>(v_) || std::holds_alternative<p18::OutputSourcePriority>(v_) ||
std::holds_alternative<p18::OutputModelSetting>(v_) || std::holds_alternative<p18::OutputMode>(v_) ||
std::holds_alternative<p18::ParallelConnectionStatus>(v_) || std::holds_alternative<p18::ParallelConnectionStatus>(v_) ||
std::holds_alternative<p18::SolarPowerPriority>(v_) || std::holds_alternative<p18::SolarPowerPriority>(v_) ||
std::holds_alternative<p18::WorkingMode>(v_) || std::holds_alternative<p18::WorkingMode>(v_) ||
@ -249,7 +249,7 @@ public:
using TotalGenerated::TotalGenerated; using TotalGenerated::TotalGenerated;
}; };
class SeriesNumber : public GetResponse { class SerialNumber : public GetResponse {
public: public:
using GetResponse::GetResponse; using GetResponse::GetResponse;
void unpack() override; void unpack() override;
@ -289,15 +289,15 @@ public:
unsigned battery_bulk_voltage; /* unit: 0.1V */ unsigned battery_bulk_voltage; /* unit: 0.1V */
unsigned battery_float_voltage; /* unit: 0.1V */ unsigned battery_float_voltage; /* unit: 0.1V */
p18::BatteryType battery_type; p18::BatteryType battery_type;
unsigned max_ac_charging_current; /* unit: A */ unsigned max_ac_charge_current; /* unit: A */
unsigned max_charging_current; /* unit: A */ unsigned max_charge_current; /* unit: A */
p18::InputVoltageRange input_voltage_range; p18::InputVoltageRange input_voltage_range;
p18::OutputSourcePriority output_source_priority; p18::OutputSourcePriority output_source_priority;
p18::ChargerSourcePriority charger_source_priority; p18::ChargeSourcePriority charge_source_priority;
unsigned parallel_max_num; unsigned parallel_max_num;
p18::MachineType machine_type; p18::MachineType machine_type;
p18::Topology topology; p18::Topology topology;
p18::OutputModelSetting output_model_setting; p18::OutputMode output_mode;
p18::SolarPowerPriority solar_power_priority; p18::SolarPowerPriority solar_power_priority;
std::string mppt; std::string mppt;
}; };
@ -319,7 +319,7 @@ public:
unsigned battery_voltage_scc; /* unit: 0.1V */ unsigned battery_voltage_scc; /* unit: 0.1V */
unsigned battery_voltage_scc2; /* unit: 0.1V */ unsigned battery_voltage_scc2; /* unit: 0.1V */
unsigned battery_discharge_current; /* unit: A */ unsigned battery_discharge_current; /* unit: A */
unsigned battery_charging_current; /* unit: A */ unsigned battery_charge_current; /* unit: A */
unsigned battery_capacity; /* unit: % */ unsigned battery_capacity; /* unit: % */
unsigned inverter_heat_sink_temp; /* unit: C */ unsigned inverter_heat_sink_temp; /* unit: C */
unsigned mppt1_charger_temp; /* unit: C */ unsigned mppt1_charger_temp; /* unit: C */
@ -389,7 +389,7 @@ public:
char reserved = '0'; char reserved = '0';
}; };
class Defaults : public GetResponse { class RatedDefaults : public GetResponse {
public: public:
using GetResponse::GetResponse; using GetResponse::GetResponse;
void unpack() override; void unpack() override;
@ -403,14 +403,14 @@ public:
unsigned charging_bulk_voltage = 0; unsigned charging_bulk_voltage = 0;
unsigned battery_recharge_voltage = 0; unsigned battery_recharge_voltage = 0;
unsigned battery_redischarge_voltage = 0; unsigned battery_redischarge_voltage = 0;
unsigned max_charging_current = 0; unsigned max_charge_current = 0;
unsigned max_ac_charging_current = 0; unsigned max_ac_charge_current = 0;
p18::BatteryType battery_type = static_cast<BatteryType>(0); p18::BatteryType battery_type = static_cast<BatteryType>(0);
p18::OutputSourcePriority output_source_priority = static_cast<OutputSourcePriority>(0); p18::OutputSourcePriority output_source_priority = static_cast<OutputSourcePriority>(0);
p18::ChargerSourcePriority charger_source_priority = static_cast<ChargerSourcePriority>(0); p18::ChargeSourcePriority charge_source_priority = static_cast<ChargeSourcePriority>(0);
p18::SolarPowerPriority solar_power_priority = static_cast<SolarPowerPriority>(0); p18::SolarPowerPriority solar_power_priority = static_cast<SolarPowerPriority>(0);
p18::MachineType machine_type = static_cast<MachineType>(0); p18::MachineType machine_type = static_cast<MachineType>(0);
p18::OutputModelSetting output_model_setting = static_cast<OutputModelSetting>(0); p18::OutputMode output_mode = static_cast<OutputMode>(0);
bool flag_buzzer = false; bool flag_buzzer = false;
bool flag_overload_restart = false; bool flag_overload_restart = false;
bool flag_over_temp_restart = false; bool flag_over_temp_restart = false;
@ -421,7 +421,7 @@ public:
bool flag_lcd_escape_to_default_page_after_1min_timeout = false; bool flag_lcd_escape_to_default_page_after_1min_timeout = false;
}; };
class AllowedChargingCurrents : public GetResponse { class AllowedChargeCurrents : public GetResponse {
public: public:
using GetResponse::GetResponse; using GetResponse::GetResponse;
void unpack() override; void unpack() override;
@ -430,9 +430,9 @@ public:
std::vector<unsigned> amps; std::vector<unsigned> amps;
}; };
class AllowedACChargingCurrents : public AllowedChargingCurrents { class AllowedACChargeCurrents : public AllowedChargeCurrents {
public: public:
using AllowedChargingCurrents::AllowedChargingCurrents; using AllowedChargeCurrents::AllowedChargeCurrents;
}; };
class ParallelRatedInformation : public GetResponse { class ParallelRatedInformation : public GetResponse {
@ -441,13 +441,13 @@ public:
void unpack() override; void unpack() override;
formattable_ptr format(formatter::Format format) override; formattable_ptr format(formatter::Format format) override;
p18::ParallelConnectionStatus parallel_id_connection_status = static_cast<ParallelConnectionStatus>(0); p18::ParallelConnectionStatus parallel_connection_status = static_cast<ParallelConnectionStatus>(0);
unsigned serial_number_valid_length = 0; unsigned serial_number_valid_length = 0;
std::string serial_number; std::string serial_number;
p18::ChargerSourcePriority charger_source_priority = static_cast<ChargerSourcePriority>(0); p18::ChargeSourcePriority charge_source_priority = static_cast<ChargeSourcePriority>(0);
unsigned max_ac_charging_current = 0; // unit: A unsigned max_ac_charge_current = 0; // unit: A
unsigned max_charging_current = 0; // unit: A unsigned max_charge_current = 0; // unit: A
p18::OutputModelSetting output_model_setting = static_cast<OutputModelSetting>(0); p18::OutputMode output_mode = static_cast<OutputMode>(0);
}; };
class ParallelGeneralStatus : public GetResponse { class ParallelGeneralStatus : public GetResponse {
@ -456,7 +456,7 @@ public:
void unpack() override; void unpack() override;
formattable_ptr format(formatter::Format format) override; formattable_ptr format(formatter::Format format) override;
p18::ParallelConnectionStatus parallel_id_connection_status; p18::ParallelConnectionStatus parallel_connection_status;
p18::WorkingMode work_mode; p18::WorkingMode work_mode;
unsigned fault_code; unsigned fault_code;
unsigned grid_voltage; /* unit: 0.1V */ unsigned grid_voltage; /* unit: 0.1V */
@ -471,8 +471,8 @@ public:
unsigned total_output_load_percent; /* unit: % */ unsigned total_output_load_percent; /* unit: % */
unsigned battery_voltage; /* unit: 0.1V */ unsigned battery_voltage; /* unit: 0.1V */
unsigned battery_discharge_current; /* unit: A */ unsigned battery_discharge_current; /* unit: A */
unsigned battery_charging_current; /* unit: A */ unsigned battery_charge_current; /* unit: A */
unsigned total_battery_charging_current; /* unit: A */ unsigned total_battery_charge_current; /* unit: A */
unsigned battery_capacity; /* unit: % */ unsigned battery_capacity; /* unit: % */
unsigned pv1_input_power; /* unit: W */ unsigned pv1_input_power; /* unit: W */
unsigned pv2_input_power; /* unit: W */ unsigned pv2_input_power; /* unit: W */
@ -489,7 +489,7 @@ public:
unsigned max_temp; /* unit: C */ unsigned max_temp; /* unit: C */
}; };
class ACChargingTimeBucket : public GetResponse { class ACChargeTimeBucket : public GetResponse {
public: public:
using GetResponse::GetResponse; using GetResponse::GetResponse;
void unpack() override; void unpack() override;
@ -501,9 +501,9 @@ public:
unsigned short end_m = 0; unsigned short end_m = 0;
}; };
class ACLoadsSupplyTimeBucket : public ACChargingTimeBucket { class ACSupplyTimeBucket : public ACChargeTimeBucket {
public: public:
using ACChargingTimeBucket::ACChargingTimeBucket; using ACChargeTimeBucket::ACChargeTimeBucket;
}; };
} // namespace p18 } // namespace p18

50
src/p18/types.h
View File

@ -17,41 +17,41 @@ enum class CommandType {
GetYearGenerated, GetYearGenerated,
GetMonthGenerated, GetMonthGenerated,
GetDayGenerated, GetDayGenerated,
GetSeriesNumber, GetSerialNumber,
GetCPUVersion, GetCPUVersion,
GetRatedInformation, GetRatedInformation,
GetGeneralStatus, GetGeneralStatus,
GetWorkingMode, GetWorkingMode,
GetFaultsAndWarnings, GetFaultsAndWarnings,
GetFlagsAndStatuses, GetFlagsAndStatuses,
GetDefaults, GetRatedDefaults,
GetAllowedChargingCurrents, GetAllowedChargeCurrents,
GetAllowedACChargingCurrents, GetAllowedACChargeCurrents,
GetParallelRatedInformation, GetParallelRatedInformation,
GetParallelGeneralStatus, GetParallelGeneralStatus,
GetACChargingTimeBucket, GetACChargeTimeBucket,
GetACLoadsSupplyTimeBucket, GetACSupplyTimeBucket,
SetLoads = 100, SetACSupply = 100,
SetFlag, SetFlag,
SetDefaults, SetDefaults,
SetBatteryMaxChargingCurrent, SetBatteryMaxChargeCurrent,
SetBatteryMaxACChargingCurrent, SetBatteryMaxACChargeCurrent,
SetACOutputFreq, SetACOutputFreq,
SetBatteryMaxChargingVoltage, SetBatteryMaxChargeVoltage,
SetACOutputRatedVoltage, SetACOutputVoltage,
SetOutputSourcePriority, SetOutputSourcePriority,
SetBatteryChargingThresholds, /* Battery re-charging and re-discharing voltage when utility is available */ SetBatteryChargeThresholds, /* Battery re-charge and re-discharge voltage when utility is available */
SetChargingSourcePriority, SetChargeSourcePriority,
SetSolarPowerPriority, SetSolarPowerPriority,
SetACInputVoltageRange, SetACInputVoltageRange,
SetBatteryType, SetBatteryType,
SetOutputModel, SetOutputMode,
SetBatteryCutOffVoltage, SetBatteryCutOffVoltage,
SetSolarConfig, SetSolarConfig,
ClearGenerated, ClearGenerated,
SetDateTime, SetDateTime,
SetACChargingTimeBucket, SetACChargeTimeBucket,
SetACLoadsSupplyTimeBucket, SetACSupplyTimeBucket,
}; };
enum class BatteryType { enum class BatteryType {
@ -73,12 +73,12 @@ enum class OutputSourcePriority {
}; };
ENUM_STR(OutputSourcePriority); ENUM_STR(OutputSourcePriority);
enum class ChargerSourcePriority { enum class ChargeSourcePriority {
SolarFirst = 0, SolarFirst = 0,
SolarAndUtility = 1, SolarAndUtility = 1,
SolarOnly = 2, SolarOnly = 2,
}; };
ENUM_STR(ChargerSourcePriority); ENUM_STR(ChargeSourcePriority);
enum class MachineType { enum class MachineType {
OffGridTie = 0, OffGridTie = 0,
@ -92,14 +92,14 @@ enum class Topology {
}; };
ENUM_STR(Topology); ENUM_STR(Topology);
enum class OutputModelSetting { enum class OutputMode {
SingleModule = 0, SingleOutput = 0,
ParallelOutput = 1, ParallelOutput = 1,
Phase1OfThreePhaseOutput = 2, Phase_1_of_3 = 2,
Phase2OfThreePhaseOutput = 3, Phase_2_of_3 = 3,
Phase3OfThreePhaseOutput = 4, Phase_3_of_3 = 4,
}; };
ENUM_STR(OutputModelSetting); ENUM_STR(OutputMode);
enum class SolarPowerPriority { enum class SolarPowerPriority {
BatteryLoadUtility = 0, BatteryLoadUtility = 0,