void update_inverter_status()
{
if((buf[INV_STATUS]) == '0')
dstate_setinfo("inverter.status", "%s","OFF");
else
dstate_setinfo("inverter.status", "%s","ON");
}
/* Set up all the funky shared memory stuff used to communicate with upsd */
void upsdrv_initinfo (void)
{
/* now set up room for all future variables that are supported */
dstate_setinfo("ups.mfr", "%s", "Best Power");
switch(fc.model) {
case ME3100:
dstate_setinfo("ups.model", "Micro Ferrups (ME) %d", fc.va);
break;
case MD1KVA:
dstate_setinfo("ups.model", "Micro Ferrups (MD) %d", fc.va);
break;
case RE1800:
dstate_setinfo("ups.model", "Micro Ferrups (RE) %d", fc.va);
break;
default:
fatalx(EXIT_FAILURE, "UPS model not matched!"); /* Will never get here, upsdrv_initups() will catch */
}
fprintf(stderr, "Best Power %s detected\n",
dstate_getinfo("ups.model"));
fprintf(stderr, "Battery voltages %5.1f nominal, %5.1f full, %5.1f empty\n",
fc.idealbvolts,
fc.fullvolts,
fc.emptyvolts);
}
/* write the status_buf into the externally visible dstate storage */
void status_commit(void)
{
while (ignorelb) {
const char *val, *low;
val = dstate_getinfo("battery.charge");
low = dstate_getinfo("battery.charge.low");
if (val && low && (strtol(val, NULL, 10) < strtol(low, NULL, 10))) {
snprintfcat(status_buf, sizeof(status_buf), " LB");
upsdebugx(2, "%s: appending LB flag [charge '%s' below '%s']", __func__, val, low);
break;
}
val = dstate_getinfo("battery.runtime");
low = dstate_getinfo("battery.runtime.low");
if (val && low && (strtol(val, NULL, 10) < strtol(low, NULL, 10))) {
snprintfcat(status_buf, sizeof(status_buf), " LB");
upsdebugx(2, "%s: appending LB flag [runtime '%s' below '%s']", __func__, val, low);
break;
}
/* LB condition not detected */
break;
}
if (alarm_active) {
dstate_setinfo("ups.status", "ALARM %s", status_buf);
} else {
dstate_setinfo("ups.status", "%s", status_buf);
}
}
void sec_setinfo(int varnum, char *value)
{
if (*sec_varlist[varnum].setcmd){/*Not empty*/
if (sec_varlist[varnum].flags == FLAG_STRING) {
dstate_setinfo(sec_varlist[varnum].setcmd,"%s", value);
}
else if (sec_varlist[varnum].unit == 1) {
dstate_setinfo(sec_varlist[varnum].setcmd,"%s", value);
}
else if (sec_varlist[varnum].flags == FLAG_MULTI) {
if (atoi(value) < 0) {
dstate_setinfo(sec_varlist[varnum].setcmd,"0");
}
else
{dstate_setinfo(sec_varlist[varnum].setcmd,"%d", atoi(value) * sec_varlist[varnum].unit);
}
}
else {
dstate_setinfo(sec_varlist[varnum].setcmd,"%.1f", atof(value) / sec_varlist[varnum].unit);}
}
}
void update_charge_source_status()
{
if( (buf[CHARGE_SOURCE]) == '0'){
dstate_setinfo("charge.solar", "%s","OFF"); //charge on mains
}
else
dstate_setinfo("charge.solar", "%s","ON"); //charge on solar
}
void upsdrv_initinfo(void)
{
dstate_setinfo("ups.mfr", "%s", "PACE");
dstate_setinfo("ups.model", "PACE %s", "UPS7");
printf("Detected %s %s on %s\n", dstate_getinfo("ups.mfr"),
dstate_getinfo("ups.model"), device_path);
}
void upsdrv_initinfo(void)
{
dstate_setinfo("ups.mfr", "%s", "Richcomm dry-contact to USB solution");
dstate_setinfo("ups.model", "%s", usbdevice.Product ? usbdevice.Product : "unknown");
dstate_setinfo("ups.serial", "%s", usbdevice.Serial ? usbdevice.Serial : "unknown");
dstate_setinfo("ups.vendorid", "%04x", usbdevice.VendorID);
dstate_setinfo("ups.productid", "%04x", usbdevice.ProductID);
}
void upsdrv_initinfo(void)
{
/* try to detect the UPS here - call fatal_with_errno(EXIT_FAILURE, ) if it fails */
char device_name[80] = "";
CFStringRef device_type_cfstr, device_name_cfstr;
CFPropertyListRef power_dictionary;
CFNumberRef max_capacity;
upsdebugx(1, "upsdrv_initinfo()");
dstate_setinfo("device.mfr", "(unknown)");
power_dictionary = copy_power_dictionary(g_power_key);
device_type_cfstr = CFDictionaryGetValue(power_dictionary, CFSTR(kIOPSTypeKey));
if(device_type_cfstr && !CFStringCompare(device_type_cfstr, CFSTR(kIOPSInternalBatteryType), 0)) {
dstate_setinfo("device.type", "battery");
}
upsdebugx(2, "Getting 'Name' key");
device_name_cfstr = CFDictionaryGetValue(power_dictionary, CFSTR(kIOPSNameKey));
if (!device_name_cfstr) {
fatalx(EXIT_FAILURE, "Couldn't retrieve 'Name' key from power dictionary.");
}
CFRetain(device_name_cfstr);
CFStringGetCString(device_name_cfstr, device_name, sizeof(device_name), kCFStringEncodingUTF8);
upsdebugx(2, "Got name: %s", device_name);
CFRelease(device_name_cfstr);
dstate_setinfo("device.model", "%s", device_name);
max_capacity = CFDictionaryGetValue(power_dictionary, CFSTR(kIOPSMaxCapacityKey));
if(max_capacity) {
CFRetain(max_capacity);
CFNumberGetValue(max_capacity, kCFNumberDoubleType, &max_capacity_value);
CFRelease(max_capacity);
upsdebugx(3, "Max Capacity = %.f units (usually 100)", max_capacity_value);
if(max_capacity_value != 100) {
upsdebugx(1, "Max Capacity: %f != 100", max_capacity_value);
}
}
/* upsh.instcmd = instcmd; */
CFRelease(power_dictionary);
}
void upsdrv_updateinfo(void)
{
static int retry = 0;
if (blazer_status(command[proto].status)) {
if (retry < MAXTRIES) {
upsdebugx(1, "Communications with UPS lost: status read failed!");
retry++;
} else if (retry == MAXTRIES) {
upslogx(LOG_WARNING, "Communications with UPS lost: status read failed!");
retry++;
} else {
dstate_datastale();
}
return;
}
if (getval("runtimecal")) {
time_t now;
time(&now);
if (online) { /* OL */
batt.runt.est += batt.runt.nom * difftime(now, lastpoll) / batt.chrg.time;
if (batt.runt.est > batt.runt.nom) {
batt.runt.est = batt.runt.nom;
}
} else { /* OB */
batt.runt.est -= load.eff * difftime(now, lastpoll);
if (batt.runt.est < 0) {
batt.runt.est = 0;
}
}
dstate_setinfo("battery.charge", "%.0f", 100 * batt.runt.est / batt.runt.nom);
dstate_setinfo("battery.runtime", "%.0f", batt.runt.est / load.eff);
lastpoll = now;
}
if (retry > MAXTRIES) {
upslogx(LOG_NOTICE, "Communications with UPS re-established");
}
retry = 0;
dstate_dataok();
}
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;
}
/* 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)
{
char *page, *last = NULL;
char buf[SMALLBUF];
snprintf(buf, sizeof(buf), "%s", subdriver->initinfo);
for (page = strtok_r(buf, " ", &last); page != NULL; page = strtok_r(NULL, " ", &last)) {
if (netxml_get_page(page) != NE_OK) {
continue;
}
dstate_setinfo("driver.version.data", "%s", subdriver->version);
if (testvar("subscribe") && (netxml_alarm_subscribe(subdriver->subscribe) == NE_OK)) {
extrafd = ne_sock_fd(sock);
time(&lastheard);
}
/* Register r/w variables */
vname_register_rw();
/* Set UPS driver handler callbacks */
upsh.setvar = &setvar;
upsh.instcmd = &instcmd;
return;
}
fatalx(EXIT_FAILURE, "%s: communication failure [%s]", __func__, ne_get_error(session));
}
void update_err_status()
{
int i;
int x;
char data[2];
for(i=0;i<ERR_LEN;i++)
{
data[i] = buf[ERR_STATUS+i];
}
data[i] = '\0';
x = atoi(data);
if(x==0)
dstate_setinfo("error.status", "%d",0); //No error
else
dstate_setinfo("error.status", "%d",x); //update error code
}
static int upsc_getvalue(const char *cmd, const char *param,
const char *resp, const char *nutvar, char *ret)
{
char var[UPSC_BUFLEN];
char val[UPSC_BUFLEN];
upsdebugx(2, "Request value: %s %s", cmd, param ? param : "\"\"");
upscsend(cmd);
if (param)
upscsend(param);
upscrecv(var);
upscrecv(val);
upsdebugx(2, "Got value: %s %s", var, val);
if (strcmp(var, resp)) {
upslogx(LOG_ERR, "Bad response to %s %s: %s %s",
cmd, param ? param : "\"\"", var, val);
return 0;
}
else {
if (nutvar)
dstate_setinfo(nutvar, "%s", val);
if (ret)
strcpy(ret, val);
}
return 1;
}
/* Convert the local status information to NUT format and set NUT
status. */
static void netxml_status_set(void)
{
if (STATUS_BIT(VRANGE)) {
dstate_setinfo("input.transfer.reason", "input voltage out of range");
} else if (STATUS_BIT(FRANGE)) {
dstate_setinfo("input.transfer.reason", "input frequency out of range");
} else {
dstate_delinfo("input.transfer.reason");
}
if (STATUS_BIT(ONLINE)) {
status_set("OL"); /* on line */
} else {
status_set("OB"); /* on battery */
}
if (STATUS_BIT(DISCHRG)) {
status_set("DISCHRG"); /* discharging */
}
if (STATUS_BIT(CHRG)) {
status_set("CHRG"); /* charging */
}
if (STATUS_BIT(LOWBATT)) {
status_set("LB"); /* low battery */
}
if (STATUS_BIT(OVERLOAD)) {
status_set("OVER"); /* overload */
}
if (STATUS_BIT(REPLACEBATT)) {
status_set("RB"); /* replace batt */
}
if (STATUS_BIT(TRIM)) {
status_set("TRIM"); /* SmartTrim */
}
if (STATUS_BIT(BOOST)) {
status_set("BOOST"); /* SmartBoost */
}
if (STATUS_BIT(BYPASSAUTO) || STATUS_BIT(BYPASSMAN)) {
status_set("BYPASS"); /* on bypass */
}
if (STATUS_BIT(OFF)) {
status_set("OFF"); /* ups is off */
}
if (STATUS_BIT(SHUTDOWNIMM)) {
status_set("FSD"); /* shutdown imminent */
}
}
static int setvar(const char *varname, const char *val)
{
if (!strcasecmp(varname, "battery.charge.low")) {
battery.charge.low = strtod(val, NULL);
dstate_setinfo("battery.charge.low", "%g", battery.charge.low);
return STAT_SET_HANDLED;
}
if (!strcasecmp(varname, "battery.runtime.low")) {
battery.runtime.low = strtod(val, NULL);
dstate_setinfo("battery.runtime.low", "%g", battery.runtime.low);
return STAT_SET_HANDLED;
}
upslogx(LOG_NOTICE, "setvar: unknown variable [%s]", varname);
return STAT_SET_UNKNOWN;
}
void upsdrv_updateinfo(void)
{
if (ivt_status() < 7) {
dstate_datastale();
return;
}
dstate_setinfo("battery.voltage", "%.2f", battery.voltage.act);
dstate_setinfo("battery.voltage.minimum", "%.2f", battery.voltage.min);
dstate_setinfo("battery.voltage.maximum", "%.2f", battery.voltage.max);
dstate_setinfo("battery.current", "%.1f", battery.current.act);
dstate_setinfo("battery.current.minimum", "%.1f", battery.current.min);
dstate_setinfo("battery.current.maximum", "%.1f", battery.current.max);
dstate_setinfo("battery.temperature", "%.0f", battery.temperature);
status_init();
if (battery.current.act > 0) {
status_set("OL"); /* charging */
} else {
status_set("OB"); /* discharging */
}
if (battery.voltage.act < battery.voltage.low) {
status_set("LB");
}
status_commit();
dstate_dataok();
}
void upsdrv_initinfo(void)
{
char *tmp;
tmp = getval("mfr");
if (!tmp)
dstate_setinfo("ups.mfr", "Liebert");
else
dstate_setinfo("ups.mfr", "%s", tmp);
tmp = getval("model");
if (!tmp)
dstate_setinfo("ups.model", "MultiLink");
else
dstate_setinfo("ups.model", "%s", tmp);
}
static int get_identification(void) {
char response[MAX_RESPONSE_LENGTH];
if (do_command(POLL, IDENTIFICATION, "", response) >= 0) {
dstate_setinfo("ups.id", "%s", response);
return 1;
}
return 0;
}
int upsdrv_initups(void)
{
/* check the running mode... */
if (strchr(device_path, '@'))
{
upsdebugx(1, "Repeater mode");
mode = MODE_REPEATER;
dstate_setinfo("driver.parameter.mode", "repeater");
/* FIXME: if there is at least one more => MODE_META... */
}
else
{
upsdebugx(1, "Dummy (simulation) mode");
mode = MODE_DUMMY;
dstate_setinfo("driver.parameter.mode", "dummy");
}
return 1;
}
/* write the status_buf into the info array */
void alarm_commit(void)
{
if (strlen(alarm_buf) > 0) {
dstate_setinfo("ups.alarm", "%s", alarm_buf);
alarm_active = 1;
} else {
dstate_delinfo("ups.alarm");
alarm_active = 0;
}
}
static int setvar(const char *varname, const char *val)
{
dummy_info_t *item;
upsdebugx(2, "entering setvar(%s, %s)", varname, val);
/* FIXME: the below is only valid if (mode == MODE_DUMMY)
* if (mode == MODE_REPEATER) => forward
* if (mode == MODE_META) => ?
*/
if (!strncmp(varname, "ups.status", 10))
{
status_init();
/* FIXME: split and check values (support multiple values), à la usbhid-ups */
status_set(val);
status_commit();
return STAT_SET_HANDLED;
}
/* Check variable validity */
if (!is_valid_data(varname))
{
upsdebugx(2, "setvar: invalid variable name (%s)", varname);
return STAT_SET_UNKNOWN;
}
/* Check value validity */
if (!is_valid_value(varname, val))
{
upsdebugx(2, "setvar: invalid value (%s) for variable (%s)", val, varname);
return STAT_SET_UNKNOWN;
}
/* If value is empty, remove the variable (FIXME: do we need
* a magic word?) */
if (strlen(val) == 0)
{
dstate_delinfo(varname);
}
else
{
dstate_setinfo(varname, "%s", val);
if ( (item = find_info(varname)) != NULL)
{
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);
}
}
return STAT_SET_HANDLED;
}
static void upsc_getbaseinfo(void)
{
char *buf;
dstate_setinfo("ups.mfr", "%s",
((buf = getval("manufacturer")) != NULL) ? buf : "unknown");
if (!upsc_getvalue("UPTP", NULL, "NNAME", "ups.model", NULL))
upsc_getvalue("UPTP", NULL, "NNAME", "ups.model", NULL);
upsc_getvalue("UPSN", "0", "ACSN", "ups.serial", NULL);
}
void upsdrv_initinfo(void)
{
char *s;
dstate_setinfo("ups.mfr", "CyberPower");
dstate_setinfo("ups.model", "[unknown]");
dstate_setinfo("ups.serial", "[unknown]");
subdriver[mode]->initinfo();
/*
* Allow to override the following parameters
*/
if ((s = getval("manufacturer")) != NULL) {
dstate_setinfo("ups.mfr", "%s", s);
}
if ((s = getval("model")) != NULL) {
dstate_setinfo("ups.model", "%s", s);
}
if ((s = getval("serial")) != NULL) {
dstate_setinfo("ups.serial", "%s", s);
}
upsh.instcmd = subdriver[mode]->instcmd;
upsh.setvar = subdriver[mode]->setvar;
}
void upsdrv_updateinfo(void)
{
int r;
int x,i=0,j,k,value;
float value1;
char ch;
char data[10];
int data_position = 4;
test_EOL();
x= ser_get_buf_len(upsfd,buf, 64, SER_WAIT_SEC,SER_WAIT_USEC);
printf("reading status is %d\n",x);
printf("the reading data is %s\n",buf);
ser_comm_good();
r = test_CMD();
if(r != TRUE){
printf("command error\n");
return;
}
i = data_position;
for(j =0;j< _countof(pacefield);j++)
{
for(k=0;k<pacefield[j].len;k++)
{
data[k] = buf[i+k];
}
data[k] = '\0';
printf("the reading data is %s\n",data);
value = atoi(data);
value1 = (float)value/pacefield[j].divident;
printf("value 1 = %f\n",value1);
dstate_setinfo(pacefield[j].name, "%0.2f",value1);
i = i+pacefield[j].len;
}
status_init();
update_err_status();
update_charge_source_status();
update_inverter_status();
update_battery_status();
update_load_status();
update_battery_charge_dchrg_status();
status_commit();
dstate_dataok();
}
static int get_transfer_voltage_high(void) {
char response[MAX_RESPONSE_LENGTH];
char *ptr;
if (do_command(POLL, TRANSFER_VOLTAGE, "", response) > 0) {
ptr = field(response, 1);
if (ptr)
dstate_setinfo("input.transfer.high", "%d", atoi(ptr));
return 1;
}
return 0;
}
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;
}
static int blazer_rating(const char *cmd)
{
const struct {
const char *var;
const char *fmt;
double (*conv)(const char *, char **);
} rating[] = {
{ "input.voltage.nominal", "%.0f", strtod },
{ "input.current.nominal", "%.1f", strtod },
{ "battery.voltage.nominal", "%.1f", blazer_packs },
{ "input.frequency.nominal", "%.0f", strtod },
{ NULL }
};
char buf[SMALLBUF], *val, *last = NULL;
int i;
/*
* > [F\r]
* < [#220.0 000 024.0 50.0\r]
* 0123456789012345678901
* 0 1 2
*/
if (blazer_command(cmd, buf, sizeof(buf)) < 22) {
upsdebugx(2, "%s: short reply", __func__);
return -1;
}
if (buf[0] != '#') {
upsdebugx(2, "%s: invalid start character [%02x]", __func__, buf[0]);
return -1;
}
for (i = 0, val = strtok_r(buf+1, " ", &last); rating[i].var; i++, val = strtok_r(NULL, " \r\n", &last)) {
if (!val) {
upsdebugx(2, "%s: parsing failed", __func__);
return -1;
}
if (strspn(val, "0123456789.") != strlen(val)) {
upsdebugx(2, "%s: non numerical value [%s]", __func__, val);
continue;
}
dstate_setinfo(rating[i].var, rating[i].fmt, rating[i].conv(val, NULL));
}
return 0;
}
static int instcmd(const char *cmdname, const char *extra)
{
const char *val;
val = dstate_getinfo(getval("load.status"));
if (val) {
if (!strcasecmp(val, "off") || !strcasecmp(val, "no")) {
outlet = 0;
}
if (!strcasecmp(val, "on") || !strcasecmp(val, "yes")) {
outlet = 1;
}
}
if (!strcasecmp(cmdname, "shutdown.return")) {
if (outlet && (ups.timer.shutdown < 0)) {
ups.timer.shutdown = offdelay;
dstate_setinfo("ups.status", "FSD %s", ups.status);
}
ups.timer.start = ondelay;
return STAT_INSTCMD_HANDLED;
}
if (!strcasecmp(cmdname, "shutdown.stayoff")) {
if (outlet && (ups.timer.shutdown < 0)) {
ups.timer.shutdown = offdelay;
dstate_setinfo("ups.status", "FSD %s", ups.status);
}
ups.timer.start = -1;
return STAT_INSTCMD_HANDLED;
}
upslogx(LOG_NOTICE, "instcmd: unknown command [%s]", cmdname);
return STAT_INSTCMD_UNKNOWN;
}
static int get_sensitivity(void) {
char response[MAX_RESPONSE_LENGTH];
unsigned int i;
if (do_command(POLL, VOLTAGE_SENSITIVITY, "", response) <= 0)
return 0;
for (i = 0; i < sizeof(sensitivity) / sizeof(sensitivity[0]); i++) {
if (sensitivity[i].code == atoi(response)) {
dstate_setinfo("input.sensitivity", "%s",
sensitivity[i].name);
return 1;
}
}
return 0;
}
