524 lines
20 KiB
C
524 lines
20 KiB
C
/* mge-shut.h - monitor MGE UPS for NUT with SHUT protocol
|
|
*
|
|
* Copyright (C) 2002 - 2005
|
|
* Arnaud Quette <arnaud.quette@free.fr> & <arnaud.quette@mgeups.com>
|
|
* Philippe Marzouk <philm@users.sourceforge.net>
|
|
*
|
|
* Sponsored by MGE UPS SYSTEMS <http://opensource.mgeups.com/>
|
|
*
|
|
* 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.
|
|
*
|
|
* 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 "hidparser.h"
|
|
#include "hidtypes.h"
|
|
|
|
#define DEFAULT_TIMEOUT 3000
|
|
#define MAX_STRING 64
|
|
|
|
#define DEFAULT_LOWBATT 30 /* low battery level, in % */
|
|
#define DEFAULT_ONDELAY 3 /* delay between return of utility power
|
|
and powering up of load, in 10 seconds units */
|
|
#define DEFAULT_OFFDELAY 20 /* delay befor power off, in seconds */
|
|
#define OFF_NOTIFICATION 1 /* notification off */
|
|
|
|
#define LIGHT_NOTIFICATION 2 /* light notification */
|
|
#define COMPLETE_NOTIFICATION 3 /* complete notification for UPSs which do
|
|
* not support disabling it like some early
|
|
* Ellipse models */
|
|
#define DEFAULT_NOTIFICATION COMPLETE_NOTIFICATION
|
|
|
|
/* HID definitions */
|
|
|
|
#define HID_REPORT_TYPE_INPUT 0x01
|
|
#define HID_REPORT_TYPE_OUTPUT 0x02
|
|
#define HID_REPORT_TYPE_FEATURE 0x03
|
|
|
|
#define REQUEST_TYPE_USB 0x80
|
|
#define REQUEST_TYPE_HID 0x81
|
|
#define REQUEST_TYPE_GET_REPORT 0xa1
|
|
#define REQUEST_TYPE_SET_REPORT 0x21
|
|
|
|
#define DEVICE_DESCRIPTOR 0x0001
|
|
#define CONFIG_DESCRIPTOR 0x0002
|
|
#define STRING_DESCRIPTOR 0x0003
|
|
#define INTERFACE_DESCRIPTOR 0x0004
|
|
#define ENDPOINT_DESCRIPTOR 0x0005
|
|
#define HID_DESCRIPTOR 0x0021
|
|
#define REPORT_DESCRIPTOR 0x0022
|
|
|
|
#define MAX_REPORT_SIZE 0x1800
|
|
|
|
/* SHUT definitions - From Simplified SHUT spec */
|
|
|
|
#define SHUT_TYPE_REQUEST 0x01
|
|
#define SHUT_TYPE_RESPONSE 0x04
|
|
#define SHUT_TYPE_NOTIFY 0x05
|
|
#define SHUT_OK 0x06
|
|
#define SHUT_NOK 0x15
|
|
#define SHUT_SYNC 0x16 /* complete notifications - not yet managed
|
|
but needed for some early Ellipse models */
|
|
#define SHUT_SYNC_LIGHT 0x17 /* partial notifications */
|
|
#define SHUT_SYNC_OFF 0x18 /* disable notifications - only do polling */
|
|
#define SHUT_PKT_LAST 0x80
|
|
|
|
/* From SHUT specifications */
|
|
|
|
typedef struct hid_packet {
|
|
unsigned char bmRequestType;
|
|
unsigned char bRequest;
|
|
unsigned short wValue;
|
|
unsigned short wIndex;
|
|
unsigned short wLength;
|
|
/* unsigned char padding[8]; for use with shut_set_report */
|
|
} hid_packet_t;
|
|
|
|
typedef union hid_data_u {
|
|
hid_packet_t hid_pkt;
|
|
unsigned char raw_pkt[8]; /* max report lengh, was 8 */
|
|
} hid_data_t;
|
|
|
|
typedef struct shut_packet {
|
|
unsigned char bType;
|
|
unsigned char bLength;
|
|
hid_data_t data;
|
|
unsigned char bChecksum;
|
|
} shut_packet_t;
|
|
|
|
typedef union shut_data_u {
|
|
shut_packet_t shut_pkt;
|
|
unsigned char raw_pkt[11];
|
|
} shut_data_t;
|
|
|
|
/* From USB/HID specifications */
|
|
|
|
typedef struct hid_descriptor {
|
|
unsigned char bLength;
|
|
unsigned char bDescriptorType;
|
|
unsigned short bcdHID;
|
|
unsigned char bCountryCode;
|
|
unsigned char bNumDescriptors;
|
|
unsigned char bReportDescriptorType;
|
|
unsigned short wDescriptorLength;
|
|
} hid_descriptor_t;
|
|
|
|
typedef union hid_desc_data_u {
|
|
hid_descriptor_t hid_desc;
|
|
unsigned char raw_desc[9]; /* max report lengh, aws 9 */
|
|
} hid_desc_data_t;
|
|
|
|
typedef struct device_descriptor {
|
|
unsigned char bLength;
|
|
unsigned char bDescriptorType;
|
|
unsigned short bcdUSB;
|
|
unsigned char bDeviceClass;
|
|
unsigned char bDeviceSubClass;
|
|
unsigned char bDeviceProtocol;
|
|
unsigned char bMaxPacketSize0;
|
|
unsigned short idVendor;
|
|
unsigned short idProduct;
|
|
unsigned short bcdDevice;
|
|
unsigned char iManufacturer;
|
|
unsigned char iProduct;
|
|
unsigned char iSerialNumber;
|
|
unsigned char bNumConfigurations;
|
|
} device_descriptor_t;
|
|
|
|
typedef union device_desc_data_u {
|
|
device_descriptor_t dev_desc;
|
|
unsigned char raw_desc[18];
|
|
} device_desc_data_t;
|
|
|
|
/* --------------------------------------------------------------- */
|
|
/* Explicit Booleans */
|
|
/* --------------------------------------------------------------- */
|
|
|
|
#define SHUT_FLAG_OK (1 << 0) /* show element to upsd. */
|
|
#define SHUT_FLAG_STATIC (1 << 1) /* retrieve info only once. */
|
|
#define SHUT_FLAG_ABSENT (1 << 2) /* data is absent in the device,
|
|
use default value. */
|
|
#define SHUT_FLAG_STALE (1 << 3) /* data stale, don't try too often. */
|
|
#define SHUT_FLAG_DELAY (1 << 4) /* delay type value: formated differently. */
|
|
|
|
/* --------------------------------------------------------------- */
|
|
/* Model Name formating entries */
|
|
/* --------------------------------------------------------------- */
|
|
typedef struct {
|
|
const char *iProduct;
|
|
const char *iModel;
|
|
const char *finalname;
|
|
} models_name_t;
|
|
|
|
models_name_t models_names [] =
|
|
{
|
|
/* Ellipse models */
|
|
{ "ELLIPSE", "300", "ellipse 300" },
|
|
{ "ELLIPSE", "500", "ellipse 500" },
|
|
{ "ELLIPSE", "650", "ellipse 650" },
|
|
{ "ELLIPSE", "800", "ellipse 800" },
|
|
{ "ELLIPSE", "1200", "ellipse 1200" },
|
|
/* Ellipse Premium models */
|
|
{ "ellipse", "PR500", "ellipse premium 500" },
|
|
{ "ellipse", "PR650", "ellipse premium 650" },
|
|
{ "ellipse", "PR800", "ellipse premium 800" },
|
|
{ "ellipse", "PR1200", "ellipse premium 1200" },
|
|
/* Ellipse "Pro" */
|
|
{ "ELLIPSE", "600", "Ellipse 600" },
|
|
{ "ELLIPSE", "750", "Ellipse 750" },
|
|
{ "ELLIPSE", "1000", "Ellipse 1000" },
|
|
{ "ELLIPSE", "1500", "Ellipse 1500" },
|
|
/* Ellipse "MAX" */
|
|
{ "Ellipse MAX", "600", "Ellipse MAX 600" },
|
|
{ "Ellipse MAX", "850", "Ellipse MAX 850" },
|
|
{ "Ellipse MAX", "1100", "Ellipse MAX 1100" },
|
|
{ "Ellipse MAX", "1500", "Ellipse MAX 1500" },
|
|
/* Protection Center */
|
|
{ "PROTECTIONCENTER", "420", "Protection Center 420" },
|
|
{ "PROTECTIONCENTER", "500", "Protection Center 500" },
|
|
{ "PROTECTIONCENTER", "675", "Protection Center 675" },
|
|
/* Pulsar Evolution models */
|
|
{ "Evolution", "500", "Pulsar Evolution 500" },
|
|
{ "Evolution", "800", "Pulsar Evolution 800" },
|
|
{ "Evolution", "1100", "Pulsar Evolution 1100" },
|
|
{ "Evolution", "1500", "Pulsar Evolution 1500" },
|
|
{ "Evolution", "2200", "Pulsar Evolution 2200" },
|
|
{ "Evolution", "3000", "Pulsar Evolution 3000" },
|
|
{ "Evolution", "3000XL", "Pulsar Evolution 3000 XL" },
|
|
/* Newer Evolution models */
|
|
{ "Evolution", "650", "Evolution 650" },
|
|
{ "Evolution", "850", "Evolution 850" },
|
|
{ "Evolution", "1150", "Evolution 1150" },
|
|
{ "Evolution", "S 1250", "Evolution S 1250" },
|
|
{ "Evolution", "1550", "Evolution 1550" },
|
|
{ "Evolution", "S 1750", "Evolution S 1750" },
|
|
{ "Evolution", "2000", "Evolution 2000" },
|
|
{ "Evolution", "S 2500", "Evolution S 2500" },
|
|
{ "Evolution", "S 3000", "Evolution S 3000" },
|
|
/* Pulsar M models */
|
|
{ "PULSAR M", "2200", "Pulsar M 2200" },
|
|
{ "PULSAR M", "3000", "Pulsar M 3000" },
|
|
{ "PULSAR M", "3000 XL", "Pulsar M 3000 XL" },
|
|
/* Eaton'ified names */
|
|
{ "EX", "2200", "EX 2200" },
|
|
{ "EX", "3000", "EX 3000" },
|
|
{ "EX", "3000 XL", "EX 3000 XL" },
|
|
/* Pulsar models */
|
|
{ "Pulsar", "700", "Pulsar 700" },
|
|
{ "Pulsar", "1000", "Pulsar 1000" },
|
|
{ "Pulsar", "1500", "Pulsar 1500" },
|
|
{ "Pulsar", "1000 RT2U", "Pulsar 1000 RT2U" },
|
|
{ "Pulsar", "1500 RT2U", "Pulsar 1500 RT2U" },
|
|
/* Eaton'ified names */
|
|
{ "EX", "700", "EX 700" },
|
|
{ "EX", "1000", "EX 1000" },
|
|
{ "EX", "1500", "EX 1500" },
|
|
{ "EX", "1000 RT2U", "EX 1000 RT2U" },
|
|
{ "EX", "1500 RT2U", "EX 1500 RT2U" },
|
|
/* Pulsar MX models */
|
|
{ "PULSAR", "MX4000", "Pulsar MX 4000 RT" },
|
|
{ "PULSAR", "MX5000", "Pulsar MX 5000 RT" },
|
|
/* NOVA models */
|
|
{ "NOVA AVR", "600", "NOVA 600 AVR" },
|
|
{ "NOVA AVR", "625", "Nova AVR 625" },
|
|
{ "NOVA AVR", "1100", "NOVA 1100 AVR" },
|
|
{ "NOVA AVR", "1250", "Nova AVR 1250" },
|
|
/* EXtreme C (EMEA) */
|
|
{ "EXtreme", "700C", "Pulsar EXtreme 700C" },
|
|
{ "EXtreme", "1000C", "Pulsar EXtreme 1000C" },
|
|
{ "EXtreme", "1500C", "Pulsar EXtreme 1500C" },
|
|
{ "EXtreme", "1500CCLA", "Pulsar EXtreme 1500C CLA" },
|
|
{ "EXtreme", "2200C", "Pulsar EXtreme 2200C" },
|
|
{ "EXtreme", "3200C", "Pulsar EXtreme 3200C" },
|
|
/* EXtreme C (USA, aka "EX RT") */
|
|
{ "EX", "700RT", "Pulsar EX 700 RT" },
|
|
{ "EX", "1000RT", "Pulsar EX 1000 RT" },
|
|
{ "EX", "1500RT", "Pulsar EX 1500 RT" },
|
|
{ "EX", "2200RT", "Pulsar EX 2200 RT" },
|
|
{ "EX", "3200RT", "Pulsar EX 3200 RT" },
|
|
/* Comet EX RT three phased */
|
|
{ "EX", "5RT31", "EX 5 RT 3:1" },
|
|
{ "EX", "7RT31", "EX 7 RT 3:1" },
|
|
{ "EX", "11RT31", "EX 11 RT 3:1" },
|
|
/* Comet EX RT single phased */
|
|
{ "EX", "5RT", "EX 5 RT" },
|
|
{ "EX", "7RT", "EX 7 RT" },
|
|
{ "EX", "11RT", "EX 11 RT" },
|
|
/* Galaxy 3000 */
|
|
{ "GALAXY", "3000_10", "Galaxy 3000 10 kVA" },
|
|
{ "GALAXY", "3000_15", "Galaxy 3000 15 kVA" },
|
|
{ "GALAXY", "3000_20", "Galaxy 3000 20 kVA" },
|
|
{ "GALAXY", "3000_30", "Galaxy 3000 30 kVA" },
|
|
|
|
/* FIXME: To be completed (Comet, Galaxy, Esprit, ...) */
|
|
|
|
/* end of structure. */
|
|
{ NULL, NULL, "Generic SHUT model" }
|
|
};
|
|
/* for lookup between HID values and NUT values*/
|
|
typedef struct {
|
|
long hid_value; /* HID value */
|
|
const char *nut_value; /* NUT value */
|
|
} info_lkp_t;
|
|
|
|
/* Actual value lookup tables => should be fine for all Mfrs (TODO: validate it!) */
|
|
/* --------------------------------------------------------------- */
|
|
/* Lookup values between NUT and HID */
|
|
/* --------------------------------------------------------------- */
|
|
info_lkp_t onbatt_info[] = {
|
|
{ 0, "OB" },
|
|
{ 1, "OL" },
|
|
{ 0, "NULL" }
|
|
};
|
|
info_lkp_t discharging_info[] = {
|
|
{ 1, "DISCHRG" },
|
|
{ 0, "NULL" }
|
|
};
|
|
info_lkp_t charging_info[] = {
|
|
{ 1, "CHRG" },
|
|
{ 0, "NULL" }
|
|
};
|
|
info_lkp_t lowbatt_info[] = {
|
|
{ 1, "LB" },
|
|
{ 0, "NULL" }
|
|
};
|
|
info_lkp_t overbatt_info[] = {
|
|
{ 1, "OVER" },
|
|
{ 0, "NULL" }
|
|
};
|
|
info_lkp_t replacebatt_info[] = {
|
|
{ 1, "RB" },
|
|
{ 0, "NULL" }
|
|
};
|
|
info_lkp_t shutdownimm_info[] = {
|
|
{ 1, "LB" },
|
|
{ 0, "NULL" }
|
|
};
|
|
info_lkp_t trim_info[] = {
|
|
{ 1, "TRIM" },
|
|
{ 0, "NULL" }
|
|
};
|
|
info_lkp_t boost_info[] = {
|
|
{ 1, "BOOST" },
|
|
{ 0, "NULL" }
|
|
};
|
|
/* TODO: add BYPASS, OFF, CAL */
|
|
|
|
info_lkp_t test_write_info[] = {
|
|
{ 0, "No test" },
|
|
{ 1, "Quick test" },
|
|
{ 2, "Deep test" },
|
|
{ 3, "Abort test" },
|
|
{ 0, "NULL" }
|
|
};
|
|
info_lkp_t test_read_info[] = {
|
|
{ 1, "Done and passed" },
|
|
{ 2, "Done and warning" },
|
|
{ 3, "Done and error" },
|
|
{ 4, "Aborted" },
|
|
{ 5, "In progress" },
|
|
{ 6, "No test initiated" },
|
|
{ 0, "NULL" }
|
|
};
|
|
|
|
/* --------------------------------------------------------------- */
|
|
/* Query Commands and their Mapping to INFO_ Variables */
|
|
/* --------------------------------------------------------------- */
|
|
|
|
/* Structure defining how to query UPS for a variable and write
|
|
information to INFO structure.
|
|
*/
|
|
typedef struct {
|
|
const char *type; /* INFO_* element */
|
|
int flags; /* INFO-element flags to set in addinfo */
|
|
int length; /* INFO-element length of strings */
|
|
const char *item_path; /* HID object (fully qualified string path) */
|
|
const char *fmt; /* printf format string for INFO entry */
|
|
const char *dfl; /* default value */
|
|
unsigned long shut_flags; /* specific SHUT flags */
|
|
info_lkp_t *hid2info; /* lookup table between HID and NUT values */
|
|
} mge_info_item_t;
|
|
|
|
/* Array containing information to translate between UTalk and NUT info
|
|
* NOTE:
|
|
* - Array is terminated by element with type NULL.
|
|
* - Essential INFO items (ups.{mfr, model, firmware, status} are
|
|
* handled separately.
|
|
* - Array is NOT const, since "shut_flags" can be changed.
|
|
*/
|
|
|
|
/* FIXME: should be shared with mgehid.h */
|
|
static mge_info_item_t mge_info[] = {
|
|
/* Battery page */
|
|
{ "battery.charge", 0, 0, "UPS.PowerSummary.RemainingCapacity", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "battery.charge.low", ST_FLAG_RW | ST_FLAG_STRING, 5, "UPS.PowerSummary.RemainingCapacityLimitSetting",
|
|
"%ld", NULL, SHUT_FLAG_OK, NULL }, /* RW, to be caught first if exists... */
|
|
{ "battery.charge.low", ST_FLAG_STRING, 5, "UPS.PowerSummary.RemainingCapacityLimit",
|
|
"%ld", NULL, SHUT_FLAG_OK, NULL }, /* ... or Read only */
|
|
{ "battery.runtime", 0, 0, "UPS.PowerSummary.RunTimeToEmpty", "%.0d", NULL, SHUT_FLAG_OK, NULL },
|
|
/* UPS page */
|
|
{ "ups.mfr", ST_FLAG_STRING, 20, NULL, "%s", "MGE UPS SYSTEMS", SHUT_FLAG_ABSENT | SHUT_FLAG_OK, NULL },
|
|
{ "ups.load", 0, 0, "UPS.PowerSummary.PercentLoad", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "ups.timer.shutdown", ST_FLAG_RW | ST_FLAG_STRING, 5, "UPS.PowerSummary.DelayBeforeShutdown",
|
|
"%ld", NULL, SHUT_FLAG_OK | SHUT_FLAG_DELAY, NULL },
|
|
{ "ups.timer.reboot", ST_FLAG_RW | ST_FLAG_STRING, 5, "UPS.PowerSummary.DelayBeforeReboot",
|
|
"%ld", NULL, SHUT_FLAG_OK | SHUT_FLAG_DELAY, NULL },
|
|
{ "ups.timer.start", ST_FLAG_RW | ST_FLAG_STRING, 5, "UPS.PowerSummary.DelayBeforeStartup",
|
|
"%ld", NULL, SHUT_FLAG_OK | SHUT_FLAG_DELAY, NULL },
|
|
/* FIXME: miss ups.power */
|
|
{ "ups.power.nominal", ST_FLAG_STRING, 5, "UPS.Flow.[4].ConfigApparentPower",
|
|
"%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "ups.test.interval", ST_FLAG_RW | ST_FLAG_STRING, 5, "UPS.BatterySystem.Battery.TestPeriod",
|
|
"%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "ups.test.result", ST_FLAG_STRING, 5, "UPS.BatterySystem.Battery.Test",
|
|
"%i", NULL, SHUT_FLAG_OK, &test_read_info[0] },
|
|
|
|
/* Output page */
|
|
{ "output.voltage", 0, 0, "UPS.PowerConverter.Output.Voltage", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "output.voltage.nominal", 0, 0, "UPS.PowerSummary.ConfigVoltage", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "output.current", 0, 0, "UPS.PowerSummary.Output.Current", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "output.frequency", 0, 0, "UPS.PowerConverter.Output.Frequency", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
|
|
/* Outlet page (using MGE UPS SYSTEMS - PowerShare technology) */
|
|
/* TODO: add an iterative semantic [%x] to factorise outlets */
|
|
{ "outlet.id", 0, 0, "UPS.OutletSystem.Outlet.[1].OutletID", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "outlet.desc", ST_FLAG_RW | ST_FLAG_STRING, 20, "UPS.OutletSystem.Outlet.[1].OutletID",
|
|
"%s", "Main Outlet", SHUT_FLAG_ABSENT | SHUT_FLAG_OK, NULL },
|
|
{ "outlet.switchable", 0, 0, "UPS.OutletSystem.Outlet.[1].PresentStatus.Switchable",
|
|
"%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "outlet.1.id", 0, 0, "UPS.OutletSystem.Outlet.[2].OutletID", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "outlet.1.desc", ST_FLAG_RW | ST_FLAG_STRING, 20, "UPS.OutletSystem.Outlet.[2].OutletID",
|
|
"%s", "PowerShare Outlet 1", SHUT_FLAG_ABSENT | SHUT_FLAG_OK, NULL },
|
|
{ "outlet.1.switchable", 0, 0, "UPS.OutletSystem.Outlet.[2].PresentStatus.Switchable",
|
|
"%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "outlet.1.switch", ST_FLAG_RW | ST_FLAG_STRING, 2, "UPS.OutletSystem.Outlet.[2].PresentStatus.SwitchOn/Off",
|
|
"%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "outlet.1.autoswitch.charge.low", ST_FLAG_RW | ST_FLAG_STRING, 3,
|
|
"UPS.OutletSystem.Outlet.[2].RemainingCapacityLimit", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "outlet.1.delay.shutdown", ST_FLAG_RW | ST_FLAG_STRING, 5,
|
|
"UPS.OutletSystem.Outlet.[2].DelayBeforeShutdown", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "outlet.1.delay.start", ST_FLAG_RW | ST_FLAG_STRING, 5, "UPS.OutletSystem.Outlet.[2].DelayBeforeStartup", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "outlet.2.id", 0, 0, "UPS.OutletSystem.Outlet.[3].OutletID", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "outlet.2.desc", ST_FLAG_RW | ST_FLAG_STRING, 20, "UPS.OutletSystem.Outlet.[3].OutletID",
|
|
"%s", "PowerShare Outlet 2", SHUT_FLAG_ABSENT | SHUT_FLAG_OK, NULL },
|
|
{ "outlet.2.switchable", 0, 0, "UPS.OutletSystem.Outlet.[3].PresentStatus.Switchable",
|
|
"%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "outlet.2.switch", ST_FLAG_RW | ST_FLAG_STRING, 2, "UPS.OutletSystem.Outlet.[3].PresentStatus.SwitchOn/Off",
|
|
"%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "outlet.2.autoswitch.charge.low", ST_FLAG_RW | ST_FLAG_STRING, 3,
|
|
"UPS.OutletSystem.Outlet.[3].RemainingCapacityLimit", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "outlet.2.delay.shutdown", ST_FLAG_RW | ST_FLAG_STRING, 5,
|
|
"UPS.OutletSystem.Outlet.[3].DelayBeforeShutdown", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "outlet.2.delay.start", ST_FLAG_RW | ST_FLAG_STRING, 5,
|
|
"UPS.OutletSystem.Outlet.[3].DelayBeforeStartup", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
|
|
/* Input page */
|
|
{ "input.voltage", 0, 0, "UPS.PowerConverter.Input.[1].Voltage", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
{ "input.frequency", 0, 0, "UPS.PowerConverter.Input.[1].Frequency", "%i", NULL, SHUT_FLAG_OK, NULL },
|
|
|
|
/* terminating element */
|
|
{ NULL, 0, 0, "\0", "\0", NULL, 0, NULL }
|
|
};
|
|
|
|
/* temporary usage code lookup */
|
|
typedef struct {
|
|
const char *usage_name;
|
|
const uint32_t usage_code;
|
|
} usage_lkp_t;
|
|
|
|
/* FIXME: share this data structure with libhid.c */
|
|
static usage_lkp_t usage_lkp[] = {
|
|
/* Power Device Page */
|
|
{ "PresentStatus", 0x00840002 },
|
|
{ "UPS", 0x00840004 },
|
|
{ "BatterySystem", 0x00840010 },
|
|
{ "Battery", 0x00840012 },
|
|
{ "BatteryID", 0x00840013 },
|
|
{ "PowerConverter", 0x00840016 },
|
|
{ "OutletSystem", 0x00840018 },
|
|
{ "Input", 0x0084001a },
|
|
{ "Output", 0x0084001c },
|
|
{ "Outlet", 0x00840020 },
|
|
{ "OutletID", 0x00840021 },
|
|
{ "PowerSummary", 0x00840024 },
|
|
{ "Voltage", 0x00840030 },
|
|
{ "Current", 0x00840031 },
|
|
{ "Frequency", 0x00840032 },
|
|
{ "PercentLoad", 0x00840035 },
|
|
{ "ConfigVoltage", 0x00840040 },
|
|
{ "ConfigCurrent", 0x00840041 },
|
|
{ "ConfigFrequency", 0x00840042 },
|
|
{ "ConfigApparentPower", 0x00840043 },
|
|
{ "LowVoltageTransfer", 0x00840053 },
|
|
{ "HighVoltageTransfer", 0x00840054 },
|
|
{ "DelayBeforeReboot", 0x00840055 },
|
|
{ "DelayBeforeStartup", 0x00840056 },
|
|
{ "DelayBeforeShutdown", 0x00840057 },
|
|
{ "Test", 0x00840058 },
|
|
{ "Good", 0x00840061 },
|
|
{ "Overload", 0x00840065 }, /* sic */
|
|
{ "SwitchOn/Off", 0x0084006b },
|
|
{ "Switchable", 0x0084006c },
|
|
{ "Used", 0x0084006d },
|
|
{ "Flow", 0x0084001e },
|
|
/* Battery System Page */
|
|
{ "RemainingCapacityLimit", 0x00850029 },
|
|
{ "BelowRemainingCapacityLimit", 0x00850042 },
|
|
{ "RemainingCapacity", 0x00850066 },
|
|
{ "RunTimeToEmpty", 0x00850068 },
|
|
{ "ACPresent", 0x008500d0 },
|
|
{ "Charging", 0x00850044 },
|
|
{ "Discharging", 0x00850045 },
|
|
{ "NeedReplacement", 0x0085004b },
|
|
/* MGE UPS SYSTEMS Page */
|
|
{ "iModel", 0xffff00f0 },
|
|
{ "RemainingCapacityLimitSetting", 0xffff004d },
|
|
{ "TestPeriod", 0xffff0001 },
|
|
|
|
{ "\0", 0x0 }
|
|
};
|
|
|
|
/* SHUT / HID functions Prototypes */
|
|
|
|
int shut_ups_start(void);
|
|
u_char shut_checksum(const u_char *buf, int bufsize);
|
|
int shut_token_send(u_char token);
|
|
int shut_packet_send (hid_data_t *hdata, int datalen, u_char token);
|
|
int shut_packet_recv (u_char *Buf, int datalen);
|
|
|
|
int shut_get_descriptor(int desctype, u_char *pkt, int reportlen);
|
|
int shut_get_string(int strindex, char *string, int stringlen);
|
|
int shut_get_report(int id, u_char *pkt, int reportlen);
|
|
int shut_set_report(int id, u_char *pkt, int reportlen);
|
|
int shut_identify_ups (void);
|
|
int shut_wait_ack (void);
|
|
void shut_ups_status(void);
|
|
|
|
int hid_init_device(void);
|
|
const char *get_model_name(char *iProduct, char *iModel);
|
|
int hid_lookup_usage(char *name);
|
|
int hid_get_value(const char *item_path);
|
|
int hid_set_value(const char *varname, const char *val);
|
|
u_short lookup_path(const char *HIDpath, HIDData_t *data);
|
|
|
|
int instcmd(const char *cmdname, const char *extra);
|
|
void setline(int set);
|
|
int serial_read (int read_timeout, u_char *readbuf);
|
|
int serial_send(u_char *buf, int len);
|
|
|
|
void make_string(u_char *buf, int datalen, char *string);
|
|
|
|
|
|
mge_info_item_t *shut_find_info(const char *varname);
|