/* initialize information */
void upsdrv_initinfo(void)
{
/* write constant data for this model */
dstate_setinfo ("ups.mfr", "%s", manufacturer);
dstate_setinfo ("ups.model", "%s", modelname);
dstate_setinfo ("ups.serial", "%s", serialnumber);
dstate_setinfo ("ups.model.type", "%s", types[type].name);
dstate_setinfo ("input.voltage.nominal", "%u", linevoltage);
/* now add the instant commands */
dstate_addcmd ("test.battery.start");
dstate_addcmd ("shutdown.return");
dstate_addcmd ("shutdown.stayoff");
upsh.instcmd = instcmd;
}
void upsdrv_initinfo(void)
{
const char *val;
time(&last_poll);
dstate_addcmd("shutdown.return");
dstate_addcmd("shutdown.stayoff");
val = getval("offdelay");
if (val) {
offdelay = strtol(val, NULL, 10);
}
val = getval("ondelay");
if (val) {
ondelay = strtol(val, NULL, 10);
}
val = getval("mincharge");
if (val) {
battery.charge.low = strtod(val, NULL);
}
val = getval("minruntime");
if (val) {
battery.runtime.low = strtod(val, NULL);
}
dstate_setinfo("ups.delay.shutdown", "%d", offdelay);
dstate_setinfo("ups.delay.start", "%d", ondelay);
dstate_setinfo("ups.timer.shutdown", "%d", ups.timer.shutdown);
dstate_setinfo("ups.timer.start", "%d", ups.timer.start);
upsh.instcmd = instcmd;
upsh.setvar = setvar;
}
void upsdrv_initinfo(void)
{
if (ivt_status() < 7) {
fatal_with_errno(EXIT_FAILURE, "IVT Solar Controller not detected");
}
/* set the device general information */
dstate_setinfo("device.mfr", "IVT");
dstate_setinfo("device.model", "Solar Controller Device");
dstate_setinfo("device.type", "scd");
dstate_addcmd("reset.input.minmax");
upsh.instcmd = instcmd;
}
void upsdrv_initinfo(void)
{
int ret;
ret = start_ups_comm();
if (ret < 0)
fatalx(EXIT_FAILURE, "No communication with UPS");
else if (ret > 0)
fatalx(EXIT_FAILURE, "Bad checksum or NACK");
else
upsdebugx(2, "Communication with UPS established");
if (typeRielloProtocol == DEV_RIELLOGPSER)
riello_parse_gi(&bufIn[0], &DevData);
else
riello_parse_sentr(&bufIn[0], &DevData);
gpser_error_control = DevData.Identif_bytes[4]-0x30;
if ((DevData.Identif_bytes[0] == '1') || (DevData.Identif_bytes[0] == '2'))
input_monophase = 1;
else {
input_monophase = 0;
dstate_setinfo("input.phases", "%u", 3);
dstate_setinfo("input.phases", "%u", 3);
dstate_setinfo("input.bypass.phases", "%u", 3);
}
if ((DevData.Identif_bytes[0] == '1') || (DevData.Identif_bytes[0] == '3'))
output_monophase = 1;
else {
output_monophase = 0;
dstate_setinfo("output.phases", "%u", 3);
}
dstate_setinfo("device.mfr", "RPS S.p.a.");
dstate_setinfo("device.model", "%s", (unsigned char*) DevData.ModelStr);
dstate_setinfo("device.serial", "%s", (unsigned char*) DevData.Identification);
dstate_setinfo("device.type", "ups");
dstate_setinfo("ups.mfr", "RPS S.p.a.");
dstate_setinfo("ups.model", "%s", (unsigned char*) DevData.ModelStr);
dstate_setinfo("ups.serial", "%s", (unsigned char*) DevData.Identification);
dstate_setinfo("ups.firmware", "%s", (unsigned char*) DevData.Version);
if (typeRielloProtocol == DEV_RIELLOGPSER) {
if (get_ups_nominal() == 0) {
dstate_setinfo("ups.realpower.nominal", "%u", DevData.NomPowerKW);
dstate_setinfo("ups.power.nominal", "%u", DevData.NomPowerKVA);
dstate_setinfo("output.voltage.nominal", "%u", DevData.NominalUout);
dstate_setinfo("output.frequency.nominal", "%.1f", DevData.NomFout/10.0);
dstate_setinfo("battery.voltage.nominal", "%u", DevData.NomUbat);
dstate_setinfo("battery.capacity", "%u", DevData.NomBatCap);
}
}
else {
if (get_ups_sentr() == 0) {
dstate_setinfo("ups.realpower.nominal", "%u", DevData.NomPowerKW);
dstate_setinfo("ups.power.nominal", "%u", DevData.NomPowerKVA);
dstate_setinfo("output.voltage.nominal", "%u", DevData.NominalUout);
dstate_setinfo("output.frequency.nominal", "%.1f", DevData.NomFout/10.0);
dstate_setinfo("battery.voltage.nominal", "%u", DevData.NomUbat);
dstate_setinfo("battery.capacity", "%u", DevData.NomBatCap);
}
}
/* commands ----------------------------------------------- */
dstate_addcmd("load.off");
dstate_addcmd("load.on");
dstate_addcmd("load.off.delay");
dstate_addcmd("load.on.delay");
dstate_addcmd("shutdown.return");
dstate_addcmd("shutdown.stop");
dstate_addcmd("test.battery.start");
if (typeRielloProtocol == DEV_RIELLOGPSER)
dstate_addcmd("test.panel.start");
/* install handlers */
/* upsh.setvar = hid_set_value; setvar; */
upsh.instcmd = riello_instcmd;
}
void blazer_initinfo(void)
{
const char *protocol = getval("protocol");
int retry;
for (proto = 0; command[proto].status; proto++) {
int ret;
if (protocol && strcasecmp(protocol, command[proto].name)) {
upsdebugx(2, "Skipping %s protocol...", command[proto].name);
continue;
}
upsdebugx(2, "Trying %s protocol...", command[proto].name);
for (retry = 1; retry <= MAXTRIES; retry++) {
ret = blazer_status(command[proto].status);
if (ret < 0) {
upsdebugx(2, "Status read %d failed", retry);
continue;
}
upsdebugx(2, "Status read in %d tries", retry);
break;
}
if (!ret) {
upslogx(LOG_INFO, "Supported UPS detected with %s protocol", command[proto].name);
break;
}
}
if (!command[proto].status) {
fatalx(EXIT_FAILURE, "No supported UPS detected");
}
if (command[proto].rating && !testvar("norating")) {
int ret;
for (retry = 1; retry <= MAXTRIES; retry++) {
ret = blazer_rating(command[proto].rating);
if (ret < 0) {
upsdebugx(1, "Rating read %d failed", retry);
continue;
}
upsdebugx(2, "Ratings read in %d tries", retry);
break;
}
if (ret) {
upslogx(LOG_DEBUG, "Rating information unavailable");
}
}
if (command[proto].vendor && !testvar("novendor")) {
int ret;
for (retry = 1; retry <= MAXTRIES; retry++) {
ret = blazer_vendor(command[proto].vendor);
if (ret < 0) {
upsdebugx(1, "Vendor information read %d failed", retry);
continue;
}
upslogx(LOG_INFO, "Vendor information read in %d tries", retry);
break;
}
if (ret) {
upslogx(LOG_DEBUG, "Vendor information unavailable");
}
}
blazer_initbattery();
dstate_setinfo("ups.delay.start", "%d", 60 * ondelay);
dstate_setinfo("ups.delay.shutdown", "%d", offdelay);
dstate_addcmd("beeper.toggle");
dstate_addcmd("load.off");
dstate_addcmd("load.on");
dstate_addcmd("shutdown.return");
dstate_addcmd("shutdown.stayoff");
dstate_addcmd("shutdown.stop");
dstate_addcmd("test.battery.start");
dstate_addcmd("test.battery.start.deep");
dstate_addcmd("test.battery.start.quick");
dstate_addcmd("test.battery.stop");
upsh.instcmd = blazer_instcmd;
}
void upsdrv_initinfo(void)
{
char response[MAX_RESPONSE_LENGTH];
unsigned int min_low_transfer, max_low_transfer;
unsigned int min_high_transfer, max_high_transfer;
unsigned int i;
char *ptr;
if (!init_comm())
fatalx(EXIT_FAILURE, "Unable to detect Tripp Lite SmartOnline UPS on port %s\n",
device_path);
min_low_transfer = max_low_transfer = 0;
min_high_transfer = max_high_transfer = 0;
/* get all the read-only fields here */
if (do_command(POLL, MANUFACTURER, "", response) > 0)
dstate_setinfo("ups.mfr", "%s", response);
if (do_command(POLL, MODEL, "", response) > 0)
dstate_setinfo("ups.model", "%s", response);
if (do_command(POLL, VERSION_CMD, "", response) > 0)
dstate_setinfo("ups.firmware", "%s", response);
if (do_command(POLL, RATINGS, "", response) > 0) {
ptr = field(response, 0);
if (ptr)
dstate_setinfo("input.voltage.nominal", "%d",
atoi(ptr));
ptr = field(response, 2);
if (ptr) {
dstate_setinfo("output.voltage.nominal", "%d",
atoi(ptr));
}
ptr = field(response, 14);
if (ptr)
dstate_setinfo("battery.voltage.nominal", "%d",
atoi(ptr));
ptr = field(response, 10);
if (ptr)
min_low_transfer = atoi(ptr);
ptr = field(response, 9);
if (ptr)
max_low_transfer = atoi(ptr);
ptr = field(response, 12);
if (ptr)
min_high_transfer = atoi(ptr);
ptr = field(response, 11);
if (ptr)
max_high_transfer = atoi(ptr);
}
if (do_command(POLL, OUTLET_RELAYS, "", response) > 0)
ups.outlet_banks = atoi(response);
/* define things that are settable */
if (get_identification()) {
dstate_setflags("ups.id", ST_FLAG_RW | ST_FLAG_STRING);
dstate_setaux("ups.id", 100);
}
if (get_transfer_voltage_low() && max_low_transfer) {
dstate_setflags("input.transfer.low", ST_FLAG_RW);
for (i = min_low_transfer; i <= max_low_transfer; i++)
dstate_addenum("input.transfer.low", "%d", i);
}
if (get_transfer_voltage_high() && max_low_transfer) {
dstate_setflags("input.transfer.high", ST_FLAG_RW);
for (i = min_high_transfer; i <= max_high_transfer; i++)
dstate_addenum("input.transfer.high", "%d", i);
}
if (get_sensitivity()) {
dstate_setflags("input.sensitivity", ST_FLAG_RW);
for (i = 0; i < sizeof(sensitivity) / sizeof(sensitivity[0]);
i++)
dstate_addenum("input.sensitivity", "%s",
sensitivity[i].name);
}
if (ups.outlet_banks) {
dstate_addcmd("load.off");
dstate_addcmd("load.on");
}
dstate_addcmd("shutdown.reboot");
dstate_addcmd("shutdown.reboot.graceful");
dstate_addcmd("shutdown.return");
#if 0 /* doesn't work */
dstate_addcmd("shutdown.stayoff");
#endif
dstate_addcmd("shutdown.stop");
dstate_addcmd("test.battery.start");
dstate_addcmd("test.battery.stop");
/* add all the variables that change regularly */
upsdrv_updateinfo();
upsh.instcmd = instcmd;
upsh.setvar = setvar;
printf("Detected %s %s on %s\n", dstate_getinfo("ups.mfr"),
dstate_getinfo("ups.model"), device_path);
}
/* check which commands this ups supports.
* Returns TRUE if command list was recieved, FALSE otherwise */
static int upsc_commandlist(void)
{
char buf[UPSC_BUFLEN];
cmd_t *cp;
upsc_flush_input();
upscsend("UPCL");
while (1) {
upscrecv(buf);
if (strlen(buf) == 0) {
upslogx(LOG_ERR, "Missing UPCL after UPCL");
return 0;
}
upsdebugx(2, "Supports command: %s", buf);
if (strcmp(buf, "UPBS") == 0)
can_upbs = 1;
else if (strcmp(buf, "UPPM") == 0)
can_uppm = 1;
else if (strcmp(buf, "UPID") == 0)
can_upid = 1;
else if (strcmp(buf, "UPDA") == 0)
can_upda = 1;
else if (strcmp(buf, "UPDT") == 0)
can_updt = 1;
else if (strcmp(buf, "UPTM") == 0)
can_uptm = 1;
else if (strcmp(buf, "UPSD") == 0)
can_upsd = 1;
else if (strcmp(buf, "UPPC") == 0)
can_uppc = 1;
for (cp = commands; cp->cmd; cp++) {
if (cp->upsc && strcmp(cp->upsc, buf) == 0) {
upsdebugx(1, "instcmd: %s %s", cp->cmd, cp->upsc);
dstate_addcmd(cp->cmd);
cp->enabled = 1;
break;
}
}
for (cp = variables; cp->cmd; cp++) {
if (cp->upsc && strcmp(cp->upsc, buf) == 0) {
upsdebugx(1, "setvar: %s %s", cp->cmd, cp->upsc);
cp->enabled = 1;
break;
}
}
if (strcmp(buf, "UPCL") == 0)
break;
}
for (cp = variables; cp->cmd; cp++) {
if (cp->enabled) {
upsc_getvalue(cp->upsc, "0000", cp->upsp, cp->cmd, NULL);
dstate_setflags(cp->cmd, ST_FLAG_RW | ST_FLAG_STRING);
dstate_setaux(cp->cmd, 7);
}
}
return 1;
}
void upsdrv_initinfo(void)
{
dummy_info_t *item;
switch (mode)
{
case MODE_DUMMY:
/* Initialise basic essential variables */
for ( item = nut_data ; item->info_type != NULL ; item++ )
{
if (item->drv_flags & DU_FLAG_INIT)
{
dstate_setinfo(item->info_type, "%s", item->default_value);
dstate_setflags(item->info_type, item->info_flags);
/* Set max length for strings, if needed */
if (item->info_flags & ST_FLAG_STRING)
dstate_setaux(item->info_type, item->info_len);
}
}
/* Now get user's defined variables */
if (parse_data_file(upsfd) < 0)
upslogx(LOG_NOTICE, "Unable to parse the definition file %s", device_path);
/* Initialize handler */
upsh.setvar = setvar;
dstate_dataok();
break;
case MODE_META:
case MODE_REPEATER:
/* Obtain the target name */
if (upscli_splitname(device_path, &client_upsname, &hostname, &port) != 0)
{
fatalx(EXIT_FAILURE, "Error: invalid UPS definition.\nRequired format: upsname[@hostname[:port]]");
}
/* Connect to the target */
ups = xmalloc(sizeof(*ups));
if (upscli_connect(ups, hostname, port, UPSCLI_CONN_TRYSSL) < 0)
{
fatalx(EXIT_FAILURE, "Error: %s", upscli_strerror(ups));
}
else
{
upsdebugx(1, "Connected to %s@%s", client_upsname, hostname);
}
if (upsclient_update_vars() < 0)
{
/* check for an old upsd */
if (upscli_upserror(ups) == UPSCLI_ERR_UNKCOMMAND)
{
fatalx(EXIT_FAILURE, "Error: upsd is too old to support this query");
}
fatalx(EXIT_FAILURE, "Error: %s", upscli_strerror(ups));
}
/* FIXME: commands and settable variable! */
break;
default:
case MODE_NONE:
fatalx(EXIT_FAILURE, "no suitable definition found!");
break;
}
upsh.instcmd = instcmd;
dstate_addcmd("load.off");
}
void upsdrv_initinfo(void)
{
int i,j, k;
int VRange=0;
int timevalue;
int RetValue;
char buffer[256], buffer2[32];
/* All families should reply to this request so we can confirm that it is
* an ONEAC UPS
*/
ser_flush_in(upsfd,"",0);
ser_send(upsfd,"%c%s",GET_FAMILY,COMMAND_END);
if(OneacGetResponse (buffer, sizeof(buffer), 2))
{
fatalx(EXIT_FAILURE, "Serial timeout with ONEAC UPS on %s\n",
device_path);
}
else
{
if (strncmp(buffer,FAMILY_ON,FAMILY_SIZE) != 0 &&
strncmp(buffer,FAMILY_OZ,FAMILY_SIZE) != 0 &&
strncmp(buffer,FAMILY_OB,FAMILY_SIZE) != 0 &&
strncmp(buffer,FAMILY_EG,FAMILY_SIZE) != 0)
{
fatalx(EXIT_FAILURE, "Did not find an ONEAC UPS on %s\n",
device_path);
}
}
/* UPS Model (either EG, ON, OZ or OB series of UPS) */
strncpy(UpsFamily, buffer, FAMILY_SIZE);
UpsFamily[2] = '\0';
dstate_setinfo("device.model", "%s",UpsFamily);
printf("Found %s family of Oneac UPS\n", UpsFamily);
dstate_setinfo("ups.type", "%s", "Line Interactive");
dstate_addcmd("test.battery.start.quick");
dstate_addcmd("test.battery.stop");
dstate_addcmd("test.failure.start");
dstate_addcmd("shutdown.return");
dstate_addcmd("shutdown.stop");
dstate_addcmd("shutdown.reboot");
upsh.setvar = setcmd;
upsh.instcmd = instcmd;
/* set some stuff that shouldn't change after initialization */
/* this stuff is common to all families of UPS */
ser_send(upsfd,"%c%s",GET_ALL,COMMAND_END);
if (strncmp(UpsFamily, FAMILY_EG, FAMILY_SIZE) == 0)
{
RetValue = OneacGetResponse (buffer, sizeof(buffer),
GETALL_EG_RESP_SIZE);
}
else
{
RetValue = OneacGetResponse (buffer, sizeof(buffer), GETALL_RESP_SIZE);
}
if(RetValue)
{
fatalx(EXIT_FAILURE, "Serial timeout(2) with ONEAC UPS on %s\n",
device_path);
}
/* Manufacturer */
dstate_setinfo("device.mfr", "%.5s", buffer);
/*firmware revision*/
dstate_setinfo("ups.firmware", "%.3s",buffer+7);
/*nominal AC frequency setting --either 50 or 60*/
dstate_setinfo("input.frequency.nominal", "%.2s", buffer+20);
dstate_setinfo("output.frequency.nominal", "%.2s", buffer+20);
/* Shutdown delay in seconds...can be changed by user */
if (getval("offdelay") == NULL)
dstate_setinfo("ups.delay.shutdown", "0");
else
dstate_setinfo("ups.delay.shutdown", "%s", getval("offdelay"));
dstate_setflags("ups.delay.shutdown", ST_FLAG_STRING | ST_FLAG_RW);
dstate_setaux("ups.delay.shutdown", GET_SHUTDOWN_RESP_SIZE);
/* Setup some ON/OZ/OB only stuff ... i.e. not EG */
if (strncmp(UpsFamily, FAMILY_EG, FAMILY_SIZE) != 0)
{
dstate_addcmd("reset.input.minmax");
/*nominal input voltage*/
VRange = buffer[26]; /* Keep for later use also */
switch (VRange) /* Will be '1' or '2' */
{
case V120AC:
dstate_setinfo("input.voltage.nominal", "120");
dstate_setinfo("output.voltage.nominal", "120");
break;
case V230AC:
dstate_setinfo("input.voltage.nominal", "230");
dstate_setinfo("output.voltage.nominal", "230");
break;
default:
upslogx(LOG_INFO,"Oneac: "
"Invalid nom voltage parameter from UPS [%c]", VRange);
}
}
/* Setup some OZ/OB only stuff */
if ((strncmp (UpsFamily, FAMILY_OZ, FAMILY_SIZE) == 0) ||
(strncmp (UpsFamily, FAMILY_OB, FAMILY_SIZE) == 0))
{
dstate_addcmd("test.panel.start");
dstate_addcmd("test.battery.start.deep");
dstate_addcmd("beeper.enable");
dstate_addcmd("beeper.disable");
dstate_addcmd("beeper.mute");
dstate_setaux("ups.delay.shutdown", GETX_SHUTDOWN_RESP_SIZE);
ser_flush_in(upsfd,"",0);
ser_send(upsfd,"%c%s",GETX_ALL_2,COMMAND_END);
if(OneacGetResponse (buffer, sizeof(buffer), GETX_ALL2_RESP_SIZE))
{
fatalx(EXIT_FAILURE, "Serial timeout(3) with ONEAC UPS on %s\n",
device_path);
}
/* Low and high output trip points */
EliminateLeadingZeroes (buffer+73, 3, buffer2, sizeof(buffer2));
dstate_setinfo("input.transfer.low", "%s", buffer2);
dstate_setflags("input.transfer.low", ST_FLAG_STRING | ST_FLAG_RW );
dstate_setaux("input.transfer.low", 3);
EliminateLeadingZeroes (buffer+76, 3, buffer2, sizeof(buffer2));
dstate_setinfo("input.transfer.high", "%s", buffer2);
dstate_setflags("input.transfer.high", ST_FLAG_STRING | ST_FLAG_RW);
dstate_setaux("input.transfer.high", 3);
/* Restart delay */
EliminateLeadingZeroes (buffer+84, 4, buffer2, sizeof(buffer2));
dstate_setinfo("ups.delay.start", "%s", buffer2);
dstate_setflags("ups.delay.start", ST_FLAG_STRING | ST_FLAG_RW);
dstate_setaux("ups.delay.start", 4);
/* Low Batt at time */
strncpy(buffer2, buffer+82, 2);
buffer2[2]='\0';
timevalue = atoi(buffer2) * 60; /* Change minutes to seconds */
dstate_setinfo("battery.runtime.low", "%d",timevalue);
dstate_setflags("battery.runtime.low", ST_FLAG_STRING | ST_FLAG_RW);
dstate_setaux("battery.runtime.low", 2);
/*Get the actual model string for ON UPS reported as OZ/OB family*/
/*UPS Model (full string)*/
memset(buffer2, '\0', 32);
strncpy(buffer2, buffer+5, 10);
for (i = 9; i >= 0 && buffer2[i] == ' '; --i)
{
buffer2[i] = '\0';
}
dstate_setinfo("device.model", "%s", buffer2);
/* Serial number */
dstate_setinfo("device.serial", "%.4s-%.4s", buffer+18, buffer+22);
printf("Found %.10s UPS with serial number %.4s-%.4s\n",
buffer2, buffer+18, buffer+22);
/* Manufacture Date */
dstate_setinfo("ups.mfr.date", "%.6s (yymmdd)", buffer+38);
/* Battery Replace Date */
dstate_setinfo("battery.date", "%.6s (yymmdd)", buffer+44);
dstate_setflags("battery.date", ST_FLAG_STRING | ST_FLAG_RW);
dstate_setaux("battery.date", 6);
/* Real power nominal */
EliminateLeadingZeroes (buffer+55, 5, buffer2, sizeof(buffer2));
dstate_setinfo("ups.realpower.nominal", "%s", buffer2);
/* Set up ups.start.auto to be writable */
dstate_setinfo("ups.start.auto", "yes");
dstate_setflags("ups.start.auto", ST_FLAG_STRING | ST_FLAG_RW);
dstate_setaux("ups.start.auto", 3);
/* Get output window min/max points from OB or OZ v1.9 or later */
if ((strncmp (UpsFamily, FAMILY_OB, FAMILY_SIZE) == 0) ||
(strcmp (dstate_getinfo("ups.firmware"), MIN_ALLOW_FW) >= 0 ))
{
upsdebugx (2,"Can get output window min/max! (%s)",
dstate_getinfo("ups.firmware"));
ser_send(upsfd,"%s%s",GETX_ALLOW_RANGE,COMMAND_END);
if(OneacGetResponse (buffer, sizeof(buffer), GETX_RANGE_RESP_SIZE))
{
fatalx(EXIT_FAILURE,
"Serial timeout(4) with ONEAC UPS on %s\n",device_path);
}
strncpy(buffer2, buffer, 3);
buffer2[3]='\0';
i = atoi(buffer2); /* Minimum voltage */
strncpy(buffer2, buffer+4, 3);
j = atoi(buffer2); /* Maximum voltage */
strncpy(buffer2, buffer+8, 2);
buffer2[2]='\0';
k = atoi(buffer2); /* Spread between */
dstate_setinfo("input.transfer.low.min", "%3d", i);
dstate_setinfo("input.transfer.low.max", "%3d", j-k);
dstate_setinfo("input.transfer.high.min", "%3d", i+k);
dstate_setinfo("input.transfer.high.max", "%3d", j);
}
else
{
/* Use default values from firmware */
upsdebugx (2,"Using trip defaults (%s)...",
dstate_getinfo("ups.firmware"));
switch (VRange) /* Held from initial use */
{
case V120AC:
dstate_setinfo("input.transfer.low.min", "90");
dstate_setinfo("input.transfer.low.max", "120");
dstate_setinfo("input.transfer.high.min", "110");
dstate_setinfo("input.transfer.high.max", "140");
break;
case V230AC:
dstate_setinfo("input.transfer.low.min", "172");
dstate_setinfo("input.transfer.low.max", "228");
dstate_setinfo("input.transfer.high.min", "212");
dstate_setinfo("input.transfer.high.max", "268");
break;
default:
;
}
}
}
}
void upsdrv_initinfo(void)
{
unsigned char my_answer[255];
char serial[13];
int res, i;
/* Initial setup of variables */
#ifdef EXTRADATA
dstate_setinfo("output.power", "%d", -1);
dstate_setflags("output.power", ST_FLAG_RW);
#endif
dstate_setinfo("output.voltage", "%d", -1);
dstate_setflags("output.voltage", ST_FLAG_RW);
dstate_setinfo("output.current", "%d", -1);
dstate_setflags("output.current", ST_FLAG_RW);
#ifdef EXTRADATA
dstate_setinfo("output.current.peak", "%2.2f", -1);
dstate_setflags("output.current.peak", ST_FLAG_RW);
dstate_setinfo("input.power", "%d", -1);
dstate_setflags("input.power", ST_FLAG_RW);
#endif
dstate_setinfo("input.voltage", "%d", -1);
dstate_setflags("input.voltage", ST_FLAG_RW);
#ifdef EXTRADATA
dstate_setinfo("input.current", "%2.2f", -1);
dstate_setflags("input.current", ST_FLAG_RW);
dstate_setinfo("input.current.peak", "%2.2f", -1);
dstate_setflags("input.current.peak", ST_FLAG_RW);
#endif
dstate_setinfo("battery.voltage", "%d", -1);
dstate_setflags("battery.voltage", ST_FLAG_RW);
#ifdef EXTRADATA
dstate_setinfo("battery.voltage.low", "%2.2f", -1);
dstate_setflags("battery.voltage.low", ST_FLAG_RW);
dstate_setinfo("battery.voltage.exhaust", "%2.2f", -1);
dstate_setflags("battery.voltage.exhaust", ST_FLAG_RW);
dstate_setinfo("ups.total.runtime", "retrieving...");
dstate_setflags("ups.total.runtime", ST_FLAG_STRING | ST_FLAG_RW);
dstate_setaux("ups.total.runtime", 20);
dstate_setinfo("ups.inverter.runtime", "retrieving...");
dstate_setflags("ups.inverter.runtime", ST_FLAG_STRING | ST_FLAG_RW);
dstate_setaux("ups.inverter.runtime", 20);
dstate_setinfo("ups.inverter.interventions", "%d", -1);
dstate_setflags("ups.inverter.interventions", ST_FLAG_RW);
dstate_setinfo("battery.full.discharges", "%d", -1);
dstate_setflags("battery.full.discharges", ST_FLAG_RW);
dstate_setinfo("ups.bypass.interventions", "%d", -1);
dstate_setflags("ups.bypass.interventions", ST_FLAG_RW);
dstate_setinfo("ups.overheatings", "%d", -1);
dstate_setflags("ups.overheatings", ST_FLAG_RW);
#endif
dstate_setinfo("ups.load", "%d", -1);
dstate_setflags("ups.load", ST_FLAG_RW);
dstate_setinfo("ups.delay.shutdown", "%d", -1);
dstate_setflags("ups.delay.shutdown", ST_FLAG_RW);
dstate_setinfo("ups.delay.start", "%d", -1);
dstate_setflags("ups.delay.start", ST_FLAG_RW);
dstate_setinfo("ups.temperature", "%d", -1);
dstate_setflags("ups.temperature", ST_FLAG_RW);
dstate_setinfo("ups.test.result", "not yet done...");
dstate_setflags("ups.test.result", ST_FLAG_STRING | ST_FLAG_RW);
dstate_setaux("ups.test.result", 20);
/* UPS INFO READ */
res = command_read_sequence(UPS_INFO, my_answer);
if (res < 0) fatal_with_errno(EXIT_FAILURE, "Could not communicate with the ups");
/* the manufacturer is hard coded into the driver, the model type is in the second
byte of the answer, the third byte identifies the model version */
dstate_setinfo("ups.mfr", "Meta System");
i = my_answer[1] * 10 + my_answer[2];
switch (i) {
case 11:
dstate_setinfo("ups.model", "%s", "HF Line (1 board)");
nominal_power = 630;
break;
case 12:
dstate_setinfo("ups.model", "%s", "HF Line (2 boards)");
nominal_power = 1260;
break;
case 13:
dstate_setinfo("ups.model", "%s", "HF Line (3 boards)");
nominal_power = 1890;
break;
case 14:
dstate_setinfo("ups.model", "%s", "HF Line (4 boards)");
nominal_power = 2520;
break;
case 21:
dstate_setinfo("ups.model", "%s", "ECO Network 750/1000");
nominal_power = 500;
break;
case 22:
dstate_setinfo("ups.model", "%s", "ECO Network 1050/1500");
nominal_power = 700;
break;
case 23:
dstate_setinfo("ups.model", "%s", "ECO Network 1500/2000");
nominal_power = 1000;
break;
case 24:
dstate_setinfo("ups.model", "%s", "ECO Network 1800/2500");
nominal_power = 1200;
break;
case 25:
dstate_setinfo("ups.model", "%s", "ECO Network 2100/3000");
nominal_power = 1400;
break;
case 31:
dstate_setinfo("ups.model", "%s", "ECO 308");
nominal_power = 500;
break;
case 32:
dstate_setinfo("ups.model", "%s", "ECO 311");
nominal_power = 700;
break;
case 44:
dstate_setinfo("ups.model", "%s", "HF Line (4 boards)/2");
nominal_power = 2520;
break;
case 45:
dstate_setinfo("ups.model", "%s", "HF Line (5 boards)/2");
nominal_power = 3150;
break;
case 46:
dstate_setinfo("ups.model", "%s", "HF Line (6 boards)/2");
nominal_power = 3780;
break;
case 47:
dstate_setinfo("ups.model", "%s", "HF Line (7 boards)/2");
nominal_power = 4410;
break;
case 48:
dstate_setinfo("ups.model", "%s", "HF Line (8 boards)/2");
nominal_power = 5040;
break;
case 51:
dstate_setinfo("ups.model", "%s", "HF Millennium 810");
nominal_power = 700;
break;
case 52:
dstate_setinfo("ups.model", "%s", "HF Millennium 820");
nominal_power = 1400;
break;
case 61:
dstate_setinfo("ups.model", "%s", "HF TOP Line 910");
nominal_power = 700;
break;
case 62:
dstate_setinfo("ups.model", "%s", "HF TOP Line 920");
nominal_power = 1400;
break;
case 63:
dstate_setinfo("ups.model", "%s", "HF TOP Line 930");
nominal_power = 2100;
break;
case 64:
dstate_setinfo("ups.model", "%s", "HF TOP Line 940");
nominal_power = 2800;
break;
case 74:
dstate_setinfo("ups.model", "%s", "HF TOP Line 940/2");
nominal_power = 2800;
break;
case 75:
dstate_setinfo("ups.model", "%s", "HF TOP Line 950/2");
nominal_power = 3500;
break;
case 76:
dstate_setinfo("ups.model", "%s", "HF TOP Line 960/2");
nominal_power = 4200;
break;
case 77:
dstate_setinfo("ups.model", "%s", "HF TOP Line 970/2");
nominal_power = 4900;
break;
case 78:
dstate_setinfo("ups.model", "%s", "HF TOP Line 980/2");
nominal_power = 5600;
break;
case 81:
dstate_setinfo("ups.model", "%s", "ECO 508");
nominal_power = 500;
break;
case 82:
dstate_setinfo("ups.model", "%s", "ECO 511");
nominal_power = 700;
break;
case 83:
dstate_setinfo("ups.model", "%s", "ECO 516");
nominal_power = 1000;
break;
case 84:
dstate_setinfo("ups.model", "%s", "ECO 519");
nominal_power = 1200;
break;
case 85:
dstate_setinfo("ups.model", "%s", "ECO 522");
nominal_power = 1400;
break;
case 91:
dstate_setinfo("ups.model", "%s", "ECO 305 / Harviot 530 SX");
nominal_power = 330;
break;
case 92:
dstate_setinfo("ups.model", "%s", "ORDINATORE 2");
nominal_power = 330;
break;
case 93:
dstate_setinfo("ups.model", "%s", "Harviot 730 SX");
nominal_power = 430;
break;
case 101:
dstate_setinfo("ups.model", "%s", "ECO 308 SX / SX Interactive / Ordinatore");
nominal_power = 500;
break;
case 102:
dstate_setinfo("ups.model", "%s", "ECO 311 SX / SX Interactive");
nominal_power = 700;
break;
case 111:
dstate_setinfo("ups.model", "%s", "ally HF 800 / BI-TWICE 800");
nominal_power = 560;
break;
case 112:
dstate_setinfo("ups.model", "%s", "ally HF 1600");
nominal_power = 1120;
break;
case 121:
dstate_setinfo("ups.model", "%s", "ally HF 1000 / BI-TWICE 1000");
nominal_power = 700;
break;
case 122:
dstate_setinfo("ups.model", "%s", "ally HF 2000");
nominal_power = 1400;
break;
case 131:
dstate_setinfo("ups.model", "%s", "ally HF 1250 / BI-TWICE 1250");
nominal_power = 875;
break;
case 132:
dstate_setinfo("ups.model", "%s", "ally HF 2500");
nominal_power = 1750;
break;
case 141:
dstate_setinfo("ups.model", "%s", "Megaline 1250");
nominal_power = 875;
break;
case 142:
dstate_setinfo("ups.model", "%s", "Megaline 2500");
nominal_power = 1750;
break;
case 143:
dstate_setinfo("ups.model", "%s", "Megaline 3750");
nominal_power = 2625;
break;
case 144:
dstate_setinfo("ups.model", "%s", "Megaline 5000");
nominal_power = 3500;
break;
case 154:
dstate_setinfo("ups.model", "%s", "Megaline 5000 / 2");
nominal_power = 3500;
break;
case 155:
dstate_setinfo("ups.model", "%s", "Megaline 6250 / 2");
nominal_power = 4375;
break;
case 156:
dstate_setinfo("ups.model", "%s", "Megaline 7500 / 2");
nominal_power = 5250;
break;
case 157:
dstate_setinfo("ups.model", "%s", "Megaline 8750 / 2");
nominal_power = 6125;
break;
case 158:
dstate_setinfo("ups.model", "%s", "Megaline 10000 / 2");
nominal_power = 7000;
break;
default:
fatal_with_errno(EXIT_FAILURE, "Unknown UPS");
break;
}
/* Get the serial number */
memcpy(serial, my_answer + 7, res - 7);
/* serial number start from the 8th byte */
serial[12]=0; /* terminate string */
dstate_setinfo("ups.serial", "%s", serial);
/* get the ups firmware. The major number is in the 5th byte, the minor is in the 6th */
dstate_setinfo("ups.firmware", "%u.%u", my_answer[5], my_answer[6]);
printf("Detected %s [%s] v.%s on %s\n", dstate_getinfo("ups.model"), dstate_getinfo("ups.serial"), dstate_getinfo("ups.firmware"), device_path);
/* Add instant commands */
dstate_addcmd("shutdown.return");
dstate_addcmd("shutdown.stayoff");
dstate_addcmd("shutdown.stop");
dstate_addcmd("test.failure.start");
dstate_addcmd("test.failure.stop");
dstate_addcmd("test.battery.start");
dstate_addcmd("beeper.enable");
dstate_addcmd("beeper.mute");
dstate_addcmd("beeper.on");
dstate_addcmd("beeper.off");
upsh.instcmd = instcmd;
return;
}
static void getbaseinfo(void)
{
unsigned char temp[256];
unsigned char Pacote[37];
int tam, i, j=0;
time_t tmt;
struct tm *now;
const char *Model;
time( &tmt );
now = localtime( &tmt );
dian = now->tm_mday;
mesn = now->tm_mon+1;
anon = now->tm_year+1900;
weekn = now->tm_wday;
/* trying detect rhino model */
while ( ( !detected ) && ( j < 10 ) )
{
temp[0] = 0; /* flush temp buffer */
tam = ser_get_buf_len(upsfd, temp, pacsize, 3, 0);
if( tam == 37 )
{
for( i = 0 ; i < tam ; i++ )
{
Pacote[i] = temp[i];
}
}
j++;
if( tam == 37)
CommReceive(Pacote, tam);
else
CommReceive(temp, tam);
}
if( (!detected) )
{
fatalx(EXIT_FAILURE, NO_RHINO );
}
switch( RhinoModel )
{
case 0xC0:
{
Model = "Rhino 20.0 kVA";
PotenciaNominal = 20000;
break;
}
case 0xC1:
{
Model = "Rhino 10.0 kVA";
PotenciaNominal = 10000;
break;
}
case 0xC2:
{
Model = "Rhino 6.0 kVA";
PotenciaNominal = 6000;
break;
}
case 0xC3:
{
Model = "Rhino 7.5 kVA";
PotenciaNominal = 7500;
break;
}
default:
{
Model = "Rhino unknown model";
PotenciaNominal = 0;
break;
}
}
/* manufacturer and model */
dstate_setinfo("ups.mfr", "%s", "Microsol");
dstate_setinfo("ups.model", "%s", Model);
/*
dstate_setinfo("input.transfer.low", "%03.1f", InDownLim); LimInfBattInv ?
dstate_setinfo("input.transfer.high", "%03.1f", InUpLim); LimSupBattInv ?
*/
dstate_addcmd("shutdown.stayoff"); /* CMD_SHUT */
/* there is no reserved words for CMD_INON and CMD_INOFF yet */
/* dstate_addcmd("input.on"); */ /* CMD_INON = 1 */
/* dstate_addcmd("input.off"); */ /* CMD_INOFF = 2 */
dstate_addcmd("load.on"); /* CMD_OUTON = 3 */
dstate_addcmd("load.off"); /* CMD_OUTOFF = 4 */
dstate_addcmd("bypass.start"); /* CMD_PASSON = 5 */
dstate_addcmd("bypass.stop"); /* CMD_PASSOFF = 6 */
printf("Detected %s on %s\n", dstate_getinfo("ups.model"), device_path);
}
