static void sync_serial(void) {
char buffer[10];
ser_send(upsfd, "\r");
ser_get_line(upsfd, buffer, sizeof(buffer), '\r', "\012", 3, 0);
ser_get_line(upsfd, buffer, sizeof(buffer), ENDCHAR, IGNCHARS, 3, 0);
while (ser_get_line(upsfd, buffer, sizeof(buffer), '>', "\012", 3, 0) <= 0) {
ser_send(upsfd, "\r");
}
}
int SetOutputAllow(const char* lowval, const char* highval)
{
char buffer[32];
snprintf(buffer, 4, "%.3s", lowval);
/*the UPS wants this value to always be three characters long*/
/*so put a zero in front of the string, if needed.... */
if (strlen(buffer) < 3)
{
buffer[3] = '\0';
buffer[2] = buffer[1];
buffer[1] = buffer[0];
buffer[0] = '0';
}
upsdebugx (2,"SetOutputAllow sending %s%.3s,%.3s...",
SETX_OUT_ALLOW, buffer, highval);
ser_send(upsfd,"%s%.3s,%.3s%s", SETX_OUT_ALLOW, buffer, highval,
COMMAND_END);
ser_get_line(upsfd,buffer,sizeof(buffer), ENDCHAR, IGNCHARS,SECS,USEC);
if(buffer[0] == DONT_UNDERSTAND)
{
upsdebugx (2,"SetOutputAllow got asterisk back...");
return 1; /* Invalid command */
}
return 0; /* Valid command */
}
void setup_serial(const char *port)
{
char temp[140];
int i,ret;
/* Detect the ups baudrate */
for (i=0; i<5; i++) {
ser_set_speed(upsfd, device_path,baud_rates[i].rate);
ret = ser_send(upsfd, "^P003MAN");
ret = sec_upsrecv(temp);
if (ret >= -1) break;
}
if (i == 5) {
printf("Can't talk to UPS on port %s!\n",port);
printf("Check the cabling and portname and try again\n");
printf("Please note that this driver only support UPS Models with SEC Protorol\n");
ser_close(upsfd, device_path);
exit (1);
}
printf("Connected to UPS on %s baudrate: %d\n",port, baud_rates[i].name);
}
void writeByte(uint8_t byte)
{
#ifndef Q_OS_WIN32
ser_send(&portFD, &byte, 1);
#else
_port->write((const char *)&byte, 1);
#endif
}
//call by other if for output data to CR (for CR or transpass)
void st_send_to_st(unsigned char* data, short dlen)
{
if((!st_path)&&(!st_len)) //pass data to software ST
{
memcpy(st_buf, data, dlen);
st_len=dlen;
}
else if(st_path>0) ser_send(data); //pass data to external ST
}
static inline void parport_write_data(void)
{
uint8_t output;
output = dataport_value ^ cable->OUTPUT_INVERT;
//printf("parport_write_data 0x%02X\n",output);
ser_send(output);
}
static int instcmd(const char *cmdname, const char *extra)
{
if (!strcasecmp(cmdname, "reset.input.minmax")) {
ser_send(upsfd, "L");
return STAT_INSTCMD_HANDLED;
}
upslogx(LOG_NOTICE, "instcmd: unknown command [%s]", cmdname);
return STAT_INSTCMD_UNKNOWN;
}
static int execute(const char *cmd, char *result, int resultsize)
{
int ret;
char buf[256];
ser_send(upsfd, "%s", cmd);
ser_get_line(upsfd, buf, sizeof(buf), '\012', "", 3, 0);
ret = ser_get_line(upsfd, result, resultsize, '\015', "\012", 3, 0);
ser_get_line(upsfd, buf, sizeof(buf), '>', "", 3, 0);
return ret;
}
/*
* Generic command processing function. Send a command and read a reply.
* Returns < 0 on error, 0 on timeout and the number of bytes read on
* success.
*/
int blazer_command(const char *cmd, char *buf, size_t buflen)
{
#ifndef TESTING
int ret;
ser_flush_io(upsfd);
ret = ser_send(upsfd, "%s", cmd);
if (ret <= 0) {
upsdebugx(3, "send: %s", ret ? strerror(errno) : "timeout");
return ret;
}
upsdebugx(3, "send: '%.*s'", (int)strcspn(cmd, "\r"), cmd);
ret = ser_get_buf(upsfd, buf, buflen, SER_WAIT_SEC, 0);
if (ret <= 0) {
upsdebugx(3, "read: %s", ret ? strerror(errno) : "timeout");
return ret;
}
upsdebugx(3, "read: '%.*s'", (int)strcspn(buf, "\r"), buf);
return ret;
#else
const struct {
const char *cmd;
const char *answer;
} testing[] = {
{ "Q1\r", "(215.0 195.0 230.0 014 49.0 2.27 30.0 00101000\r" },
{ "F\r", "#230.0 000 024.0 50.0\r" },
{ "I\r", "#NOT_A_LIVE_UPS TESTING TESTING \r" },
{ NULL }
};
int i;
memset(buf, 0, buflen);
for (i = 0; cmd && testing[i].cmd; i++) {
if (strcasecmp(cmd, testing[i].cmd)) {
continue;
}
return snprintf(buf, buflen, "%s", testing[i].answer);
}
return snprintf(buf, buflen, "%s", testing[i].cmd);
#endif
}
//call by ST procedures for output data to other if
void st_send(unsigned char* data, short dlen)
{
unsigned char type=data[0]&TYPE_MASK;
if(!st_path) //process data from software ST
{
switch(type)
{ //ST cannot output any data to TR!!!
case TYPE_UI:{ui_send_to_ui(data, dlen);break;} //data will be passed to UI
case TYPE_CR:{cr_send_to_cr(data, dlen);} //data will be passed to CR
}
}
else if(st_path<0) ser_send(data); //pass data to external torfone from this ST
}
void main ()
{
char
taip [80];
static char
rbuf [BUFSIZ], tbuf [BUFSIZ];
int
done, pid, chr;
printf ("\n");
printf (" Sample TAIP Query/Response Program\n");
printf (" Copyright Trimble Navigation 1992\n");
printf (" Version %s\n\n", VERSION);
/*
* Configure COM1
*/
pid = 0;
SIO_Open (NULL);
SIO_IntOpen (0, 8+4, -1, NULL);
SIO_PortOpen (pid, 0x3f8, 0, HS_DTR | HS_RTS | HS_CTS, NULL);
SIO_PortMode (pid, 4800L, 8, NOPARITY, ONEBIT, ONEBIT, NULL);
SIO_RxOpen (pid, rbuf, (long)BUFSIZ, HS_NONE, NULL);
SIO_TxOpen (pid, tbuf, (long)BUFSIZ, HS_NONE, NULL);
printf (" Serial Parameters: COM1, 4800 Baud, 8 data bits, 1 stop bit, no parity\n\n");
printf (" Press <Enter> to Poll for a PV packet\n");
printf (" Press <Escape> to quit\n");
for (done = FALSE; !done; ) { /* While not done... */
while (SIO_RxGet (pid, &chr) == 0) { /* While characters coming in */
taip_byte (chr); /* send them to the TAIP decoder */
}
if (kbhit ()) { /* if keyboard is hit... */
switch (getch ()) { /* get key and switch() */
case 27: /* <Escape>, Quit */
done = TRUE;
break;
case '\r': /* <Enter>, Poll for a PV packet */
fmt_taip (taip, "QPV"); /* format a TAIP packet */
ser_send (0, taip, strlen (taip)); /* send it */
printf ("\nSend: %s\n", taip); /* print it */
break;
}
}
}
SIO_Close (0); /* Shutdown serial ports */
}
static int parport_read(void)
{
int data = 0;
//printf("parport_read\n");
ser_send(0xFF);
data=ser_read();
if ((data ^ cable->INPUT_INVERT) & cable->TDO_MASK)
return 1;
else
return 0;
}
void do_battery_test(void)
{
char buffer[32];
if (getval("testtime") == NULL)
snprintf(buffer, 3, "%s", DEFAULT_BAT_TEST_TIME);
else {
snprintf(buffer, 3, "%s", getval("testtime"));
/*the UPS wants this value to always be two characters long*/
/*so put a zero in front of the string, if needed.... */
if (strlen(buffer) < 2) {
buffer[2] = '\0';
buffer[1] = buffer[0];
buffer[0] = '0';
}
}
ser_send(upsfd,"%s%s%s",BAT_TEST_PREFIX,buffer,COMMAND_END);
}
int sec_cmd(const char mode, const char *command, char *msgbuf, int *buflen)
{
char msg[140];
int ret;
memset(msg, 0, sizeof(msg));
/* create the message string */
if (*buflen > 0) {
snprintf(msg, sizeof(msg), "%c%c%03d%s%s", SEC_MSG_STARTCHAR,
mode, (*buflen)+3, command, msgbuf);
}
else {
snprintf(msg, sizeof(msg), "%c%c003%s", SEC_MSG_STARTCHAR,
mode, command);
}
upsdebugx(1, "PC-->UPS: \"%s\"",msg);
ret = ser_send(upsfd, "%s", msg);
upsdebugx(1, " send returned: %d",ret);
if (ret == -1) return -1;
ret = sec_upsrecv(msg);
if (ret < 0) return -1;
if (ret >= 0) {
strncpy(msgbuf, msg, ret);
upsdebugx(1, "UPS<--PC: \"%s\"",msg);
}
/* *(msgbuf+ret) = '\0';*/
*buflen = ret;
return ret;
}
void upsdrv_updateinfo(void)
{
static int CommTry = COMM_TRIES; /* Comm loss counter */
char buffer[256]; /* Main response buffer */
char buffer2[32]; /* Conversion buffer */
char s;
int RetValue;
int timevalue;
/* Start with EG/ON information */
ser_flush_in(upsfd,"",0); /*just in case*/
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 != 0) && (CommTry == 0))
{
ser_comm_fail("Oneac UPS Comm failure continues on port %s",
device_path);
}
else if (RetValue != 0)
{
if (--CommTry == 0)
{
ser_comm_fail("Oneac UPS Comm failure on port %s",device_path);
dstate_datastale();
}
upsdebugx(2,"Oneac: Update serial comm retry value: %d", CommTry);
return;
}
else
{
CommTry = COMM_TRIES; /* Reset serial retries */
s = buffer[12];
status_init();
alarm_init();
/*take care of the UPS status information*/
if (s == '@')
{
status_set("OL");
}
else
{
if (s & 0x01) /* On Battery */
{
status_set("OB");
}
else
{
status_set("OL");
}
if (s & 0x02) /* Low Battery */
status_set("LB");
if (s & 0x04) /* General fault */
{
dstate_setinfo("ups.test.result","UPS Internal Failure");
}
else
{
dstate_setinfo("ups.test.result","Normal");
}
if (s & 0x08) /* Replace Battery */
status_set("RB");
/* if (s & 0x10) */ /* High Line */
if (s & 0x20) /* Unit is hot */
alarm_set("OVERHEAT");
}
/*take care of the reason why the UPS last transferred to battery*/
switch (buffer[13]) {
case XFER_BLACKOUT :
dstate_setinfo("input.transfer.reason", "Blackout");
break;
case XFER_LOW_VOLT :
dstate_setinfo("input.transfer.reason",
"Low Input Voltage");
break;
case XFER_HI_VOLT :
dstate_setinfo("input.transfer.reason",
"High Input Voltage");
break;
case NO_VALUE_YET :
dstate_setinfo("input.transfer.reason",
"No transfer yet.");
break;
default :
upslogx(LOG_INFO,"Oneac: Unknown reason for UPS battery"
" transfer [%c]", buffer[13]);
}
/* now update info for only the non-EG families of UPS*/
if (strncmp(UpsFamily, FAMILY_EG, FAMILY_SIZE) != 0)
{
dstate_setinfo("ups.load", "0%.2s",buffer+31);
/* Output ON or OFF? */
if(buffer[27] == NO_VALUE_YET)
status_set("OFF");
/*battery charge*/
if(buffer[10] == YES)
dstate_setinfo("battery.charge", "0%.2s",buffer+33);
else
dstate_setinfo("battery.charge", "100");
EliminateLeadingZeroes (buffer+35, 3, buffer2, sizeof(buffer2));
dstate_setinfo("input.voltage", "%s",buffer2);
EliminateLeadingZeroes (buffer+38, 3, buffer2, sizeof(buffer2));
dstate_setinfo("input.voltage.minimum", "%s",buffer2);
EliminateLeadingZeroes (buffer+41, 3, buffer2, sizeof(buffer2));
dstate_setinfo("input.voltage.maximum", "%s",buffer2);
EliminateLeadingZeroes (buffer+44, 3, buffer2, sizeof(buffer2));
dstate_setinfo("output.voltage", "%s",buffer2);
if (buffer[15] == NO_VALUE_YET)
{
dstate_delinfo("ups.timer.shutdown");
}
else
{
/* A shutdown is underway! */
status_set("FSD");
if(buffer[15] != HIGH_COUNT)
{
EliminateLeadingZeroes (buffer+15, 3, buffer2,
sizeof(buffer2));
dstate_setinfo("ups.timer.shutdown", "%s", buffer2);
}
else
{
dstate_setinfo("ups.timer.shutdown", "999");
}
}
if (buffer[47] == YES)
status_set("BOOST");
}
/* Now update info for only the OZ/OB families of UPS */
if ((strncmp(UpsFamily, FAMILY_OZ, FAMILY_SIZE) == 0) ||
(strncmp(UpsFamily, FAMILY_OB, FAMILY_SIZE) == 0))
{
ser_flush_in(upsfd,"",0); /*just in case*/
ser_send (upsfd,"%c%s",GETX_ALL_1,COMMAND_END);
RetValue = OneacGetResponse (buffer, sizeof(buffer),
GETX_ALL1_RESP_SIZE);
if(RetValue)
{
if (--CommTry == 0)
{
ser_comm_fail("Oneac (OZ) UPS Comm failure on port %s",
device_path);
dstate_datastale();
}
upsdebugx(2,"Oneac: "
"Update (OZ) serial comm retry value: %d", CommTry);
}
else
{
CommTry = COMM_TRIES; /* Reset count */
EliminateLeadingZeroes (buffer+57, 5, buffer2, sizeof(buffer2));
dstate_setinfo("ups.realpower", "%s",buffer2);
dstate_setinfo("input.frequency", "%.2s.%c",
buffer+42,buffer[44]);
dstate_setinfo("output.frequency", "%.2s.%c",
buffer+76, buffer[78]);
EliminateLeadingZeroes (buffer+29, 3, buffer2, sizeof(buffer2));
dstate_setinfo("battery.voltage", "%s.%c",buffer2, buffer[32]);
dstate_setinfo("ups.temperature", "%.2s",buffer+13);
dstate_setinfo("ups.load", "%.3s",buffer+73);
strncpy(buffer2, buffer+19, 4);
buffer2[4]='\0';
timevalue = atoi(buffer2) * 60; /* Change mins to secs */
dstate_setinfo("battery.runtime", "%d",timevalue);
/* Now some individual requests... */
/* Battery replace date */
ser_send (upsfd,"%c%s",GETX_BATT_REPLACED,COMMAND_END);
if(!OneacGetResponse (buffer, sizeof(buffer),
GETX_DATE_RESP_SIZE))
dstate_setinfo("battery.date", "%.6s (yymmdd)", buffer);
/* Low and high output trip points */
ser_send (upsfd,"%c%s",GETX_LOW_OUT_ALLOW,COMMAND_END);
if(!OneacGetResponse (buffer, sizeof(buffer),
GETX_ALLOW_RESP_SIZE))
{
EliminateLeadingZeroes (buffer, 3, buffer2,sizeof(buffer2));
dstate_setinfo("input.transfer.low", "%s", buffer2);
}
ser_send (upsfd,"%c%s",GETX_HI_OUT_ALLOW,COMMAND_END);
if(!OneacGetResponse (buffer, sizeof(buffer),
GETX_ALLOW_RESP_SIZE))
dstate_setinfo("input.transfer.high", "%s", buffer);
/* Restart delay */
ser_send (upsfd,"%c%s",GETX_RESTART_DLY,COMMAND_END);
if(!OneacGetResponse (buffer, sizeof(buffer),
GETX_RSTRT_RESP_SIZE))
{
EliminateLeadingZeroes (buffer, 4, buffer2,
sizeof(buffer2));
dstate_setinfo("ups.delay.start", "%s", buffer2);
}
/* Buzzer state */
ser_send (upsfd,"%s%s",GETX_BUZZER_WHAT,COMMAND_END);
if(!OneacGetResponse (buffer, sizeof(buffer), 1))
{
switch (buffer[0])
{
case BUZZER_ENABLED :
dstate_setinfo("ups.beeper.status", "enabled");
break;
case BUZZER_DISABLED :
dstate_setinfo("ups.beeper.status", "disabled");
break;
case BUZZER_MUTED :
dstate_setinfo("ups.beeper.status", "muted");
break;
default :
dstate_setinfo("ups.beeper.status", "enabled");
}
}
/* Auto start setting */
ser_send (upsfd,"%s%s",GETX_AUTO_START,COMMAND_END);
if(!OneacGetResponse (buffer, sizeof(buffer), 1))
{
if (buffer[0] == '0')
dstate_setinfo("ups.start.auto", "yes");
else
dstate_setinfo("ups.start.auto", "no");
}
/* Low Batt at time */
ser_send (upsfd,"%c%s",GETX_LOW_BATT_TIME,COMMAND_END);
if(!OneacGetResponse (buffer, sizeof(buffer), 2))
{
strncpy(buffer2, buffer, 2);
buffer2[2]='\0';
timevalue = atoi(buffer2) * 60; /* Mins to secs */
dstate_setinfo("battery.runtime.low", "%d",timevalue);
}
/* Shutdown timer */
ser_send (upsfd,"%c%s",GETX_SHUTDOWN,COMMAND_END);
if(!OneacGetResponse (buffer, sizeof(buffer),
GETX_SHUTDOWN_RESP_SIZE))
{
/* ON would have handled NO_VALUE_YET and setting FSD
* above so only deal with counter value here.
*/
if (buffer[0] != NO_VALUE_YET)
{
EliminateLeadingZeroes (buffer, 5, buffer2,
sizeof(buffer2));
dstate_setinfo("ups.timer.shutdown", "%s", buffer2);
}
}
/* Restart timer */
ser_send (upsfd,"%s%s",GETX_RESTART_COUNT,COMMAND_END);
if(!OneacGetResponse (buffer, sizeof(buffer),
GETX_RSTRT_RESP_SIZE))
{
if (atoi(buffer) == 0)
{
dstate_delinfo("ups.timer.start");
}
else
{
EliminateLeadingZeroes (buffer, 4, buffer2,
sizeof(buffer2));
dstate_setinfo("ups.timer.start", "%s", buffer2);
}
}
}
}
alarm_commit();
status_commit();
/* If the comm retry counter is zero then datastale has been set.
* We don't want to set dataok or ser_comm_good if that is the case.
*/
if (CommTry != 0)
{
dstate_dataok();
ser_comm_good();
}
}
}
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_shutdown(void)
{
ser_send(upsfd,"%s",SHUTDOWN);
}
int instcmd(const char *cmdname, const char *extra)
{
int i;
upsdebugx(2, "In instcmd with %s and extra %s.", cmdname, extra);
if (!strcasecmp(cmdname, "test.failure.start")) {
ser_send(upsfd,"%s%s",SIM_PWR_FAIL,COMMAND_END);
return STAT_INSTCMD_HANDLED;
}
if (!strcasecmp(cmdname, "shutdown.return")) {
i = atoi(dstate_getinfo("ups.delay.shutdown"));
if ((strncmp (UpsFamily, FAMILY_OZ, FAMILY_SIZE) == 0) ||
(strncmp (UpsFamily, FAMILY_OB, FAMILY_SIZE) == 0))
{
upsdebugx(3, "Shutdown using %c%d...", DELAYED_SHUTDOWN_PREFIX, i);
ser_send(upsfd,"%c%d%s",DELAYED_SHUTDOWN_PREFIX, i, COMMAND_END);
}
else
{
upsdebugx(3, "Shutdown using %c%03d...",DELAYED_SHUTDOWN_PREFIX, i);
ser_send(upsfd,"%c%03d%s",DELAYED_SHUTDOWN_PREFIX, i, COMMAND_END);
}
return STAT_INSTCMD_HANDLED;
}
if(!strcasecmp(cmdname, "shutdown.reboot")) {
ser_send(upsfd, "%s", SHUTDOWN);
return STAT_INSTCMD_HANDLED;
}
if (!strcasecmp(cmdname, "shutdown.stop")) {
ser_send(upsfd,"%c%s",DELAYED_SHUTDOWN_PREFIX,COMMAND_END);
return STAT_INSTCMD_HANDLED;
}
if (!strcasecmp(cmdname, "test.battery.start.quick")) {
do_battery_test();
return STAT_INSTCMD_HANDLED;
}
if (!strcasecmp(cmdname, "test.battery.start.deep")) {
ser_send(upsfd, "%s%s", TEST_BATT_DEEP, COMMAND_END);
return STAT_INSTCMD_HANDLED;
}
if (!strcasecmp(cmdname, "test.battery.stop"))
{
if ((strncmp (UpsFamily, FAMILY_EG, FAMILY_SIZE) == 0) ||
(strncmp (UpsFamily, FAMILY_ON, FAMILY_SIZE) == 0))
{
ser_send(upsfd,"%s00%s",BAT_TEST_PREFIX,COMMAND_END);
}
else
{
ser_send(upsfd,"%c%s",TEST_ABORT,COMMAND_END);
}
return STAT_INSTCMD_HANDLED;
}
if (!strcasecmp(cmdname, "reset.input.minmax")) {
ser_send(upsfd,"%c%s",RESET_MIN_MAX, COMMAND_END);
return STAT_INSTCMD_HANDLED;
}
if (!strcasecmp(cmdname, "beeper.enable")) {
ser_send(upsfd,"%c%c%s",SETX_BUZZER_PREFIX, BUZZER_ENABLED,COMMAND_END);
return STAT_INSTCMD_HANDLED;
}
if (!strcasecmp(cmdname, "beeper.disable")) {
ser_send(upsfd,"%c%c%s",SETX_BUZZER_PREFIX,BUZZER_DISABLED,COMMAND_END);
return STAT_INSTCMD_HANDLED;
}
if (!strcasecmp(cmdname, "beeper.mute")) {
ser_send(upsfd,"%c%c%s",SETX_BUZZER_PREFIX, BUZZER_MUTED, COMMAND_END);
return STAT_INSTCMD_HANDLED;
}
if (!strcasecmp(cmdname, "test.panel.start")) {
ser_send(upsfd,"%s%s",TEST_INDICATORS, COMMAND_END);
return STAT_INSTCMD_HANDLED;
}
upslogx(LOG_NOTICE, "instcmd: unknown command [%s]", cmdname);
return STAT_INSTCMD_UNKNOWN;
}
int setcmd(const char* varname, const char* setvalue)
{
upsdebugx(2, "In setcmd for %s with %s...", varname, setvalue);
if (!strcasecmp(varname, "ups.delay.shutdown"))
{
if ((strncmp (UpsFamily, FAMILY_OZ, FAMILY_SIZE) == 0) ||
(strncmp (UpsFamily, FAMILY_OB, FAMILY_SIZE) == 0))
{
if (atoi(setvalue) > 65535)
{
upsdebugx(2, "Too big for OZ/OB (>65535)...(%s)", setvalue);
return STAT_SET_UNKNOWN;
}
}
else
{
if (atoi(setvalue) > 999)
{
upsdebugx(2, "Too big for EG/ON (>999)...(%s)", setvalue);
return STAT_SET_UNKNOWN;
}
}
dstate_setinfo("ups.delay.shutdown", "%s", setvalue);
return STAT_SET_HANDLED;
}
if (!strcasecmp(varname, "input.transfer.low"))
{
if (SetOutputAllow(setvalue, dstate_getinfo("input.transfer.high")))
{
return STAT_SET_UNKNOWN;
}
else
{
dstate_setinfo("input.transfer.low" , "%s", setvalue);
return STAT_SET_HANDLED;
}
}
if (!strcasecmp(varname, "input.transfer.high"))
{
if (SetOutputAllow(dstate_getinfo("input.transfer.low"), setvalue))
{
return STAT_SET_UNKNOWN;
}
else
{
dstate_setinfo("input.transfer.high" , "%s", setvalue);
return STAT_SET_HANDLED;
}
}
if (!strcasecmp(varname, "battery.date"))
{
if(strlen(setvalue) == GETX_DATE_RESP_SIZE) /* yymmdd (6 chars) */
{
ser_send(upsfd, "%s%s%s", SETX_BATTERY_DATE, setvalue, COMMAND_END);
dstate_setinfo("battery.date", "%s (yymmdd)", setvalue);
return STAT_SET_HANDLED;
}
else
{
return STAT_SET_UNKNOWN;
}
}
if (!strcasecmp(varname, "ups.delay.start"))
{
if (atoi(setvalue) <= 9999)
{
ser_send(upsfd,"%s%s%s",SETX_RESTART_DELAY, setvalue, COMMAND_END);
dstate_setinfo("ups.delay.start", "%s", setvalue);
return STAT_SET_HANDLED;
}
else
{
return STAT_SET_UNKNOWN;
}
}
if (!strcasecmp(varname, "battery.runtime.low"))
{
if (atoi(setvalue) <= 99)
{
ser_send(upsfd,"%s%s%s",SETX_LOWBATT_AT, setvalue, COMMAND_END);
dstate_setinfo("battery.runtime.low", "%s", setvalue);
return STAT_SET_HANDLED;
}
else
{
return STAT_SET_UNKNOWN;
}
}
if (!strcasecmp(varname, "ups.start.auto"))
{
if (!strcasecmp(setvalue, "yes"))
{
ser_send(upsfd,"%c0%s",SETX_AUTO_START, COMMAND_END);
dstate_setinfo("ups.start.auto", "yes");
return STAT_SET_HANDLED;
}
else if (!strcasecmp(setvalue, "no"))
{
ser_send(upsfd,"%c1%s",SETX_AUTO_START, COMMAND_END);
dstate_setinfo("ups.start.auto", "no");
return STAT_SET_HANDLED;
}
return STAT_SET_UNKNOWN;
}
upslogx(LOG_NOTICE, "setcmd: unknown command [%s]", varname);
return STAT_SET_UNKNOWN;
}
static int ivt_status(void)
{
char reply[SMALLBUF];
int ret, i, j = 0;
ser_flush_io(upsfd);
/*
* send: F\n
*/
ret = ser_send(upsfd, "F");
if (ret < 0) {
upsdebug_with_errno(3, "send");
return -1;
}
if (ret == 0) {
upsdebug_with_errno(3, "send: timeout");
return -1;
}
upsdebugx(3, "send: F");
sleep(1); /* allow controller some time to digest this */
/*
* read: R:12,57;- 1,1;20;12,57;13,18;- 2,1; 1,5;\n
*/
ret = ser_get_buf(upsfd, reply, sizeof(reply), 1, 0);
if (ret < 0) {
upsdebug_with_errno(3, "read");
return -1;
}
if (ret == 0) {
upsdebugx(3, "read: timeout");
return -1;
}
upsdebugx(3, "read: %.*s", (int)strcspn(reply, "\r\n"), reply);
upsdebug_hex(4, " \\_", reply, ret);
for (i = 0; i < ret; i++) {
switch(reply[i])
{
case ',': /* convert ',' to '.' */
reply[j++] = '.';
break;
case ' ': /* skip over white space */
case '\0': /* skip over null characters */
break;
default: /* leave the rest as is */
reply[j++] = reply[i];
break;
}
}
reply[j++] = '\0';
ret = sscanf(reply, "R:%f;%f;%f;%f;%f;%f;%f;", &battery.voltage.act, &battery.current.act, &battery.temperature,
&battery.voltage.min, &battery.voltage.max, &battery.current.min, &battery.current.max);
upsdebugx(3, "Parsed %d parameters from reply", ret);
return ret;
}
/* power down the attached load immediately */
void upsdrv_shutdown(void)
{
/* NB: hard-wired password */
ser_send(upsfd, "pw377\r");
ser_send(upsfd, "off 1 a\r"); /* power off in 1 second and restart when line power returns */
}