1090 lines
40 KiB
C
1090 lines
40 KiB
C
/* nutdrv_qx_masterguard.c - Subdriver for Masterguard A/E Series
|
|
*
|
|
* Copyright (C)
|
|
* 2020-2021 Edgar Fuß <ef@math.uni-bonn.de>, Mathematisches Institut der Universität Bonn
|
|
*
|
|
* This program 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
|
|
* (at your option) any later version, or a 2-clause BSD License.
|
|
*
|
|
* This program 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.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
|
|
#include "main.h"
|
|
#include "nutdrv_qx.h"
|
|
|
|
#include "nutdrv_qx_masterguard.h"
|
|
#include <stddef.h>
|
|
|
|
#define MASTERGUARD_VERSION "Masterguard 0.02"
|
|
|
|
/* series (for un-SKIP) */
|
|
static char masterguard_my_series = '?';
|
|
/* slave address for commands that require it */
|
|
static char masterguard_my_slaveaddr[3] = "??"; /* null-terminated for strtol() in claim() */
|
|
/* next slaveaddr to use after the SS command (which needs the old one) has been run */
|
|
static long masterguard_next_slaveaddr;
|
|
/* output current/power computation */
|
|
static long masterguard_my_power = 0;
|
|
/* battery voltage computation */
|
|
static long masterguard_my_numcells = 0;
|
|
|
|
|
|
/* ranges */
|
|
|
|
static info_rw_t masterguard_r_slaveaddr[] = {
|
|
{ "0", NULL },
|
|
{ "99", NULL },
|
|
{ "" , NULL }
|
|
};
|
|
|
|
static info_rw_t masterguard_r_batpacks[] = {
|
|
{ "0", NULL }, /* actually 1 for most models, see masterguard_model() */
|
|
{ "9", NULL }, /* varies across models, see masterguard_model() */
|
|
{ "" , NULL }
|
|
};
|
|
|
|
static info_rw_t masterguard_r_offdelay[] = {
|
|
{ "0", NULL },
|
|
{ "5940", NULL }, /* 99*60 */
|
|
{ "" , NULL }
|
|
};
|
|
|
|
static info_rw_t masterguard_r_ondelay[] = {
|
|
{ "0", NULL },
|
|
{ "599940", NULL }, /* 9999*60 */
|
|
{ "" , NULL }
|
|
};
|
|
|
|
|
|
/* enums */
|
|
|
|
static info_rw_t *masterguard_e_outvolts = NULL; /* set in masterguard_output_voltages() */
|
|
|
|
|
|
/* preprocess functions */
|
|
|
|
/* set masterguard_my_slaveaddr (for masterguard_add_slaveaddr) */
|
|
static int masterguard_slaveaddr(item_t *item, char *value, const size_t valuelen) {
|
|
if (strlen(item->value) != 2) {
|
|
upsdebugx(2, "slaveaddr length not 2");
|
|
return -1;
|
|
}
|
|
memcpy(masterguard_my_slaveaddr, item->value, 2);
|
|
if (valuelen >= 3) memcpy(value, item->value, 3);
|
|
return 0;
|
|
}
|
|
|
|
/* set masterguard_my_series (for activating supported commands in masterguard_claim() */
|
|
static int masterguard_series(item_t *item, char *value, const size_t valuelen) {
|
|
NUT_UNUSED_VARIABLE(valuelen);
|
|
|
|
switch (item->value[0]) {
|
|
case 'A':
|
|
break;
|
|
case 'E':
|
|
break;
|
|
default:
|
|
upsdebugx(2, "unknown series %s", item->value);
|
|
return -1;
|
|
}
|
|
masterguard_my_series = item->value[0];
|
|
memcpy(value, item->value, 2);
|
|
return 0;
|
|
}
|
|
|
|
/* Convert strangely formatted model name in WH output
|
|
* (spaces, -19 only after battery packs) to something readable
|
|
* Also set min/max battery packs according to model */
|
|
static int masterguard_model(item_t *item, char *value, const size_t valuelen) {
|
|
char *model;
|
|
int rack;
|
|
char min_bp, max_bp;
|
|
|
|
rack = (strstr(item->value, "-19") != NULL);
|
|
if (strncmp(item->value, "A 700", 6) == 0) {
|
|
model = "A700";
|
|
min_bp = 0; max_bp = 0;
|
|
} else if (strncmp(item->value, "A 1000", 6) == 0) {
|
|
model = "A1000";
|
|
min_bp = 0; max_bp = 2;
|
|
} else if (strncmp(item->value, "A 2000", 6) == 0) {
|
|
model = "A2000";
|
|
min_bp = rack ? 1 : 0; max_bp = rack ? 5 : 2;
|
|
} else if (strncmp(item->value, "A 3000", 6) == 0) {
|
|
model = "A3000";
|
|
min_bp = rack ? 1 : 0; max_bp = rack ? 5 : 2;
|
|
} else if (strncmp(item->value, "E 60", 4) == 0) {
|
|
model = "E60";
|
|
min_bp = 1; max_bp = 1; /* ??? */
|
|
} else if (strncmp(item->value, "E100", 4) == 0) {
|
|
model = "E100";
|
|
min_bp = 1; max_bp = 1; /* ??? */
|
|
} else if (strncmp(item->value, "E200", 4) == 0) {
|
|
model = "E200";
|
|
min_bp = 1; max_bp = 1; /* ??? */
|
|
} else {
|
|
upsdebugx(2, "unknown T %s", item->value);
|
|
return -1;
|
|
}
|
|
masterguard_r_batpacks[0].value[0] = '0' + min_bp;
|
|
masterguard_r_batpacks[1].value[0] = '0' + max_bp;
|
|
snprintf(value, valuelen, "%s%s", model, rack ? "-19" : "");
|
|
return 0;
|
|
}
|
|
|
|
/* set masterguard_my_power (for power/current calculations) according to model */
|
|
static int masterguard_power(item_t *item, char *value, const size_t valuelen) {
|
|
int p;
|
|
|
|
if (strncmp(item->value, "A 700", 6) == 0) {
|
|
p = 700;
|
|
} else if (strncmp(item->value, "A 1000", 6) == 0) {
|
|
p = 1000;
|
|
} else if (strncmp(item->value, "A 2000", 6) == 0) {
|
|
p = 2000;
|
|
} else if (strncmp(item->value, "A 3000", 6) == 0) {
|
|
p = 3000;
|
|
} else if (strncmp(item->value, "E 60", 4) == 0) {
|
|
p = 6000;
|
|
} else if (strncmp(item->value, "E100", 4) == 0) {
|
|
p = 10000;
|
|
} else if (strncmp(item->value, "E200", 4) == 0) {
|
|
p = 20000;
|
|
} else {
|
|
upsdebugx(2, "unknown T %s", item->value);
|
|
return -1;
|
|
}
|
|
masterguard_my_power = p;
|
|
snprintf(value, valuelen, "%d", p);
|
|
return 0;
|
|
}
|
|
|
|
/* convert mmm.ss to seconds */
|
|
static int masterguard_mmm_ss(item_t *item, char *value, const size_t valuelen) {
|
|
int m, s;
|
|
|
|
if (sscanf(item->value, "%d.%d", &m, &s) != 2) {
|
|
upsdebugx(2, "unparsable mmm.ss %s", item->value);
|
|
return -1;
|
|
}
|
|
snprintf(value, valuelen, "%d", 60*m + s);
|
|
return 0;
|
|
}
|
|
|
|
/* convert hhh to seconds */
|
|
static int masterguard_hhh(item_t *item, char *value, const size_t valuelen) {
|
|
int h;
|
|
if (sscanf(item->value, "%d", &h) != 1) {
|
|
upsdebugx(2, "unparsable hhh %s", item->value);
|
|
return -1;
|
|
}
|
|
snprintf(value, valuelen, "%d", 60*60*h);
|
|
return 0;
|
|
}
|
|
|
|
/* convert TTTT:hh:mm:dd to seconds */
|
|
static int masterguard_tttt_hh_mm_ss(item_t *item, char *value, const size_t valuelen) {
|
|
int t, h, m, s;
|
|
|
|
if (sscanf(item->value, "%d:%d:%d:%d", &t, &h, &m, &s) != 4) {
|
|
upsdebugx(2, "unparsable TTTT:hh:mm:ss %s", item->value);
|
|
return -1;
|
|
}
|
|
snprintf(value, valuelen, "%d", 86400*t + 3600*h + 60*m + s);
|
|
return 0;
|
|
}
|
|
|
|
/* set masterguard_my_numcells (for nominal battery voltage computation) */
|
|
static int masterguard_numcells(item_t *item, char *value, const size_t valuelen) {
|
|
int v;
|
|
if (sscanf(item->value, "%d", &v) != 1) {
|
|
upsdebugx(2, "unparsable vvv %s", item->value);
|
|
return -1;
|
|
}
|
|
masterguard_my_numcells = v;
|
|
snprintf(value, valuelen, "%d", v);
|
|
return 0;
|
|
}
|
|
|
|
/* compute nominal battery voltage */
|
|
static int masterguard_battvolt(item_t *item, char *value, const size_t valuelen) {
|
|
float s;
|
|
if (sscanf(item->value, "%f", &s) != 1) {
|
|
upsdebugx(2, "unparsable ss.ss %s", item->value);
|
|
return -1;
|
|
}
|
|
snprintf(value, valuelen, "%.2f", masterguard_my_numcells * s);
|
|
return 0;
|
|
}
|
|
|
|
/* compute output power from load percentage */
|
|
static int masterguard_ups_power(item_t *item, char *value, const size_t valuelen) {
|
|
int q;
|
|
|
|
if (sscanf(item->value, "%d", &q) != 1) {
|
|
upsdebugx(2, "unparsable qqq %s", item->value);
|
|
return -1;
|
|
}
|
|
snprintf(value, valuelen, "%.0f", q / 100.0 * masterguard_my_power + 0.5);
|
|
return 0;
|
|
}
|
|
|
|
/* helper routine, not to be called from table */
|
|
static int masterguard_output_current_fraction(item_t *item, char *value, const size_t valuelen, double fraction) {
|
|
NUT_UNUSED_VARIABLE(item);
|
|
|
|
snprintf(value, valuelen, "%.2f",
|
|
fraction * masterguard_my_power / strtod(dstate_getinfo("output.voltage") , NULL) + 0.005);
|
|
return 0;
|
|
}
|
|
|
|
/* compute output current from load percentage and output voltage */
|
|
static int masterguard_output_current(item_t *item, char *value, const size_t valuelen) {
|
|
int q;
|
|
|
|
if (sscanf(item->value, "%d", &q) != 1) {
|
|
upsdebugx(2, "unparsable qqq %s", item->value);
|
|
return -1;
|
|
}
|
|
return masterguard_output_current_fraction(item, value, valuelen, q/100.0);
|
|
}
|
|
|
|
/* compute nominal output current from output voltage */
|
|
static int masterguard_output_current_nominal(item_t *item, char *value, const size_t valuelen) {
|
|
return masterguard_output_current_fraction(item, value, valuelen, 1.0);
|
|
}
|
|
|
|
/* digest status bits */
|
|
static int masterguard_status(item_t *item, char *value, const size_t valuelen) {
|
|
int neg;
|
|
char *s;
|
|
|
|
switch (item->value[0]) {
|
|
case '0': neg = 1; break;
|
|
case '1': neg = 0; break;
|
|
default:
|
|
upsdebugx(2, "unknown flag value %c", item->value[0]);
|
|
return -1;
|
|
}
|
|
switch (item->from) {
|
|
case 53: /* B7 */ s = "OL"; neg = !neg; break;
|
|
case 54: /* B6 */ s = "LB"; break;
|
|
case 55: /* B5 */ s = "BYPASS"; break;
|
|
case 56: /* B4 */ s = neg ? "" : "UPS Failed"; neg = 0; break;
|
|
case 57: /* B3 */ s = neg ? "online" : "offline"; neg = 0; break;
|
|
case 58: /* B2 */ s = "CAL"; break;
|
|
case 59: /* B1 */ s = "FSD"; break;
|
|
/* 60: blank */
|
|
/* 61: B0 reserved */
|
|
/* 62: T7 reserved */
|
|
case 63: /* T6 */ s = neg ? "" : "problems in parallel operation mode"; neg = 0; break;
|
|
/* 64: T5 part of a parallel set */
|
|
case 65: /* T4 */ s = "RB"; break;
|
|
case 66: /* T3 */ s = neg ? "" : "no battery connected"; neg = 0; break;
|
|
case 67: /* T210 */
|
|
neg = 0;
|
|
if (strncmp(item->value, "000", 3) == 0) {
|
|
s = "no test in progress";
|
|
} else if (strncmp(item->value, "001", 3) == 0) {
|
|
s = "in progress";
|
|
} else if (strncmp(item->value, "010", 3) == 0) {
|
|
s = "OK";
|
|
} else if (strncmp(item->value, "011", 3) == 0) {
|
|
s = "failed";
|
|
} else if (strncmp(item->value, "100", 3) == 0) {
|
|
s = "not possible";
|
|
} else if (strncmp(item->value, "101", 3) == 0) {
|
|
s = "aborted";
|
|
} else if (strncmp(item->value, "110", 3) == 0) {
|
|
s = "autonomy time calibration in progress";
|
|
} else if (strncmp(item->value, "111", 3) == 0) {
|
|
s = "unknown";
|
|
} else {
|
|
upsdebugx(2, "unknown test result %s", item->value);
|
|
return -1;
|
|
}
|
|
break;
|
|
default:
|
|
upsdebugx(2, "unknown flag position %d", item->from);
|
|
return -1;
|
|
}
|
|
snprintf(value, valuelen, "%s%s", neg ? "!" : "", s);
|
|
return 0;
|
|
}
|
|
|
|
/* convert beeper status bit to string required by NUT */
|
|
static int masterguard_beeper_status(item_t *item, char *value, const size_t valuelen) {
|
|
switch (item->value[0]) {
|
|
case '0':
|
|
if (valuelen >= 9)
|
|
strcpy(value, "disabled");
|
|
else
|
|
*value = '\0';
|
|
break;
|
|
case '1':
|
|
if (valuelen >= 8)
|
|
strcpy(value, "enabled");
|
|
else
|
|
*value = '\0';
|
|
break;
|
|
default:
|
|
upsdebugx(2, "unknown beeper status %c", item->value[0]);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* parse list of available (nominal) output voltages into masterguard_w_outvolts enum */
|
|
static int masterguard_output_voltages(item_t *item, char *value, const size_t valuelen) {
|
|
char sep[] = " ";
|
|
char *w;
|
|
size_t n = 0;
|
|
|
|
strncpy(value, item->value, valuelen); /* save before strtok mangles it */
|
|
for (w = strtok(item->value, sep); w; w = strtok(NULL, sep)) {
|
|
n++;
|
|
upsdebugx(4, "output voltage #%zu: %s", n, w);
|
|
if ((masterguard_e_outvolts = realloc(masterguard_e_outvolts, n * sizeof(info_rw_t))) == NULL) {
|
|
upsdebugx(1, "output voltages: allocating #%zu failed", n);
|
|
return -1;
|
|
}
|
|
strncpy(masterguard_e_outvolts[n - 1].value, w, SMALLBUF - 1);
|
|
masterguard_e_outvolts[n - 1].preprocess = NULL;
|
|
}
|
|
/* need to do this seperately in case the loop is run zero times */
|
|
if ((masterguard_e_outvolts = realloc(masterguard_e_outvolts, (n + 1) * sizeof(info_rw_t))) == NULL) {
|
|
upsdebugx(1, "output voltages: allocating terminator after #%zu failed", n);
|
|
return -1;
|
|
}
|
|
masterguard_e_outvolts[n].value[0] = '\0';
|
|
masterguard_e_outvolts[n].preprocess = NULL;
|
|
return 0;
|
|
}
|
|
|
|
/* parse fault record string into readable form */
|
|
static int masterguard_fault(item_t *item, char *value, const size_t valuelen) {
|
|
char c;
|
|
float f;
|
|
int t, h, m, s;
|
|
long l;
|
|
|
|
if (sscanf(item->value, "%c %f %d:%d:%d:%d", &c, &f, &t, &h, &m, &s) != 6) {
|
|
upsdebugx(1, "unparsable fault record %s", item->value);
|
|
return -1;
|
|
}
|
|
l = 86400*t + 3600*h + 60*m + s;
|
|
snprintf(value, valuelen, "%ld: ", l);
|
|
switch (c) {
|
|
case '0':
|
|
snprintfcat(value, valuelen, "none");
|
|
break;
|
|
case '1':
|
|
snprintfcat(value, valuelen, "bus fault (%.0fV)", f);
|
|
break;
|
|
case '2':
|
|
snprintfcat(value, valuelen, "inverter fault (%.0fV)", f);
|
|
break;
|
|
case '3':
|
|
snprintfcat(value, valuelen, "overheat fault (%.0fC)", f);
|
|
break;
|
|
case '4':
|
|
snprintfcat(value, valuelen, "battery overvoltage fault (%.2fV)", f);
|
|
break;
|
|
case '5':
|
|
snprintfcat(value, valuelen, "battery mode overload fault (%.0f%%)", f);
|
|
break;
|
|
case '6':
|
|
snprintfcat(value, valuelen, "bypass mode overload fault (%.0f%%)", f);
|
|
break;
|
|
case '7':
|
|
snprintfcat(value, valuelen, "inverter mode outpt short-circuit fault (%.0fV)", f);
|
|
break;
|
|
case '8':
|
|
snprintfcat(value, valuelen, "fan lock fault");
|
|
break;
|
|
case '9':
|
|
snprintfcat(value, valuelen, "battery fault (%.0fV)", f);
|
|
break;
|
|
case 'A':
|
|
snprintfcat(value, valuelen, "charger fault");
|
|
break;
|
|
case 'B':
|
|
snprintfcat(value, valuelen, "EPO activated");
|
|
break;
|
|
case 'C':
|
|
snprintfcat(value, valuelen, "parallel error");
|
|
break;
|
|
case 'D':
|
|
snprintfcat(value, valuelen, "MCU communication error");
|
|
break;
|
|
case 'E':
|
|
case 'F':
|
|
upsdebugx(1, "reserved fault id %c", c);
|
|
return -1;
|
|
default:
|
|
upsdebugx(1, "unknown fault id %c", c);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* pre-command preprocessing functions */
|
|
|
|
/* add slave address (from masterguard_my_slaveaddr) to commands that require it */
|
|
static int masterguard_add_slaveaddr(item_t *item, char *command, const size_t commandlen) {
|
|
NUT_UNUSED_VARIABLE(item);
|
|
NUT_UNUSED_VARIABLE(commandlen);
|
|
|
|
size_t l;
|
|
|
|
l = strlen(command);
|
|
if (strncmp(command + l - 4, ",XX\r", 4) != 0) {
|
|
upsdebugx(1, "add slaveaddr: no ,XX\\r at end of command %s", command);
|
|
return -1;
|
|
}
|
|
upsdebugx(4, "add slaveaddr %s to command %s", masterguard_my_slaveaddr, command);
|
|
memcpy(command + l - 3, masterguard_my_slaveaddr, 2);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* instant command preprocessing functions */
|
|
|
|
/* helper, not to be called directly from table */
|
|
/*!! use parameter from the value field instead of ups.delay.{shutdown,return}?? */
|
|
static int masterguard_shutdown(item_t *item, char *value, const size_t valuelen, const int stayoff) {
|
|
NUT_UNUSED_VARIABLE(item);
|
|
|
|
long offdelay;
|
|
char *p;
|
|
const char *val, *name;
|
|
char offstr[3];
|
|
|
|
offdelay = strtol((val = dstate_getinfo(name = "ups.delay.shutdown")), &p, 10);
|
|
if (*p != '\0') goto ill;
|
|
if (offdelay < 0) {
|
|
goto ill;
|
|
} else if (offdelay < 60) {
|
|
offstr[0] = '.';
|
|
offstr[1] = '0' + (char)offdelay / 6;
|
|
} else if (offdelay <= 99*60) {
|
|
int m = (int)(offdelay / 60);
|
|
offstr[0] = '0' + (char)(m / 10);
|
|
offstr[1] = '0' + (char)(m % 10);
|
|
} else goto ill;
|
|
offstr[2] = '\0';
|
|
if (stayoff) {
|
|
snprintf(value, valuelen, "S%s\r", offstr);
|
|
} else {
|
|
long ondelay;
|
|
|
|
ondelay = strtol((val = dstate_getinfo(name = "ups.delay.start")), &p, 10);
|
|
if (*p != '\0') goto ill;
|
|
if (ondelay < 0 || ondelay > 9999*60) goto ill;
|
|
snprintf(value, valuelen, "S%sR%04ld\r", offstr, ondelay);
|
|
}
|
|
return 0;
|
|
|
|
ill:
|
|
upsdebugx(2, "shutdown: illegal %s %s", name, val);
|
|
return -1;
|
|
}
|
|
|
|
static int masterguard_shutdown_return(item_t *item, char *value, const size_t valuelen) {
|
|
return masterguard_shutdown(item, value, valuelen, 0);
|
|
}
|
|
|
|
static int masterguard_shutdown_stayoff(item_t *item, char *value, const size_t valuelen) {
|
|
return masterguard_shutdown(item, value, valuelen, 1);
|
|
}
|
|
|
|
static int masterguard_test_battery(item_t *item, char *value, const size_t valuelen) {
|
|
NUT_UNUSED_VARIABLE(item);
|
|
|
|
long duration;
|
|
char *p;
|
|
|
|
if (value[0] == '\0') {
|
|
upsdebugx(2, "battery test: no duration");
|
|
return -1;
|
|
}
|
|
duration = strtol(value, &p, 10);
|
|
if (*p != '\0') goto ill;
|
|
if (duration == 10) {
|
|
strncpy(value, "T\r", valuelen);
|
|
return 0;
|
|
}
|
|
if (duration < 60 || duration > 99*60) goto ill;
|
|
snprintf(value, valuelen, "T%02ld\r", duration / 60);
|
|
return 0;
|
|
|
|
ill: upsdebugx(2, "battery test: illegal duration %s", value);
|
|
return -1;
|
|
}
|
|
|
|
|
|
/* variable setting preprocessing functions */
|
|
|
|
/* set variable, input format specifier (d/f/s, thms) in item->dfl */
|
|
static int masterguard_setvar(item_t *item, char *value, const size_t valuelen) {
|
|
char *p;
|
|
char t = 's';
|
|
long i = 0;
|
|
double f = 0.0;
|
|
char s[80];
|
|
|
|
if (value[0] == '\0') {
|
|
upsdebugx(2, "setvar: no value");
|
|
return -1;
|
|
}
|
|
if (!item->dfl || item->dfl[0] == '\0') {
|
|
upsdebugx(2, "setvar: no dfl");
|
|
return -1;
|
|
}
|
|
if (item->dfl[1] == '\0') {
|
|
t = item->dfl[0];
|
|
switch (t) {
|
|
case 'd':
|
|
i = strtol(value, &p, 10);
|
|
if (*p != '\0') goto ill;
|
|
break;
|
|
case 'f':
|
|
f = strtod(value, &p);
|
|
if (*p != '\0') {
|
|
goto ill;
|
|
} else if (errno) {
|
|
upsdebug_with_errno(2, "setvar: f value %s", value);
|
|
return -1;
|
|
}
|
|
break;
|
|
case 's':
|
|
/* copy to s to avoid snprintf()ing value to itself */
|
|
if (strlen(value) >= sizeof s) goto ill;
|
|
strcpy(s, value);
|
|
break;
|
|
default:
|
|
upsdebugx(2, "setvar: unknown dfl %c", item->dfl[0]);
|
|
return -1;
|
|
}
|
|
} else if (strncmp(item->dfl, "thms", 4) == 0) {
|
|
int tt, h, m, sec;
|
|
if (sscanf(item->value, "%d:%d:%d:%d", &tt, &h, &m, &sec) == 4) {
|
|
if (tt < 0 || tt > 9999 || h < 0 || h > 23 || m < 0 || m > 59 || sec < 0 || sec > 59) goto ill;
|
|
} else {
|
|
long l;
|
|
char *pl;
|
|
|
|
l = strtol(value, &pl, 10);
|
|
if (*pl != '\0') goto ill;
|
|
sec = l % 60; l /= 60;
|
|
m = l % 60; l /= 60;
|
|
h = l % 24; l /= 24;
|
|
if (l > 9999) goto ill;
|
|
tt = (int)l;
|
|
}
|
|
snprintf(s, sizeof s, "%04d:%02d:%02d:%02d", tt, h, m, sec);
|
|
} else {
|
|
upsdebugx(2, "setvar: unknown dfl %s", item->dfl);
|
|
return -1;
|
|
}
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic push
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
|
#endif
|
|
#ifdef HAVE_PRAGMA_GCC_DIAGNOSTIC_IGNORED_FORMAT_SECURITY
|
|
#pragma GCC diagnostic ignored "-Wformat-security"
|
|
#endif
|
|
switch (t) {
|
|
case 'd':
|
|
snprintf(value, valuelen, item->command, i);
|
|
break;
|
|
case 'f':
|
|
snprintf(value, valuelen, item->command, f);
|
|
break;
|
|
case 's':
|
|
snprintf(value, valuelen, item->command, s);
|
|
break;
|
|
}
|
|
#ifdef HAVE_PRAGMAS_FOR_GCC_DIAGNOSTIC_IGNORED_FORMAT_NONLITERAL
|
|
#pragma GCC diagnostic pop
|
|
#endif
|
|
return 0;
|
|
ill:
|
|
upsdebugx(2, "setvar: illegal %s value %s", item->dfl, value);
|
|
return -1;
|
|
}
|
|
|
|
/* record new slave address in masterguard_next_slaveaddr; moved to masterguard_my_slaveaddr in masterguard_new_slaveaddr() after the slaveaddr-changing command finished */
|
|
static int masterguard_set_slaveaddr(item_t *item, char *value, const size_t valuelen) {
|
|
char *p;
|
|
|
|
masterguard_next_slaveaddr = strtol(value, &p, 10);
|
|
if (*p != '\0') {
|
|
upsdebugx(2, "set_slaveaddr: illegal value %s", value);
|
|
return -1;
|
|
}
|
|
upsdebugx(3, "next slaveaddr %ld", masterguard_next_slaveaddr);
|
|
return masterguard_setvar(item, value, valuelen);
|
|
}
|
|
|
|
|
|
/* variable setting answer preprocessing functions */
|
|
|
|
/* set my_slaveaddr to next_slaveaddr /after/ issuing the SS command (which, itself, needs the /old/ slaveaddr) */
|
|
static int masterguard_new_slaveaddr(item_t *item, const int len) {
|
|
NUT_UNUSED_VARIABLE(item);
|
|
|
|
upsdebugx(3, "saved slaveaddr %ld", masterguard_next_slaveaddr);
|
|
if (masterguard_next_slaveaddr < 0 || masterguard_next_slaveaddr > 99) {
|
|
upsdebugx(2, "%s: illegal value %ld", __func__, masterguard_next_slaveaddr);
|
|
return -1;
|
|
}
|
|
masterguard_my_slaveaddr[0] = '0' + (char)(masterguard_next_slaveaddr / 10);
|
|
masterguard_my_slaveaddr[1] = '0' + (char)(masterguard_next_slaveaddr % 10);
|
|
upsdebugx(3, "new slaveaddr %s", masterguard_my_slaveaddr);
|
|
return len;
|
|
}
|
|
|
|
|
|
/* qx2nut lookup table */
|
|
static item_t masterguard_qx2nut[] = {
|
|
/* static values */
|
|
|
|
/* type flags rw command answer len leading value from to dfl qxflags precmd preans preproc */
|
|
{ "device.mfr", 0, NULL, "", "", 0, '\0', "", 0, 0, "Masterguard", QX_FLAG_STATIC | QX_FLAG_ABSENT,NULL, NULL, NULL },
|
|
{ "load.high", 0, NULL, "", "", 0, '\0', "", 0, 0, "140", QX_FLAG_STATIC | QX_FLAG_ABSENT,NULL, NULL, NULL },
|
|
/* battery.charge.low */
|
|
/* battery.charge.warning */
|
|
{ "battery.type", 0, NULL, "", "", 0, '\0', "", 0, 0, "PbAc", QX_FLAG_STATIC | QX_FLAG_ABSENT,NULL, NULL, NULL },
|
|
|
|
|
|
/* variables */
|
|
|
|
/*
|
|
* > [WH\r]
|
|
* < [(XX VV.VV PP.PP TTTTTTTTTTTTTTTTTTTTTTTTTTTTTT B MMM FF.FF VVV SS.SS HHH.hh GGG.gg RRR mm nn MMM NNN FF.FF FF.FF\r]
|
|
* 01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012
|
|
* 0 1 2 3 4 5 6 7 8 9 0 1
|
|
* (00 10.06 03.09 A 700 + 0 Bat Pack-19 0 230 50.00 012 02.30 006.00 012.00 018 10 40 160 276 47.00 53.00
|
|
*/
|
|
/* type flags rw command answer len leading value from to dfl qxflags precmd preans preproc */
|
|
{ "ups.id", ST_FLAG_RW, masterguard_r_slaveaddr,"WH\r", "", 113, '(', "", 1, 2, "%.0f", QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE, NULL, NULL, masterguard_slaveaddr },
|
|
{ "ups.firmware", 0, NULL, "WH\r", "", 113, '(', "", 4, 8, "%s", QX_FLAG_STATIC, NULL, NULL, NULL },
|
|
{ "ups.firmware.aux", 0, NULL, "WH\r", "", 113, '(', "", 10, 14, "%s", QX_FLAG_STATIC, NULL, NULL, NULL },
|
|
/* several values are deduced from the T field */
|
|
{ "experimental.series", 0, NULL, "WH\r", "", 113, '(', "", 16, 16, "%s", QX_FLAG_STATIC | QX_FLAG_NONUT, NULL, NULL, masterguard_series },
|
|
{ "device.model", 0, NULL, "WH\r", "", 113, '(', "", 16, 45, "%s", QX_FLAG_STATIC, NULL, NULL, masterguard_model },
|
|
{ "ups.power.nominal", 0, NULL, "WH\r", "", 113, '(', "", 16, 45, "%s", QX_FLAG_STATIC, NULL, NULL, masterguard_power },
|
|
/* not used, use GS instead because the value is settable
|
|
{ "battery.packs", 0, NULL, "WH\r", "", 113, '(', "", 47, 47, "%.0f", QX_FLAG_STATIC, NULL, NULL, NULL },
|
|
*/
|
|
{ "input.voltage.nominal", 0, NULL, "WH\r", "", 113, '(', "", 49, 51, "%.0f", QX_FLAG_STATIC, NULL, NULL, NULL },
|
|
{ "input.frequency.nominal", 0, NULL, "WH\r", "", 113, '(', "", 53, 57, "%.2f", QX_FLAG_STATIC, NULL, NULL, NULL },
|
|
{ "experimental.number_of_battery_cells", 0, NULL, "WH\r", "", 113, '(', "", 59, 61, "%.0f", QX_FLAG_STATIC | QX_FLAG_NONUT, NULL, NULL, masterguard_numcells },
|
|
{ "experimental.nominal_cell_voltage", 0, NULL, "WH\r", "", 113, '(', "", 63, 67, "%.2f", QX_FLAG_STATIC | QX_FLAG_NONUT, NULL, NULL, NULL },
|
|
{ "battery.voltage.nominal", 0, NULL, "WH\r", "", 113, '(', "", 63, 67, "%.2f", QX_FLAG_STATIC, NULL, NULL, masterguard_battvolt},
|
|
{ "experimental.runtime_half", 0, NULL, "WH\r", "", 113, '(', "", 69, 74, "%.0f", QX_FLAG_STATIC | QX_FLAG_NONUT, NULL, NULL, masterguard_mmm_ss },
|
|
{ "experimental.runtime_full", 0, NULL, "WH\r", "", 113, '(', "", 76, 81, "%.0f", QX_FLAG_STATIC | QX_FLAG_NONUT, NULL, NULL, masterguard_mmm_ss },
|
|
{ "experimental.recharge_time", 0, NULL, "WH\r", "", 113, '(', "", 83, 85, "%.0f", QX_FLAG_STATIC | QX_FLAG_NONUT, NULL, NULL, masterguard_hhh },
|
|
/*!! what's the difference between low/high and low.critical/high.critical?? */
|
|
{ "ambient.0.temperature.low", 0, NULL, "WH\r", "", 113, '(', "", 87, 88, "%.0f", QX_FLAG_STATIC, NULL, NULL, NULL },
|
|
{ "ambient.0.temperature.high", 0, NULL, "WH\r", "", 113, '(', "", 90, 91, "%.0f", QX_FLAG_STATIC, NULL, NULL, NULL },
|
|
{ "input.voltage.low.critical", 0, NULL, "WH\r", "", 113, '(', "", 93, 95, "%.0f", QX_FLAG_STATIC, NULL, NULL, NULL },
|
|
{ "input.voltage.high.critical",0, NULL, "WH\r", "", 113, '(', "", 97, 99, "%.0f", QX_FLAG_STATIC, NULL, NULL, NULL },
|
|
{ "input.frequency.low", 0, NULL, "WH\r", "", 113, '(', "", 101, 105, "%.2f", QX_FLAG_STATIC, NULL, NULL, NULL },
|
|
{ "input.frequency.high", 0, NULL, "WH\r", "", 113, '(', "", 107, 111, "%.2f", QX_FLAG_STATIC, NULL, NULL, NULL },
|
|
|
|
/*
|
|
* > [Q3\r]
|
|
* 76543210 76543210
|
|
* < [(XX MMM.M NNN.N PPP.P QQQ RR.R SS.SS TT.T ttt.tt CCC BBBBBBBB TTTTTTTT\r]
|
|
* 01234567890123456789012345678901234567890123456789012345678901234567890
|
|
* 0 1 2 3 4 5 6 7
|
|
* (00 225.9 225.9 229.3 043 50.0 02.27 23.4 017.03 100 00000000 00000000
|
|
* (01 226.9 226.9 226.9 039 50.0 02.30 21.8 000.00 000 01100000 00011000
|
|
*/
|
|
/* type flags rw command answer len leading value from to dfl qxflags precmd preans preproc */
|
|
{ "input.voltage", 0, NULL, "Q3\r", "", 71, '(', "", 4, 8, "%.1f", 0, NULL, NULL, NULL },
|
|
{ "experimental.input_fault_voltage", 0, NULL, "Q3\r", "", 71, '(', "", 10, 14, "%.1f", QX_FLAG_NONUT, NULL, NULL, NULL },
|
|
{ "output.voltage", 0, NULL, "Q3\r", "", 71, '(', "", 16, 20, "%.1f", 0, NULL, NULL, NULL },
|
|
{ "ups.load", 0, NULL, "Q3\r", "", 71, '(', "", 22, 24, "%.0f", 0, NULL, NULL, NULL },
|
|
{ "ups.power", 0, NULL, "Q3\r", "", 71, '(', "", 22, 24, "%.0f", 0, NULL, NULL, masterguard_ups_power },
|
|
{ "output.current", 0, NULL, "Q3\r", "", 71, '(', "", 22, 24, "%f", 0, NULL, NULL, masterguard_output_current },
|
|
{ "input.frequency", 0, NULL, "Q3\r", "", 71, '(', "", 26, 29, "%.1f", 0, NULL, NULL, NULL },
|
|
{ "battery.voltage", 0, NULL, "Q3\r", "", 71, '(', "", 31, 35, "%.1f", 0, NULL, NULL, masterguard_battvolt },
|
|
{ "ups.temperature", 0, NULL, "Q3\r", "", 71, '(', "", 37, 40, "%.1f", 0, NULL, NULL, NULL },
|
|
/*!! report both ups.temperature and ambient.0.temperature?? */
|
|
{ "ambient.0.temperature", 0, NULL, "Q3\r", "", 71, '(', "", 37, 40, "%.1f", 0, NULL, NULL, NULL },
|
|
{ "battery.runtime", 0, NULL, "Q3\r", "", 71, '(', "", 42, 47, "%.0f", 0, NULL, NULL, masterguard_mmm_ss },
|
|
{ "battery.charge", 0, NULL, "Q3\r", "", 71, '(', "", 49, 51, "%.0f", 0, NULL, NULL, NULL },
|
|
/* Status bits, first half (B) */
|
|
{ "ups.status", 0, NULL, "Q3\r", "", 71, '(', "", 53, 53, NULL, QX_FLAG_QUICK_POLL, NULL, NULL, masterguard_status }, /* B7: Utility Fail */
|
|
{ "ups.status", 0, NULL, "Q3\r", "", 71, '(', "", 54, 54, NULL, QX_FLAG_QUICK_POLL, NULL, NULL, masterguard_status }, /* B6: Battery Low */
|
|
{ "ups.status", 0, NULL, "Q3\r", "", 71, '(', "", 55, 55, NULL, QX_FLAG_QUICK_POLL, NULL, NULL, masterguard_status }, /* B5: Bypass/Boost Active */
|
|
{ "ups.alarm", 0, NULL, "Q3\r", "", 71, '(', "", 56, 56, NULL, QX_FLAG_QUICK_POLL, NULL, NULL, masterguard_status }, /* B4: UPS Failed */
|
|
{ "ups.type", 0, NULL, "Q3\r", "", 71, '(', "", 57, 57, NULL, QX_FLAG_STATIC, NULL, NULL, masterguard_status }, /* B3: UPS Type */
|
|
{ "ups.status", 0, NULL, "Q3\r", "", 71, '(', "", 58, 58, NULL, QX_FLAG_QUICK_POLL, NULL, NULL, masterguard_status }, /* B2: Test in Progress */
|
|
{ "ups.status", 0, NULL, "Q3\r", "", 71, '(', "", 59, 59, NULL, QX_FLAG_QUICK_POLL, NULL, NULL, masterguard_status }, /* B1: Shutdown Active */
|
|
/* unused */ /* B0: unused */
|
|
/* Status bits, second half (T) */
|
|
/* unused */ /* T7: unused */
|
|
{ "ups.alarm", 0, NULL, "Q3\r", "", 69, '(', "", 63, 63, NULL, QX_FLAG_QUICK_POLL, NULL, NULL, masterguard_status }, /* T6: problems in parallel operation mode */
|
|
/* part of a parallel set */ /* T5: is part of a parallel set */
|
|
{ "ups.status", 0, NULL, "Q3\r", "", 71, '(', "", 65, 65, NULL, QX_FLAG_QUICK_POLL, NULL, NULL, masterguard_status }, /* T4: Battery: end of service life */
|
|
{ "ups.alarm", 0, NULL, "Q3\r", "", 71, '(', "", 66, 66, NULL, QX_FLAG_QUICK_POLL, NULL, NULL, masterguard_status }, /* T3: battery connected */
|
|
{ "ups.test.result", 0, NULL, "Q3\r", "", 71, '(', "", 67, 69, NULL, QX_FLAG_QUICK_POLL, NULL, NULL, masterguard_status }, /* T210: Test Status */
|
|
|
|
/*
|
|
* > [GS,XX\r]
|
|
* < [(XX,ii p a\r]
|
|
* 01234567890
|
|
* 0 1
|
|
* (00,00 0 1
|
|
*/
|
|
/* type flags rw command answer len leading value from to dfl qxflags precmd preans preproc */
|
|
/* ups.id obtained via WH */
|
|
{ "ups.id", 0, NULL, "SS%02d--,XX\r","", 0, '\0', "", 0, 0, "d", QX_FLAG_SETVAR | QX_FLAG_RANGE, masterguard_add_slaveaddr, masterguard_new_slaveaddr, masterguard_set_slaveaddr },
|
|
{ "battery.packs", ST_FLAG_RW, masterguard_r_batpacks, "GS,XX\r", "", 0, '(', "", 7, 7, "%.0f", QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE, masterguard_add_slaveaddr, NULL, NULL },
|
|
{ "battery.packs", 0, NULL, "SS--%1d-,XX\r","", 0, '\0', "", 0, 0, "d", QX_FLAG_SETVAR | QX_FLAG_RANGE, masterguard_add_slaveaddr, NULL, masterguard_setvar },
|
|
/*!! which QX_FLAGs to use?? (changed by instcmd) */
|
|
{ "ups.beeper.status", 0, NULL, "GS,XX\r", "", 11, '(', "", 9, 9, NULL, QX_FLAG_SEMI_STATIC, masterguard_add_slaveaddr, NULL, masterguard_beeper_status },
|
|
/* set with beeper.{en,dis}able */
|
|
|
|
/*
|
|
* > [GBS,XX\r]
|
|
* < [(XX,CCC hhhh HHHH AAAA BBBB DDDD EEE SS.SS\r]
|
|
* 0123456789012345678901234567890123456789012
|
|
* 0 1 2 3 4
|
|
* (00,100 0017 0000 0708 0712 0994 115 02.28
|
|
* (01,000 0000 0360 0708 0712 0994 076 02.30
|
|
*/
|
|
/* type flags rw command answer len leading value from to dfl qxflags precmd preans preproc */
|
|
{ "battery.charge", 0, NULL, "GBS,XX\r", "", 43, '(', "", 4, 6, "%.0f", 0, masterguard_add_slaveaddr, NULL, NULL },
|
|
/*
|
|
* hhhh: hold time (minutes)
|
|
* HHHH: recharge time to 90% (minutes)
|
|
* AAAA: Ageing factor (promilles)
|
|
* BBBB: Ageing factor time dependant (promilles)
|
|
* DDDD: Ageing factor cyclic use (promilles)
|
|
* EEE: Calibration factor (percent)
|
|
* SS.SS: Actual battery cell voltage
|
|
*/
|
|
|
|
/*
|
|
* > [GSN,XX\r]
|
|
* < [(XX,SSN=SSSSSSSSSSSnnnnn\r]
|
|
* 0123456789012345678901234
|
|
* 0 1 2
|
|
* (00,SSN=6A1212 2782
|
|
*/
|
|
/* type flags rw command answer len leading value from to dfl qxflags precmd preans preproc */
|
|
{ "device.part", 0, NULL, "GSN,XX\r", "", 25, '(', "", 8, 18, "%s", QX_FLAG_STATIC | QX_FLAG_TRIM, masterguard_add_slaveaddr, NULL, NULL },
|
|
{ "device.serial", 0, NULL, "GSN,XX\r", "", 25, '(', "", 20, 23, "%s", QX_FLAG_STATIC, masterguard_add_slaveaddr, NULL, NULL },
|
|
|
|
/*
|
|
* > [DRC,XX\r]
|
|
* < [(XX,TTTT:hh:mm:ss\r]
|
|
* 012345678901234567
|
|
* 0 1
|
|
* (00,1869:19:06:37
|
|
*/
|
|
/* type flags rw command answer len leading value from to dfl qxflags precmd preans preproc */
|
|
/* this is not really the uptime, but the running time since last maintenance */
|
|
{ "device.uptime", ST_FLAG_RW, NULL, "DRC,XX\r", "", 17, '(', "", 4, 16, "%.0f", QX_FLAG_SEMI_STATIC, masterguard_add_slaveaddr, NULL, masterguard_tttt_hh_mm_ss },
|
|
{ "device.uptime", 0, NULL, "SRC%s,XX\r", "", 0, '\0', "", 0, 0, "thms", QX_FLAG_SETVAR, masterguard_add_slaveaddr, NULL, masterguard_setvar },
|
|
|
|
/*
|
|
* > [MSO\r]
|
|
* < [(220 230 240\r]
|
|
* 0123456789012
|
|
* 0 1
|
|
* (220 230 240
|
|
*/
|
|
/* type flags rw command answer len leading value from to dfl qxflags precmd preans preproc */
|
|
{ "experimental.output_voltages", 0, NULL, "MSO\r", "", 5, '(', "", 1, 0, "%s", QX_FLAG_STATIC | QX_FLAG_NONUT, NULL, NULL, masterguard_output_voltages },
|
|
|
|
/*
|
|
* > [PNV\r]
|
|
* < [(PNV=nnn\r]
|
|
* 012345678
|
|
* 0
|
|
* (PNV=230
|
|
*/
|
|
/* type flags rw command answer len leading value from to dfl qxflags precmd preans preproc */
|
|
{ "output.voltage.nominal", ST_FLAG_RW, NULL /* see claim */, "PNV\r", "", 8, '(', "", 5, 7, "%.0f", QX_FLAG_SEMI_STATIC | QX_FLAG_ENUM, NULL, NULL, NULL },
|
|
{ "output.voltage.nominal", 0, NULL, "PNV=%03d\r", "", 0, '\0', "", 0, 0, "d", QX_FLAG_SETVAR, NULL, NULL, masterguard_setvar },
|
|
{ "output.current.nominal", 0, NULL, "PNV\r", "", 8, '(', "", 5, 7, "%.0f", QX_FLAG_SEMI_STATIC, NULL, NULL, masterguard_output_current_nominal },
|
|
|
|
/*
|
|
* > [FLT,XX\r]
|
|
* < [(XX,A aaaa TTTT:hh:mm:ss B bbbb TTTT:hh:mm:ss C cccc TTTT:hh:mm:ss D dddd TTTT:hh:mm:ss E eeee TTTT:hh:mm:ss\r
|
|
* 0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678
|
|
* 0 1 2 3 4 5 6 7 8 9 0
|
|
* (00,7 0043 0000:16:48:06 0 0000 0000:00:00:00 0 0000 0000:00:00:00 0 0000 0000:00:00:00 0 0000 0000:00:00:00
|
|
* (01,9 0010 1780:14:57:19 7 0046 0000:21:14:41 0 0000 0000:00:00:00 0 0000 0000:00:00:00 0 0000 0000:00:00:00
|
|
*/
|
|
/* type flags rw command answer len leading value from to dfl qxflags precmd preans preproc */
|
|
{ "experimental.fault_1", 0, NULL, "FLT,XX\r", "", 108, '(', "", 4, 23, "%s", QX_FLAG_NONUT, masterguard_add_slaveaddr, NULL, masterguard_fault },
|
|
{ "experimental.fault_2", 0, NULL, "FLT,XX\r", "", 108, '(', "", 25, 44, "%s", QX_FLAG_NONUT, masterguard_add_slaveaddr, NULL, masterguard_fault },
|
|
{ "experimental.fault_3", 0, NULL, "FLT,XX\r", "", 108, '(', "", 46, 65, "%s", QX_FLAG_NONUT, masterguard_add_slaveaddr, NULL, masterguard_fault },
|
|
{ "experimental.fault_4", 0, NULL, "FLT,XX\r", "", 108, '(', "", 67, 86, "%s", QX_FLAG_NONUT, masterguard_add_slaveaddr, NULL, masterguard_fault },
|
|
{ "experimental.fault_5", 0, NULL, "FLT,XX\r", "", 108, '(', "", 88, 107, "%s", QX_FLAG_NONUT, masterguard_add_slaveaddr, NULL, masterguard_fault },
|
|
|
|
|
|
/* instant commands */
|
|
/* type flags rw command answer len leading value from to dfl qxflags precmd preans preproc */
|
|
/*!! what's the difference between load.off.delay and shutdown.stayoff?? */
|
|
#if 0
|
|
{ "load.off", 0, NULL, "S.0\r", "", 0, '\0', "", 0, 0, NULL, QX_FLAG_CMD, NULL, NULL, NULL },
|
|
{ "load.on", 0, NULL, "C\r", "", 0, '\0', "", 0, 0, NULL, QX_FLAG_CMD, NULL, NULL, NULL },
|
|
/* load.off.delay */
|
|
/* load.on.delay */
|
|
#endif
|
|
{ "shutdown.return", 0, NULL, NULL, "", 0, '\0', "", 0, 0, NULL, QX_FLAG_CMD, NULL, NULL, masterguard_shutdown_return },
|
|
{ "shutdown.stayoff", 0, NULL, NULL, "", 0, '\0', "", 0, 0, NULL, QX_FLAG_CMD, NULL, NULL, masterguard_shutdown_stayoff },
|
|
{ "shutdown.stop", 0, NULL, "C\r", "", 0, '\0', "", 0, 0, NULL, QX_FLAG_CMD, NULL, NULL, NULL },
|
|
/* shutdown.reboot */
|
|
/* shutdown.reboot.graceful */
|
|
/* test.panel.start */
|
|
/* test.panel.stop */
|
|
/* test.failure.start */
|
|
/* test.failure.stop */
|
|
{ "test.battery.start", 0, NULL, NULL, "", 0, '\0', "", 0, 0, NULL, QX_FLAG_CMD, NULL, NULL, masterguard_test_battery },
|
|
{ "test.battery.start.quick", 0, NULL, "T\r", "", 0, '\0', "", 0, 0, NULL, QX_FLAG_CMD, NULL, NULL, NULL },
|
|
{ "test.battery.start.deep", 0, NULL, "TUD\r", "", 0, '\0', "", 0, 0, NULL, QX_FLAG_CMD, NULL, NULL, NULL },
|
|
{ "test.battery.stop", 0, NULL, "CT\r", "", 0, '\0', "", 0, 0, NULL, QX_FLAG_CMD, NULL, NULL, NULL },
|
|
/* test.system.start */
|
|
/* calibrate.start */
|
|
/* calibrate.stop */
|
|
{ "bypass.start", 0, NULL, "FOFF\r", "", 0, '\0', "", 0, 0, NULL, QX_FLAG_CMD, NULL, NULL, NULL },
|
|
{ "bypass.stop", 0, NULL, "FON\r", "", 0, '\0', "", 0, 0, NULL, QX_FLAG_CMD, NULL, NULL, NULL },
|
|
/* reset.input.minmax */
|
|
/* reset.watchdog */
|
|
{ "beeper.enable", 0, NULL, "SS---1,XX\r", "", 0, '\0', "", 0, 0, NULL, QX_FLAG_CMD, masterguard_add_slaveaddr, NULL, NULL },
|
|
{ "beeper.disable", 0, NULL, "SS---0,XX\r", "", 0, '\0', "", 0, 0, NULL, QX_FLAG_CMD, masterguard_add_slaveaddr, NULL, NULL },
|
|
/* beeper.mute */
|
|
/* beeper.toggle */
|
|
/* outlet.* */
|
|
|
|
|
|
/* server variables */
|
|
/* type flags rw command answer len leading value from to dfl qxflags precmd preans preproc */
|
|
{ "ups.delay.shutdown", ST_FLAG_RW, masterguard_r_offdelay, NULL, "", 0, '\0', "", 0, 0, DEFAULT_OFFDELAY, QX_FLAG_ABSENT | QX_FLAG_SETVAR | QX_FLAG_RANGE, NULL, NULL, NULL },
|
|
{ "ups.delay.start", ST_FLAG_RW, masterguard_r_ondelay, NULL, "", 0, '\0', "", 0, 0, DEFAULT_ONDELAY, QX_FLAG_ABSENT | QX_FLAG_SETVAR | QX_FLAG_RANGE, NULL, NULL, NULL },
|
|
|
|
|
|
/* end marker */
|
|
{ NULL, 0, NULL, NULL, "", 0, 0, "", 0, 0, NULL, 0, NULL, NULL, NULL }
|
|
};
|
|
|
|
|
|
/*!! todo
|
|
|
|
untested:
|
|
Sxx (.n/nn)
|
|
C after S.0
|
|
|
|
unused:
|
|
>G01,00
|
|
(00,00000
|
|
|
|
additional E series commands:
|
|
PSR
|
|
BUS*
|
|
V
|
|
INVDC
|
|
|
|
use ups.{delay,timer}.{start,reboot,shutdown}?
|
|
report ups.contacts?
|
|
how to report battery.charger.status?
|
|
set battery.packs.bad?
|
|
|
|
how to report battery aeging/run time?
|
|
how to report nominal hold time at half/full load?
|
|
|
|
*/
|
|
|
|
|
|
/* commands supported by A series */
|
|
static char *masterguard_commands_a[] = {
|
|
"Q", "Q1", "Q3", "T", "TL", "S", "C", "CT", "WH", "M", "N", "O", "DECO", "DRC", "SRC", "FLT", "FCLR", "G", "SS", "GS", "MSO", "PNV", "FOFF", "FON", "TUD", "GBS", "SSN", "GSN", NULL
|
|
};
|
|
|
|
/* commands supported by E series */
|
|
static char *masterguard_commands_e[] = {
|
|
"Q", "Q1", "Q3", "PSR", "T", "TL", "S", "C", "CT", "WH", "DRC", "SRC", "FLT", "FCLR", "SS", "GS", "MSO", "PNV", "FOFF", "FON", "TUD", "GBS", "SSN", "GSN", "BUS", "V", "INVDC", "BUSP", "BUSN", NULL
|
|
};
|
|
|
|
/* claim function. fetch some mandatory values,
|
|
* disable unsupported commands,
|
|
* set enum for supported output voltages */
|
|
static int masterguard_claim(void) {
|
|
item_t *item;
|
|
/* mandatory values */
|
|
char *mandatory[] = {
|
|
"series", /* SKIP */
|
|
"device.model", /* minimal number of battery packs */
|
|
"ups.power.nominal", /* load computation */
|
|
"ups.id", /* slave address */
|
|
"output_voltages", /* output voltages enum */
|
|
#if 0
|
|
"battery.packs", /* battery voltage computation */
|
|
#endif
|
|
NULL
|
|
};
|
|
char **sp;
|
|
long config_slaveaddr;
|
|
char *sa;
|
|
char **commands;
|
|
|
|
if ((sa = getval("slave_address")) != NULL) {
|
|
char *p;
|
|
|
|
if (*sa == '\0') {
|
|
upsdebugx(2, "claim: empty slave_address");
|
|
return 0;
|
|
}
|
|
config_slaveaddr = strtol(sa, &p, 10);
|
|
if (*p != '\0' || config_slaveaddr < 0 || config_slaveaddr > 99) {
|
|
upsdebugx(2, "claim: illegal slave_address %s", sa);
|
|
return 0;
|
|
}
|
|
} else {
|
|
config_slaveaddr = -1;
|
|
}
|
|
for (sp = mandatory; *sp != NULL; sp++) {
|
|
char value[SMALLBUF] = "";
|
|
|
|
if ((item = find_nut_info(*sp, 0, QX_FLAG_SETVAR)) == NULL) {
|
|
upsdebugx(2, "claim: cannot find %s", *sp);
|
|
return 0;
|
|
}
|
|
/* since qx_process_answer() is not exported, there's no way
|
|
* to avoid sending the same command to the UPS again */
|
|
if (qx_process(item, NULL) < 0) {
|
|
upsdebugx(2, "claim: cannot process %s", *sp);
|
|
return 0;
|
|
}
|
|
/* only call the preprocess function; don't call ups_infoval_set()
|
|
* because that does a dstate_setinfo() before dstate_setflags()
|
|
* is called (via qx_set_var() in qx_ups_walk() with QX_WALKMODE_INIT);
|
|
* that leads to r/w vars ending up r/o. */
|
|
if (item->preprocess == NULL ) {
|
|
upsdebugx(2, "claim: no preprocess function for %s", *sp);
|
|
return 0;
|
|
}
|
|
if (item->preprocess(item, value, sizeof value)) {
|
|
upsdebugx(2, "claim: failed to preprocess %s", *sp);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (config_slaveaddr >= 0 && config_slaveaddr != strtol(masterguard_my_slaveaddr, NULL, 10)) {
|
|
upsdebugx(2, "claim: slave address mismatch: want %02ld, have %s", config_slaveaddr, masterguard_my_slaveaddr);
|
|
return 0;
|
|
}
|
|
|
|
switch (masterguard_my_series) {
|
|
case 'A':
|
|
commands = masterguard_commands_a;
|
|
break;
|
|
case 'E':
|
|
commands = masterguard_commands_e;
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
/* set SKIP flag for unimplemented commands */
|
|
for (item = masterguard_qx2nut; item->info_type != NULL; item++) {
|
|
int match = 0;
|
|
if (item->command == NULL || item->command[0] == '\0') continue;
|
|
for (sp = commands; sp != NULL; sp++) {
|
|
const char *p = *sp, *q = item->command;
|
|
|
|
while (1) {
|
|
if (*p == '\0' && (*q < 'A' || *q > 'Z')) {
|
|
match = 1; break;
|
|
} else if (*p == '\0' || *q < 'A' || *q > 'Z' || *p != *q) {
|
|
match = 0; break;
|
|
}
|
|
p++; q++;
|
|
}
|
|
if (match) break;
|
|
}
|
|
if (nut_debug_level >= 3) {
|
|
char cmd[10];
|
|
char *p = cmd; const char *q = item->command;
|
|
while (*q >= 'A' && *q <= 'Z') {
|
|
*p++ = *q++;
|
|
if (p - cmd >= (ptrdiff_t)sizeof cmd - 1) break;
|
|
}
|
|
*p++ = '\0';
|
|
upsdebugx(3, "command %s %simplemented", cmd, match ? "" : "NOT ");
|
|
|
|
}
|
|
if (!match)
|
|
item->qxflags |= QX_FLAG_SKIP;
|
|
}
|
|
|
|
/* set enum for output.voltage.nominal */
|
|
if ((item = find_nut_info("output.voltage.nominal", QX_FLAG_ENUM, QX_FLAG_SETVAR)) == NULL) {
|
|
upsdebugx(2, "claim: cannot find output.voltage.nominal");
|
|
return 0;
|
|
}
|
|
item->info_rw = masterguard_e_outvolts;
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
static void masterguard_makevartable(void) {
|
|
addvar(VAR_VALUE, "series", "Series (A/E)");
|
|
addvar(VAR_VALUE, "slave_address", "Slave address (UPS id) to match");
|
|
addvar(VAR_VALUE, "input_fault_voltage", "Input fault voltage (whatever that means)");
|
|
addvar(VAR_VALUE, "number_of_battery_cells", "Number of battery cells in series");
|
|
addvar(VAR_VALUE, "nominal_cell_voltage", "Nominal battery cell voltage");
|
|
addvar(VAR_VALUE, "runtime_half", "Nominal battery run time at 50% load (seconds)");
|
|
addvar(VAR_VALUE, "runtime_full", "Nominal battery run time at 100% load (seconds)");
|
|
addvar(VAR_VALUE, "recharge_time", "Nominal battery recharge time to 95% capacity (seconds)");
|
|
addvar(VAR_VALUE, "output_voltages", "Possible output voltages (volts)");
|
|
addvar(VAR_VALUE, "fault_1", "Fault record 1 (newest)");
|
|
addvar(VAR_VALUE, "fault_2", "Fault record 2");
|
|
addvar(VAR_VALUE, "fault_3", "Fault record 3");
|
|
addvar(VAR_VALUE, "fault_4", "Fault record 4");
|
|
addvar(VAR_VALUE, "fault_5", "Fault record 5 (oldest)");
|
|
}
|
|
|
|
|
|
#ifdef TESTING
|
|
static testing_t masterguard_testing[] = {
|
|
{ NULL }
|
|
};
|
|
#endif /* TESTING */
|
|
|
|
subdriver_t masterguard_subdriver = {
|
|
MASTERGUARD_VERSION,
|
|
masterguard_claim,
|
|
masterguard_qx2nut,
|
|
NULL, /* initups */
|
|
NULL, /* intinfo */
|
|
masterguard_makevartable,
|
|
NULL, /* accepted */
|
|
NULL, /* rejected */
|
|
#ifdef TESTING
|
|
masterguard_testing,
|
|
#endif /* TESTING */
|
|
};
|