nut-debian/drivers/nutdrv_qx_voltronic.c

/* nutdrv_qx_voltronic.c - Subdriver for Voltronic Power UPSes
 *
 * Copyright (C)
 *   2013 Daniele Pezzini <hyouko@gmail.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 "main.h"
#include "nutdrv_qx.h"

#include "nutdrv_qx_voltronic.h"

#define VOLTRONIC_VERSION "Voltronic 0.03"

/* Support functions */
static int	voltronic_claim(void);
static void	voltronic_makevartable(void);
static void	voltronic_massive_unskip(const int protocol);

/* Range/enum functions */
static int	voltronic_batt_low(char *value, size_t len);
static int	voltronic_bypass_volt_max(char *value, size_t len);
static int	voltronic_bypass_volt_min(char *value, size_t len);
static int	voltronic_bypass_freq_max(char *value, size_t len);
static int	voltronic_bypass_freq_min(char *value, size_t len);
static int	voltronic_eco_freq_min(char *value, size_t len);
static int	voltronic_eco_freq_max(char *value, size_t len);

/* Preprocess functions */
static int	voltronic_process_setvar(item_t *item, char *value, size_t valuelen);
static int	voltronic_process_command(item_t *item, char *value, size_t valuelen);
static int	voltronic_capability(item_t *item, char *value, size_t valuelen);
static int	voltronic_capability_set(item_t *item, char *value, size_t valuelen);
static int	voltronic_capability_set_nonut(item_t *item, char *value, size_t valuelen);
static int	voltronic_capability_reset(item_t *item, char *value, size_t valuelen);
static int	voltronic_eco_volt(item_t *item, char *value, size_t valuelen);
static int	voltronic_eco_volt_range(item_t *item, char *value, size_t valuelen);
static int	voltronic_eco_freq(item_t *item, char *value, size_t valuelen);
static int	voltronic_bypass(item_t *item, char *value, size_t valuelen);
static int	voltronic_batt_numb(item_t *item, char *value, size_t valuelen);
static int	voltronic_batt_runtime(item_t *item, char *value, size_t valuelen);
static int	voltronic_protocol(item_t *item, char *value, size_t valuelen);
static int	voltronic_fault(item_t *item, char *value, size_t valuelen);
static int	voltronic_warning(item_t *item, char *value, size_t valuelen);
static int	voltronic_mode(item_t *item, char *value, size_t valuelen);
static int	voltronic_status(item_t *item, char *value, size_t valuelen);
static int	voltronic_output_powerfactor(item_t *item, char *value, size_t valuelen);
static int	voltronic_serial_numb(item_t *item, char *value, size_t valuelen);
static int	voltronic_outlet(item_t *item, char *value, size_t valuelen);
static int	voltronic_outlet_delay(item_t *item, char *value, size_t valuelen);
static int	voltronic_outlet_delay_set(item_t *item, char *value, size_t valuelen);
static int	voltronic_p31b(item_t *item, char *value, size_t valuelen);
static int	voltronic_p31b_set(item_t *item, char *value, size_t valuelen);
static int	voltronic_p31g(item_t *item, char *value, size_t valuelen);
static int	voltronic_p31g_set(item_t *item, char *value, size_t valuelen);
static int	voltronic_phase(item_t *item, char *value, size_t valuelen);
static int	voltronic_phase_set(item_t *item, char *value, size_t valuelen);
static int	voltronic_parallel(item_t *item, char *value, size_t valuelen);

/* Capability vars */
static char	*bypass_alarm,
		*battery_alarm,
		*bypass_when_off,
		*alarm_control,
		*converter_mode,
		*eco_mode,
		*battery_open_status_check,
		*bypass_forbidding,
		*site_fault_detection,
		*advanced_eco_mode,
		*constant_phase_angle,
		*limited_runtime_on_battery;

/* ups.conf settings */
static int	max_bypass_volt,
		min_bypass_volt,
		battery_number,
		output_phase_angle,
		work_range_type;
static double	max_bypass_freq,
		min_bypass_freq;


/* == Ranges/enums == */

/* Range for ups.delay.start */
static info_rw_t	voltronic_r_ondelay[] = {
	{ "0", 0 },
	{ "599940", 0 },
	{ "", 0 }
};

/* Range for ups.delay.shutdown */
static info_rw_t	voltronic_r_offdelay[] = {
	{ "12", 0 },
	{ "5940", 0 },
	{ "", 0 }
};

/* Enumlist for output phase angle */
static info_rw_t	voltronic_e_phase[] = {
	{ "000", 0 },
	{ "120", 0 },
	{ "180", 0 },
	{ "240", 0 },
	{ "", 0 }
};

/* Range for battery low voltage */
static info_rw_t	voltronic_r_batt_low[] = {
	{ "20", 0 },
	{ "24", voltronic_batt_low },
	{ "28", voltronic_batt_low },
	{ "", 0 }
};

/* Preprocess range value for battery low voltage */
static int	voltronic_batt_low(char *value, size_t len)
{
	int		val = strtol(value, NULL, 10);
	const char	*ovn = dstate_getinfo("output.voltage.nominal"),
			*ocn = dstate_getinfo("output.current.nominal");

	if (!ovn || !ocn) {
		upsdebugx(2, "%s: unable to get the value of output voltage nominal/output current nominal", __func__);
		return -1;
	}

	if ((strtol(ovn, NULL, 10) * strtol(ocn, NULL, 10)) < 1000) {

		if (val == 24)
			return 0;
		else
			return -1;

	} else {

		if (val == 28)
			return 0;
		else
			return -1;
	}
}

/* Range for outlet.n.delay.shutdown */
static info_rw_t	voltronic_r_outlet_delay[] = {
	{ "0", 0 },
	{ "59940", 0 },
	{ "", 0 }
};

/* Enumlist for device grid working range type */
static info_rw_t	voltronic_e_work_range[] = {
	{ "Appliance", 0 },	/* 00 */
	{ "UPS", 0 },		/* 01 */
	{ "", 0 }
};

/* Enumlist for battery type */
static info_rw_t	voltronic_e_batt_type[] = {
	{ "Li", 0 },		/* 00 */
	{ "Flooded", 0 },	/* 01 */
	{ "AGM", 0 },		/* 02 */
	{ "", 0 }
};

/* Range for number of battery packs */
static info_rw_t	voltronic_r_batt_packs[] = {
	{ "1", 0 },
	{ "99", 0 },
	{ "", 0 }
};

/* Range for number of batteries */
static info_rw_t	voltronic_r_batt_numb[] = {
	{ "1", 0 },
	{ "9", 0 },
	{ "", 0 }
};

/* Range for Bypass Mode maximum voltage */
static info_rw_t	voltronic_r_bypass_volt_max[] = {
	{ "60", voltronic_bypass_volt_max },	/* P09 */
	{ "115", voltronic_bypass_volt_max },	/* P02/P03/P10/P13/P14/P99 ivn<200 */
	{ "120", voltronic_bypass_volt_max },	/* P01 ivn<200 */
	{ "132", voltronic_bypass_volt_max },	/* P99 ivn<200 */
	{ "138", voltronic_bypass_volt_max },	/* P02/P03/P10/P13/P14 ivn<200 */
	{ "140", voltronic_bypass_volt_max },	/* P01 ivn<200, P09 */
	{ "230", voltronic_bypass_volt_max },	/* P01 ivn>=200 */
	{ "231", voltronic_bypass_volt_max },	/* P02/P03/P10/P13/P14/P99 ivn>=200 */
	{ "261", voltronic_bypass_volt_max },	/* P99 ivn>=200 */
	{ "264", voltronic_bypass_volt_max },	/* P01 ivn>=200 */
	{ "276", voltronic_bypass_volt_max },	/* P02/P03/P10/P13/P14 ivn>=200 */
	{ "", 0 }
};

/* Preprocess range value for Bypass Mode maximum voltage */
static int	voltronic_bypass_volt_max(char *value, size_t len)
{
	int		protocol = strtol(dstate_getinfo("ups.firmware.aux")+1, NULL, 10),
			val = strtol(value, NULL, 10),
			ivn;
	const char	*involtnom = dstate_getinfo("input.voltage.nominal");

	if (!involtnom) {
		upsdebugx(2, "%s: unable to get input.voltage.nominal", __func__);
		return -1;
	}

	ivn = strtol(involtnom, NULL, 10);

	switch (val)
	{
	case 60:	/* P09 */

		if (protocol == 9)
			return 0;

		break;

	case 115:	/* P02/P03/P10/P13/P14/P99 ivn<200 */

		if (ivn >= 200)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 120:	/* P01 ivn<200 */

		if (ivn >= 200)
			return -1;

		if (protocol == 1)
			return 0;

		break;

	case 132:	/* P99 ivn<200 */

		if (ivn >= 200)
			return -1;

		if (protocol == 99)
			return 0;

		break;

	case 138:	/* P02/P03/P10/P13/P14 ivn<200 */

		if (ivn >= 200)
			return -1;

		if (protocol == 2 || protocol == 2 || protocol == 10 || protocol == 13 || protocol == 14)
			return 0;

		break;

	case 140:	/* P01 ivn<200, P09 */

		if (protocol == 9)
			return 0;

		if (ivn >= 200)
			return -1;

		if (protocol == 1)
			return 0;

		break;

	case 230:	/* P01 ivn>=200 */

		if (ivn < 200)
			return -1;

		if (protocol == 1)
			return 0;

		break;

	case 231:	/* P02/P03/P10/P13/P14/P99 ivn>=200 */

		if (ivn < 200)
			return -1;

		if (protocol == 2 || protocol == 2 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 261:	/* P99 ivn>=200 */

		if (ivn < 200)
			return -1;

		if (protocol == 99)
			return 0;

		break;

	case 264:	/* P01 ivn>=200 */

		if (ivn < 200)
			return -1;

		if (protocol == 1)
			return 0;

		break;

	case 276:	/* P02/P03/P10/P13/P14 ivn>=200 */

		if (ivn < 200)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14)
			return 0;

		break;

	default:

		upsdebugx(2, "%s: unknown value (%s)", __func__, value);
		break;

	}

	return -1;
}

/* Range for Bypass Mode minimum voltage */
static info_rw_t	voltronic_r_bypass_volt_min[] = {
	{ "50", voltronic_bypass_volt_min },	/* P99 ivn<200 */
	{ "55", voltronic_bypass_volt_min },	/* P02/P03/P10/P13/P14 ivn<200 */
	{ "60", voltronic_bypass_volt_min },	/* P09 */
	{ "85", voltronic_bypass_volt_min },	/* P01/P99 ivn<200 */
	{ "104", voltronic_bypass_volt_min },	/* P02/P03/P10/P13/P14 ivn<200 */
	{ "110", voltronic_bypass_volt_min },	/* P02/P03/P10/P13/P14 ivn>=200 */
	{ "115", voltronic_bypass_volt_min },	/* P01 ivn<200 */
	{ "140", voltronic_bypass_volt_min },	/* P09 */
	{ "149", voltronic_bypass_volt_min },	/* P99 ivn>=200 */
	{ "170", voltronic_bypass_volt_min },	/* P01 ivn>=200 */
	{ "209", voltronic_bypass_volt_min },	/* P02/P03/P10/P13/P14/P99 ivn>=200 */
	{ "220", voltronic_bypass_volt_min },	/* P01 ivn>=200 */
	{ "", 0 }
};

/* Preprocess range value for Bypass Mode minimum voltage */
static int	voltronic_bypass_volt_min(char *value, size_t len)
{
	int		protocol = strtol(dstate_getinfo("ups.firmware.aux")+1, NULL, 10),
			val = strtol(value, NULL, 10),
			ivn;
	const char	*involtnom = dstate_getinfo("input.voltage.nominal");

	if (!involtnom) {
		upsdebugx(2, "%s: unable to get input.voltage.nominal", __func__);
		return -1;
	}

	ivn = strtol(involtnom, NULL, 10);

	switch (val)
	{
	case 50:	/* P99 ivn<200 */

		if (ivn >= 200)
			return -1;

		if (protocol == 99)
			return 0;

		break;

	case 55:	/* P02/P03/P10/P13/P14 ivn<200 */

		if (ivn >= 200)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 10 || protocol == 13 || protocol == 14)
			return 0;

		break;

	case 60:	/* P09 */
	case 140:	/* P09 */

		if (protocol == 9)
			return 0;

		break;

	case 85:	/* P01/P99 ivn<200 */

		if (ivn >= 200)
			return -1;

		if (protocol == 1 || protocol == 99)
			return 0;

		break;

	case 104:	/* P02/P03/P10/P13/P14 ivn<200 */

		if (ivn >= 200)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14)
			return 0;

		break;

	case 110:	/* P02/P03/P10/P13/P14 ivn>=200 */

		if (ivn < 200)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14)
			return 0;

		break;

	case 115:	/* P01 ivn<200 */

		if (ivn >= 200)
			return -1;

		if (protocol == 1)
			return 0;

		break;

	case 149:	/* P99 ivn>=200 */

		if (ivn < 200)
			return -1;

		if (protocol == 99)
			return 0;

		break;

	case 170:	/* P01 ivn>=200 */

		if (ivn < 200)
			return -1;

		if (protocol == 1)
			return 0;

		break;

	case 209:	/* P02/P03/P10/P13/P14/P99 ivn>=200 */

		if (ivn < 200)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 220:	/* P01 ivn>=200 */

		if (ivn < 200)
			return -1;

		if (protocol == 1)
			return 0;

		break;

	default:

		upsdebugx(2, "%s: unknown value (%s)", __func__, value);
		break;

	}

	return -1;
}

/* Range for Bypass Mode maximum frequency */
static info_rw_t	voltronic_r_bypass_freq_max[] = {
	{ "51.0", voltronic_bypass_freq_max },	/* P01/P09/P02/P03/P10/P13/P14/P99 ofn==50.0 */
	{ "54.0", voltronic_bypass_freq_max },	/* P02/P03/P10/P13/P14/P99 ofn==50.0 */
	{ "60.0", voltronic_bypass_freq_max },	/* P01/P09 ofn==50.0 */
	{ "61.0", voltronic_bypass_freq_max },	/* P01/P09/P02/P03/P10/P13/P14/P99 ofn==60.0 */
	{ "64.0", voltronic_bypass_freq_max },	/* P02/P03/P10/P13/P14/P99 ofn==60.0 */
	{ "70.0", voltronic_bypass_freq_max },	/* P01/P09 ofn==60.0 */
	{ "", 0 }
};

/* Preprocess range value for Bypass Mode maximum frequency */
static int	voltronic_bypass_freq_max(char *value, size_t len)
{
	int		protocol = strtol(dstate_getinfo("ups.firmware.aux")+1, NULL, 10),
			val = strtol(value, NULL, 10);
	double		ofn;
	const char	*outfreqnom = dstate_getinfo("output.frequency.nominal");

	if (!outfreqnom) {
		upsdebugx(2, "%s: unable to get output.frequency.nominal", __func__);
		return -1;
	}

	ofn = strtod(outfreqnom, NULL);

	switch (val)
	{
	case 51:	/* P01/P09/P02/P03/P10/P13/P14/P99 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 1 || protocol == 2 || protocol == 3 || protocol == 9 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 54:	/* P02/P03/P10/P13/P14/P99 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 60:	/* P01/P09 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 1 || protocol == 9)
			return 0;

		break;

	case 61:	/* P01/P09/P02/P03/P10/P13/P14/P99 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 1 || protocol == 2 || protocol == 3 || protocol == 9 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 64:	/* P02/P03/P10/P13/P14/P99 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 70:	/* P01/P09 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 1 || protocol == 9)
			return 0;

		break;

	default:

		upsdebugx(2, "%s: unknown value (%s)", __func__, value);
		break;

	}

	return -1;
}

/* Range for Bypass Mode minimum frequency */
static info_rw_t	voltronic_r_bypass_freq_min[] = {
	{ "40.0", voltronic_bypass_freq_min },	/* P01/P09 ofn==50.0 */
	{ "46.0", voltronic_bypass_freq_min },	/* P02/P03/P10/P13/P14/P99 ofn==50.0 */
	{ "49.0", voltronic_bypass_freq_min },	/* P01/P09/P02/P03/P10/P13/P14/P99 ofn==50.0 */
	{ "50.0", voltronic_bypass_freq_min },	/* P01/P09 ofn==60.0 */
	{ "56.0", voltronic_bypass_freq_min },	/* P02/P03/P10/P13/P14/P99 ofn==60.0 */
	{ "59.0", voltronic_bypass_freq_min },	/* P01/P09/P02/P03/P10/P13/P14/P99 ofn==60.0 */
	{ "", 0 }
};

/* Preprocess range value for Bypass Mode minimum frequency */
static int	voltronic_bypass_freq_min(char *value, size_t len)
{
	int		protocol = strtol(dstate_getinfo("ups.firmware.aux")+1, NULL, 10),
			val = strtol(value, NULL, 10);
	double		ofn;
	const char	*outfreqnom = dstate_getinfo("output.frequency.nominal");

	if (!outfreqnom) {
		upsdebugx(2, "%s: unable to get output.frequency.nominal", __func__);
		return -1;
	}

	ofn = strtod(outfreqnom, NULL);

	switch (val)
	{
	case 40:	/* P01/P09 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 1 || protocol == 9)
			return 0;

		break;

	case 46:	/* P02/P03/P10/P13/P14/P99 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 49:	/* P01/P09/P02/P03/P10/P13/P14/P99 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 1 || protocol == 2 || protocol == 3 || protocol == 9 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 50:	/* P01/P09 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 1 || protocol == 9)
			return 0;

		break;

	case 56:	/* P02/P03/P10/P13/P14/P99 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 59:	/* P01/P09/P02/P03/P10/P13/P14/P99 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 1 || protocol == 2 || protocol == 3 || protocol == 9 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	default:

		upsdebugx(2, "%s: unknown value (%s)", __func__, value);
		break;

	}

	return -1;
}

/* Range for Eco Mode maximum voltage: filled at runtime by voltronic_eco_volt */
static info_rw_t	voltronic_r_eco_volt_max[] = {
	{ "", 0 },
	{ "", 0 },
	{ "", 0 }
};

/* Range for ECO Mode minimum voltage: filled at runtime by voltronic_eco_volt */
static info_rw_t	voltronic_r_eco_volt_min[] = {
	{ "", 0 },
	{ "", 0 },
	{ "", 0 }
};

/* Range for ECO Mode minimum frequency */
static info_rw_t	voltronic_r_eco_freq_min[] = {
	{ "40.0", voltronic_eco_freq_min },	/* P01/P09 ofn==50.0 */
	{ "46.0", voltronic_eco_freq_min },	/* P02/P03/P10/P13/P14/P99 ofn==50.0 */
	{ "47.0", voltronic_eco_freq_min },	/* P01/P09 ofn==50.0 */
	{ "48.0", voltronic_eco_freq_min },	/* P02/P03/P10/P13/P14/P99 ofn==50.0 */
	{ "50.0", voltronic_eco_freq_min },	/* P01/P09 ofn==60.0 */
	{ "56.0", voltronic_eco_freq_min },	/* P02/P03/P10/P13/P14/P99 ofn==60.0 */
	{ "57.0", voltronic_eco_freq_min },	/* P01/P09 ofn==60.0 */
	{ "58.0", voltronic_eco_freq_min },	/* P02/P03/P10/P13/P14/P99 ofn==60.0 */
	{ "", 0 }
};

/* Preprocess range value for ECO Mode minimum frequency */
static int	voltronic_eco_freq_min(char *value, size_t len)
{
	int		protocol = strtol(dstate_getinfo("ups.firmware.aux")+1, NULL, 10),
			val = strtol(value, NULL, 10);
	double		ofn;
	const char	*outfreqnom = dstate_getinfo("output.frequency.nominal");

	if (!outfreqnom) {
		upsdebugx(2, "%s: unable to get output.frequency.nominal", __func__);
		return -1;
	}

	ofn = strtod(outfreqnom, NULL);

	switch (val)
	{
	case 40:	/* P01/P09 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 1 || protocol == 9)
			return 0;

		break;

	case 46:	/* P02/P03/P10/P13/P14/P99 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 47:	/* P01/P09 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 1 || protocol == 9)
			return 0;

		break;

	case 48:	/* P02/P03/P10/P13/P14/P99 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 50:	/* P01/P09 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 1 || protocol == 9)
			return 0;

		break;

	case 56:	/* P02/P03/P10/P13/P14/P99 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 57:	/* P01/P09 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 1 || protocol == 9)
			return 0;

		break;

	case 58:	/* P02/P03/P10/P13/P14/P99 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	default:

		upsdebugx(2, "%s: unknown value (%s)", __func__, value);
		break;

	}

	return -1;
}

/* Range for ECO Mode maximum frequency */
static info_rw_t	voltronic_r_eco_freq_max[] = {
	{ "52.0", voltronic_eco_freq_max },	/* P02/P03/P10/P13/P14/P99 ofn==50.0 */
	{ "53.0", voltronic_eco_freq_max },	/* P01/P09 ofn==50.0 */
	{ "54.0", voltronic_eco_freq_max },	/* P02/P03/P10/P13/P14/P99 ofn==50.0 */
	{ "60.0", voltronic_eco_freq_max },	/* P01/P09 ofn==50.0 */
	{ "62.0", voltronic_eco_freq_max },	/* P02/P03/P10/P13/P14/P99 ofn==60.0 */
	{ "63.0", voltronic_eco_freq_max },	/* P01/P09 ofn==60.0 */
	{ "64.0", voltronic_eco_freq_max },	/* P02/P03/P10/P13/P14/P99 ofn==60.0 */
	{ "70.0", voltronic_eco_freq_max },	/* P01/P09 ofn==60.0 */
	{ "", 0 }
};

/* Preprocess range value for ECO Mode maximum frequency */
static int	voltronic_eco_freq_max(char *value, size_t len)
{
	int		protocol = strtol(dstate_getinfo("ups.firmware.aux")+1, NULL, 10),
			val = strtol(value, NULL, 10);
	double		ofn;
	const char	*outfreqnom = dstate_getinfo("output.frequency.nominal");

	if (!outfreqnom) {
		upsdebugx(2, "%s: unable to get output.frequency.nominal", __func__);
		return -1;
	}

	ofn = strtod(outfreqnom, NULL);

	switch (val)
	{
	case 52:	/* P02/P03/P10/P13/P14/P99 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 53:	/* P01/P09 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 1 || protocol == 9)
			return 0;

		break;

	case 54:	/* P02/P03/P10/P13/P14/P99 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 60:	/* P01/P09 ofn==50.0 */

		if (ofn != 50.0)
			return -1;

		if (protocol == 1 || protocol == 9)
			return 0;

		break;

	case 62:	/* P02/P03/P10/P13/P14/P99 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 63:	/* P01/P09 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 1 || protocol == 9)
			return 0;

		break;

	case 64:	/* P02/P03/P10/P13/P14/P99 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99)
			return 0;

		break;

	case 70:	/* P01/P09 ofn==60.0 */

		if (ofn != 60.0)
			return -1;

		if (protocol == 1 || protocol == 9)
			return 0;

		break;

	default:

		upsdebugx(2, "%s: unknown value (%s)", __func__, value);
		break;

	}

	return -1;
}

/* Enumlist for UPS capabilities that have a NUT var */
static info_rw_t	voltronic_e_cap[] = {
	{ "no", 0 },
	{ "yes", 0 },
	{ "", 0 }
};

/* Enumlist for NONUT capabilities */
static info_rw_t	voltronic_e_cap_nonut[] = {
	{ "enabled", 0 },
	{ "disabled", 0 },
	{ "", 0 }
};


/* == qx2nut lookup table == */
static item_t	voltronic_qx2nut[] = {

	/* Query UPS for protocol
	 * > [QPI\r]
	 * < [(PI00\r]
	 *    012345
	 *    0
	 */

	{ "ups.firmware.aux",		0,	NULL,	"QPI\r",	"",	6,	'(',	"",	1,	4,	"%s",	QX_FLAG_STATIC,	NULL,	voltronic_protocol },

	/* Query UPS for ratings
	 * > [QRI\r]
	 * < [(230.0 004 024.0 50.0\r]
	 *    0123456789012345678901
	 *    0         1         2
	 */

	{ "output.voltage.nominal",	0,	NULL,	"QRI\r",	"",	22,	'(',	"",	1,	5,	"%.1f",	QX_FLAG_STATIC,		NULL,	NULL },
	{ "output.current.nominal",	0,	NULL,	"QRI\r",	"",	22,	'(',	"",	7,	9,	"%.0f",	QX_FLAG_STATIC,		NULL,	NULL },
	{ "battery.voltage.nominal",	0,	NULL,	"QRI\r",	"",	22,	'(',	"",	11,	15,	"%.1f",	QX_FLAG_SEMI_STATIC,	NULL,	NULL },	/* as *per battery pack*: the value will change when the number of batteries is changed (battery_number through BATNn) */
	{ "output.frequency.nominal",	0,	NULL,	"QRI\r",	"",	22,	'(',	"",	17,	20,	"%.1f",	QX_FLAG_STATIC,		NULL,	NULL },

	/* Query UPS for ratings
	 * > [QMD\r]
	 * < [(#######OLHVT1K0 ###1000 80 1/1 230 230 02 12.0\r]	<- Some UPS may reply with spaces instead of hashes
	 *    012345678901234567890123456789012345678901234567
	 *    0         1         2         3         4
	 */

	{ "device.model",		0,	NULL,	"QMD\r",	"",	48,	'(',	"",	1,	15,	"%s",	QX_FLAG_STATIC | QX_FLAG_TRIM,	NULL,	NULL },
	{ "ups.power.nominal",		0,	NULL,	"QMD\r",	"",	48,	'(',	"",	17,	23,	"%s",	QX_FLAG_STATIC | QX_FLAG_TRIM,	NULL,	NULL },
	{ "output.powerfactor",		0,	NULL,	"QMD\r",	"",	48,	'(',	"",	25,	26,	"%.1f",	QX_FLAG_STATIC,	NULL,	voltronic_output_powerfactor },
	{ "input.phases",		0,	NULL,	"QMD\r",	"",	48,	'(',	"",	28,	28,	"%.0f",	QX_FLAG_STATIC,	NULL,	NULL },
	{ "output.phases",		0,	NULL,	"QMD\r",	"",	48,	'(',	"",	30,	30,	"%.0f",	QX_FLAG_STATIC,	NULL,	NULL },
	{ "input.voltage.nominal",	0,	NULL,	"QMD\r",	"",	48,	'(',	"",	32,	34,	"%.1f",	QX_FLAG_STATIC,	NULL,	NULL },
	{ "output.voltage.nominal",	0,	NULL,	"QMD\r",	"",	48,	'(',	"",	36,	38,	"%.1f",	QX_FLAG_STATIC,	NULL,	NULL },	/* redundant with value from QRI */
/*	{ "battery_number",		ST_FLAG_RW,	voltronic_r_batt_numb,	"QMD\r",	"",	48,	'(',	"",	40,	41,	"%d",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_NONUT,	NULL,	voltronic_batt_numb },	*//* redundant with value from QBV */
/*	{ "battery.voltage.nominal",	0,	NULL,	"QMD\r",	"",	48,	'(',	"",	43,	46,	"%.1f",	QX_FLAG_STATIC,	NULL,	NULL },	*//* as *per battery* vs *per pack* reported by QRI */

	/* Query UPS for ratings
	 * > [F\r]
	 * < [#220.0 000 024.0 50.0\r]
	 *    0123456789012345678901
	 *    0         1         2
	 */

	{ "input.voltage.nominal",	0,	NULL,	"F\r",	"",	22,	'#',	"",	1,	5,	"%.1f",	QX_FLAG_STATIC,	NULL,	NULL },
	{ "input.current.nominal",	0,	NULL,	"F\r",	"",	22,	'#',	"",	7,	9,	"%.1f",	QX_FLAG_STATIC,	NULL,	NULL },
	{ "battery.voltage.nominal",	0,	NULL,	"F\r",	"",	22,	'#',	"",	11,	15,	"%.1f",	QX_FLAG_STATIC,	NULL,	NULL },
	{ "input.frequency.nominal",	0,	NULL,	"F\r",	"",	22,	'#',	"",	17,	20,	"%.1f",	QX_FLAG_STATIC,	NULL,	NULL },

	/* Query UPS for manufacturer
	 * > [QMF\r]
	 * < [(#######BOH\r]	<- I don't know if it has a fixed length (-> so min length = ( + \r = 2). Hashes may be replaced by spaces
	 *    012345678901
	 *    0         1
	 */

	{ "device.mfr",		0,	NULL,	"QMF\r",	"",	2,	'(',	"",	1,	0,	"%s",	QX_FLAG_STATIC | QX_FLAG_TRIM,	NULL,	NULL },

	/* Query UPS for firmware version
	 * > [QVFW\r]
	 * < [(VERFW:00322.02\r]
	 *    0123456789012345
	 *    0         1
	 */

	{ "ups.firmware",	0,	NULL,	"QVFW\r",	"",	16,	'(',	"",	7,	14,	"%s",	QX_FLAG_STATIC,	NULL,	NULL },

	/* Query UPS for serial number
	 * > [QID\r]
	 * < [(12345679012345\r]	<- As far as I know it hasn't a fixed length -> min length = ( + \r = 2
	 *    0123456789012345
	 *    0         1
	 */

	{ "device.serial",	0,	NULL,	"QID\r",	"",	2,	'(',	"",	1,	0,	"%s",	QX_FLAG_STATIC,	NULL,	voltronic_serial_numb },

	/* Query UPS for vendor infos
	 * > [I\r]
	 * < [#-------------   ------     VT12046Q  \r]
	 *    012345678901234567890123456789012345678
	 *    0         1         2         3
	 */

	{ "device.mfr",		0,	NULL,	"I\r",	"",	39,	'#',	"",	1,	15,	"%s",	QX_FLAG_STATIC | QX_FLAG_TRIM,	NULL,	NULL },
	{ "device.model",	0,	NULL,	"I\r",	"",	39,	'#',	"",	17,	26,	"%s",	QX_FLAG_STATIC | QX_FLAG_TRIM,	NULL,	NULL },
	{ "ups.firmware",	0,	NULL,	"I\r",	"",	39,	'#',	"",	28,	37,	"%s",	QX_FLAG_STATIC | QX_FLAG_TRIM,	NULL,	NULL },

	/* Query UPS for status
	 * > [QGS\r]
	 * < [(234.9 50.0 229.8 50.0 000.0 000 369.1 ---.- 026.5 ---.- 018.8 100000000001\r]
	 *    0123456789012345678901234567890123456789012345678901234567890123456789012345
	 *    0         1         2         3         4         5         6         7
	 */

	{ "input.voltage",	0,	NULL,	"QGS\r",	"",	76,	'(',	"",	1,	5,	"%.1f",	0,	NULL,	NULL },
	{ "input.frequency",	0,	NULL,	"QGS\r",	"",	76,	'(',	"",	7,	10,	"%.1f",	0,	NULL,	NULL },
	{ "output.voltage",	0,	NULL,	"QGS\r",	"",	76,	'(',	"",	12,	16,	"%.1f",	0,	NULL,	NULL },
	{ "output.frequency",	0,	NULL,	"QGS\r",	"",	76,	'(',	"",	18,	21,	"%.1f",	0,	NULL,	NULL },
	{ "output.current",	0,	NULL,	"QGS\r",	"",	76,	'(',	"",	23,	27,	"%.1f",	0,	NULL,	NULL },
	{ "ups.load",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	29,	31,	"%.0f",	0,	NULL,	NULL },
/*	{ "unknown.1",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	33,	37,	"%.1f",	0,	NULL,	NULL },	*//* Unknown */
/*	{ "unknown.2",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	39,	43,	"%.1f",	0,	NULL,	NULL },	*//* Unknown */
	{ "battery.voltage",	0,	NULL,	"QGS\r",	"",	76,	'(',	"",	45,	49,	"%.2f",	0,	NULL,	NULL },
/*	{ "unknown.3",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	51,	55,	"%.1f",	0,	NULL,	NULL },	*//* Unknown */
	{ "ups.temperature",	0,	NULL,	"QGS\r",	"",	76,	'(',	"",	57,	61,	"%.1f",	0,	NULL,	NULL },
	{ "ups.type",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	63,	64,	"%s",	QX_FLAG_SEMI_STATIC,	NULL,	voltronic_status },
	{ "ups.status",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	65,	65,	"%s",	QX_FLAG_QUICK_POLL,	NULL,	voltronic_status },	/* Utility Fail (Immediate) */
	{ "ups.status",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	66,	66,	"%s",	QX_FLAG_QUICK_POLL,	NULL,	voltronic_status },	/* Battery Low */
	{ "ups.status",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	67,	67,	"%s",	QX_FLAG_QUICK_POLL,	NULL,	voltronic_status },	/* Bypass/Boost or Buck Active */
	{ "ups.alarm",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	67,	67,	"%s",	0,			NULL,	voltronic_status },	/* Bypass/Boost or Buck Active */
	{ "ups.alarm",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	68,	68,	"%s",	0,			NULL,	voltronic_status },	/* UPS Fault */
/*	{ "unknown.4",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	69,	69,	"%s",	0,			NULL,	voltronic_status },	*//* Unknown */
	{ "ups.status",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	70,	70,	"%s",	QX_FLAG_QUICK_POLL,	NULL,	voltronic_status },	/* Test in Progress */
	{ "ups.status",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	71,	71,	"%s",	QX_FLAG_QUICK_POLL,	NULL,	voltronic_status },	/* Shutdown Active */
	{ "ups.beeper.status",	0,	NULL,	"QGS\r",	"",	76,	'(',	"",	72,	72,	"%s",	0,			NULL,	voltronic_status },	/* Beeper status - ups.beeper.status */
/*	{ "unknown.5",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	73,	73,	"%s",	0,			NULL,	voltronic_status },	*//* Unknown */
/*	{ "unknown.6",		0,	NULL,	"QGS\r",	"",	76,	'(',	"",	74,	74,	"%s",	0,			NULL,	voltronic_status },	*//* Unknown */

	/* Query UPS for actual working mode
	 * > [QMOD\r]
	 * < [(S\r]
	 *    012
	 *    0
	 */

	{ "ups.alarm",		0,	NULL,	"QMOD\r",	"",	3,	'(',	"",	1,	1,	"%s",	0,	NULL,	voltronic_mode },
	{ "ups.status",		0,	NULL,	"QMOD\r",	"",	3,	'(',	"",	1,	1,	"%s",	0,	NULL,	voltronic_mode },

	/* Query UPS for faults and their type. Unskipped when a fault is found in 12bit flag of QGS, otherwise you'll get a fake reply.
	 * > [QFS\r]
	 * < [(OK\r] <- No fault
	 *    0123
	 *    0
	 * < [(14 212.1 50.0 005.6 49.9 006 010.6 343.8 ---.- 026.2 021.8 01101100\r] <- Fault type + Short status
	 *    012345678901234567890123456789012345678901234567890123456789012345678
	 *    0         1         2         3         4         5         6
	 */

	{ "ups.alarm",		0,	NULL,	"QFS\r",	"",	4,	'(',	"",	1,	2,	"%s",	QX_FLAG_SKIP,	NULL,	voltronic_fault },

	/* Query UPS for warnings and their type
	 * > [QWS\r]
	 * < [(0000000100000000000000000000000000000000000000000000000000000000\r]
	 *    012345678901234567890123456789012345678901234567890123456789012345
	 *    0         1         2         3         4         5         6
	 */

	{ "ups.alarm",		0,	NULL,	"QWS\r",	"",	66,	'(',	"",	1,	64,	"%s",	0,	NULL,	voltronic_warning },

	/* Query UPS for actual infos about battery
	 * > [QBV\r]
	 * < [(026.5 02 01 068 255\r]
	 *    012345678901234567890
	 *    0         1         2
	 */

	{ "battery.voltage",	0,		NULL,			"QBV\r",	"",	21,	'(',	"",	1,	5,	"%.2f",	0,	NULL,	NULL },
	{ "battery_number",	ST_FLAG_RW,	voltronic_r_batt_numb,	"QBV\r",	"",	21,	'(',	"",	7,	9,	"%d",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_NONUT,	NULL,	voltronic_batt_numb },	/* Number of batteries that make a pack */
	{ "battery.packs",	ST_FLAG_RW,	voltronic_r_batt_packs,	"QBV\r",	"",	21,	'(',	"",	10,	11,	"%.0f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE,	NULL,	NULL },	/* Number of battery packs in parallel */
	{ "battery.charge",	0,		NULL,			"QBV\r",	"",	21,	'(',	"",	13,	15,	"%.0f",	0,	NULL,	NULL },
	{ "battery.runtime",	0,		NULL,			"QBV\r",	"",	21,	'(',	"",	17,	19,	"%.0f",	0,	NULL,	voltronic_batt_runtime },

	/* Query UPS for last seen min/max load level
	 * > [QLDL\r]
	 * < [(021 023\r]	<- minimum load level - maximum load level
	 *    012345678
	 *    0
	 */

	{ "output.power.minimum.percent",	0,	NULL,	"QLDL\r",	"",	9,	'(',	"",	1,	3,	"%.0f",	0,	NULL,	NULL },
	{ "output.power.maximum.percent",	0,	NULL,	"QLDL\r",	"",	9,	'(',	"",	5,	7,	"%.0f",	0,	NULL,	NULL },

	/* Query UPS for multi-phase voltages/frequencies
	 * > [Q3**\r]
	 * < [(123.4 123.4 123.4 123.4 123.4 123.4\r]	<- Q3PV
	 * < [(123.4 123.4 123.4 123.4 123.4 123.4\r]	<- Q3OV
	 * < [(123 123 123\r]	<- Q3PC
	 * < [(123 123 123\r]	<- Q3OC
	 * < [(123 123 123\r]	<- Q3LD
	 * < [(123.4 123.4 123.4\r]	<- Q3YV - P09 protocol
	 * < [(123.4 123.4 123.4 123.4 123.4 123.4\r]	<- Q3YV - P10/P03 protocols
	 *    0123456789012345678901234567890123456
	 *    0         1         2         3
	 *
	 * P09 = 2-phase input/2-phase output
	 * Q3PV	(Input Voltage L1 | Input Voltage L2 | Input Voltage L3 | Input Voltage L1-L2 | Input Voltage L1-L3 | Input Voltage L2-L3
	 * Q3OV	(Output Voltage L1 | Output Voltage L2 | Output Voltage L3 | Output Voltage L1-L2 | Output Voltage L1-L3 | Output Voltage L2-L3
	 * Q3PC	(Input Current L1 | Input Current L2 | Input Current L3
	 * Q3OC	(Output Current L1 | Output Current L2 | Output Current L3
	 * Q3LD	(Output Load Level L1 | Output Load Level L2 | Output Load Level L3
	 * Q3YV	(Output Bypass Voltage L1 | Output Bypass Voltage L2 | Output Bypass Voltage L3
	 *
	 * P10 = 3-phase input/3-phase output / P03 = 3-phase input/ 1-phase output
	 * Q3PV	(Input Voltage L1 | Input Voltage L2 | Input Voltage L3 | Input Voltage L1-L2 | Input Voltage L2-L3 | Input Voltage L1-L3
	 * Q3OV	(Output Voltage L1 | Output Voltage L2 | Output Voltage L3 | Output Voltage L1-L2 | Output Voltage L2-L3 | Output Voltage L1-L3
	 * Q3PC	(Input Current L1 | Input Current L2 | Input Current L3
	 * Q3OC	(Output Current L1 | Output Current L2 | Output Current L3
	 * Q3LD	(Output Load Level L1 | Output Load Level L2 | Output Load Level L3
	 * Q3YV	(Output Bypass Voltage L1 | Output Bypass Voltage L2 | Output Bypass Voltage L3 | Output Bypass Voltage L1-L2 | Output Bypass Voltage L2-L3 | Output Bypass Voltage L1-L3
	 *
	 */

	/*	From Q3PV	*/
	{ "input.L1-N.voltage",			0,	NULL,	"Q3PV\r",	"",	37,	'(',	"",	1,	5,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "input.L2-N.voltage",			0,	NULL,	"Q3PV\r",	"",	37,	'(',	"",	7,	11,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "input.L3-N.voltage",			0,	NULL,	"Q3PV\r",	"",	37,	'(',	"",	13,	17,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "input.L1-L2.voltage",		0,	NULL,	"Q3PV\r",	"",	37,	'(',	"",	19,	23,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "input.L2-L3.voltage",		0,	NULL,	"Q3PV\r",	"",	37,	'(',	"",	25,	29,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "input.L1-L3.voltage",		0,	NULL,	"Q3PV\r",	"",	37,	'(',	"",	31,	35,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
/*	{ "input.L1-L3.voltage",		0,	NULL,	"Q3PV\r",	"",	37,	'(',	"",	25,	29,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },	*//* P09 *//* Commented out because P09 should be two-phase input/output UPSes */
/*	{ "input.L2-L3.voltage",		0,	NULL,	"Q3PV\r",	"",	37,	'(',	"",	31,	35,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },	*//* P09 *//* Commented out because P09 should be two-phase input/output UPSes */

	/*	From Q3PC	*/
	{ "input.L1.current",			0,	NULL,	"Q3PC\r",	"",	13,	'(',	"",	1,	3,	"%.0f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "input.L2.current",			0,	NULL,	"Q3PC\r",	"",	13,	'(',	"",	5,	7,	"%.0f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "input.L3.current",			0,	NULL,	"Q3PC\r",	"",	13,	'(',	"",	9,	11,	"%.0f",	QX_FLAG_SKIP,	NULL,	NULL },

	/*	From Q3OV	*/
	{ "output.L1-N.voltage",		0,	NULL,	"Q3OV\r",	"",	37,	'(',	"",	1,	5,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.L2-N.voltage",		0,	NULL,	"Q3OV\r",	"",	37,	'(',	"",	7,	11,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.L3-N.voltage",		0,	NULL,	"Q3OV\r",	"",	37,	'(',	"",	13,	17,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.L1-L2.voltage",		0,	NULL,	"Q3OV\r",	"",	37,	'(',	"",	19,	23,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.L2-L3.voltage",		0,	NULL,	"Q3OV\r",	"",	37,	'(',	"",	25,	29,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.L1-L3.voltage",		0,	NULL,	"Q3OV\r",	"",	37,	'(',	"",	31,	35,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
/*	{ "output.L1-L3.voltage",		0,	NULL,	"Q3OV\r",	"",	37,	'(',	"",	25,	29,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },	*//* P09 *//* Commented out because P09 should be two-phase input/output UPSes */
/*	{ "output.L2-L3.voltage",		0,	NULL,	"Q3OV\r",	"",	37,	'(',	"",	31,	35,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },	*//* P09 *//* Commented out because P09 should be two-phase input/output UPSes */

	/*	From Q3OC	*/
	{ "output.L1.current",			0,	NULL,	"Q3OC\r",	"",	13,	'(',	"",	1,	3,	"%.0f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.L2.current",			0,	NULL,	"Q3OC\r",	"",	13,	'(',	"",	5,	7,	"%.0f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.L3.current",			0,	NULL,	"Q3OC\r",	"",	13,	'(',	"",	9,	11,	"%.0f",	QX_FLAG_SKIP,	NULL,	NULL },

	/*	From Q3LD	*/
	{ "output.L1.power.percent",		0,	NULL,	"Q3LD\r",	"",	13,	'(',	"",	1,	3,	"%.0f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.L2.power.percent",		0,	NULL,	"Q3LD\r",	"",	13,	'(',	"",	5,	7,	"%.0f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.L3.power.percent",		0,	NULL,	"Q3LD\r",	"",	13,	'(',	"",	9,	11,	"%.0f",	QX_FLAG_SKIP,	NULL,	NULL },

	/*	From Q3YV	*/
	{ "output.bypass.L1-N.voltage",		0,	NULL,	"Q3YV\r",	"",	37,	'(',	"",	1,	5,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.bypass.L2-N.voltage",		0,	NULL,	"Q3YV\r",	"",	37,	'(',	"",	7,	11,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.bypass.L3-N.voltage",		0,	NULL,	"Q3YV\r",	"",	37,	'(',	"",	13,	17,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.bypass.L1-N.voltage",		0,	NULL,	"Q3YV\r",	"",	19,	'(',	"",	1,	5,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },	/* P09 */
	{ "output.bypass.L2-N.voltage",		0,	NULL,	"Q3YV\r",	"",	19,	'(',	"",	7,	11,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },	/* P09 */
/*	{ "output.bypass.L3-N.voltage",		0,	NULL,	"Q3YV\r",	"",	19,	'(',	"",	13,	17,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },	*//* P09 *//* Commented out because P09 should be two-phase input/output UPSes */
	{ "output.bypass.L1-L2.voltage",	0,	NULL,	"Q3YV\r",	"",	37,	'(',	"",	19,	23,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.bypass.L2-L3.voltage",	0,	NULL,	"Q3YV\r",	"",	37,	'(',	"",	25,	29,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },
	{ "output.bypass.L1-L3.voltage",	0,	NULL,	"Q3YV\r",	"",	37,	'(',	"",	31,	35,	"%.1f",	QX_FLAG_SKIP,	NULL,	NULL },

	/* Query UPS for capability - total options available: 23; only those whom the UPS is capable of are reported as Enabled or Disabled
	 * > [QFLAG\r]
	 * < [(EpashcDbroegfl\r]
	 *    0123456789012345
	 *    0         1	* min length = ( + E + D + \r = 4
	 */

	{ "ups.start.auto",		ST_FLAG_RW,	voltronic_e_cap,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_ENUM,	NULL,	voltronic_capability },
	{ "battery.protection",		ST_FLAG_RW,	voltronic_e_cap,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_ENUM,	NULL,	voltronic_capability },
	{ "battery.energysave",		ST_FLAG_RW,	voltronic_e_cap,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_ENUM,	NULL,	voltronic_capability },
	{ "ups.start.battery",		ST_FLAG_RW,	voltronic_e_cap,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_ENUM,	NULL,	voltronic_capability },
	{ "outlet.0.switchable",	ST_FLAG_RW,	voltronic_e_cap,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_ENUM,	NULL,	voltronic_capability },
	/* Not available in NUT */
	{ "bypass_alarm",		0,	NULL,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_NONUT,	NULL,	voltronic_capability },
	{ "battery_alarm",		0,	NULL,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_NONUT,	NULL,	voltronic_capability },
	{ "bypass_when_off",		0,	NULL,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_NONUT,	NULL,	voltronic_capability },
	{ "alarm_control",		0,	NULL,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_NONUT,	NULL,	voltronic_capability },
	{ "converter_mode",		0,	NULL,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_NONUT,	NULL,	voltronic_capability },
	{ "eco_mode",			0,	NULL,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_NONUT,	NULL,	voltronic_capability },
	{ "battery_open_status_check",	0,	NULL,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_NONUT,	NULL,	voltronic_capability },
	{ "bypass_forbidding",		0,	NULL,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_NONUT,	NULL,	voltronic_capability },
	{ "site_fault_detection",	0,	NULL,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_NONUT,	NULL,	voltronic_capability },
	{ "advanced_eco_mode",		0,	NULL,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_NONUT,	NULL,	voltronic_capability },
	{ "constant_phase_angle",	0,	NULL,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_NONUT,	NULL,	voltronic_capability },
	{ "limited_runtime_on_battery",	0,	NULL,	"QFLAG\r",	"",	4,	'(',	"",	1,	0,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_NONUT,	NULL,	voltronic_capability },

	/*   Enable	or	  Disable	or	Reset to safe default values	capability options
	 * > [PEX\r]		> [PDX\r]		> [PF\r]
	 * < [(ACK\r]		< [(ACK\r]		< [(ACK\r]
	 *    01234		   01234		   01234
	 *    0			   0			   0
	 */

	{ "ups.start.auto",		0,	voltronic_e_cap,	"P%sR\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_SKIP,	NULL,	voltronic_capability_set },
	{ "battery.protection",		0,	voltronic_e_cap,	"P%sS\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_SKIP,	NULL,	voltronic_capability_set },
	{ "battery.energysave",		0,	voltronic_e_cap,	"P%sG\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_SKIP,	NULL,	voltronic_capability_set },
	{ "ups.start.battery",		0,	voltronic_e_cap,	"P%sC\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_SKIP,	NULL,	voltronic_capability_set },
	{ "outlet.0.switchable",	0,	voltronic_e_cap,	"P%sJ\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_SKIP,	NULL,	voltronic_capability_set },
	/* Not available in NUT */
	{ "reset_to_default",		0,	NULL,			"PF\r",		"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_capability_reset },
	{ "bypass_alarm",		0,	voltronic_e_cap_nonut,	"P%sP\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_capability_set_nonut },
	{ "battery_alarm",		0,	voltronic_e_cap_nonut,	"P%sB\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_capability_set_nonut },
	{ "bypass_when_off",		0,	voltronic_e_cap_nonut,	"P%sO\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_capability_set_nonut },
	{ "alarm_control",		0,	voltronic_e_cap_nonut,	"P%sA\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_capability_set_nonut },
	{ "converter_mode",		0,	voltronic_e_cap_nonut,	"P%sV\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_capability_set_nonut },
	{ "eco_mode",			0,	voltronic_e_cap_nonut,	"P%sE\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_capability_set_nonut },
	{ "battery_open_status_check",	0,	voltronic_e_cap_nonut,	"P%sD\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_capability_set_nonut },
	{ "bypass_forbidding",		0,	voltronic_e_cap_nonut,	"P%sF\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_capability_set_nonut },
	{ "site_fault_detection",	0,	voltronic_e_cap_nonut,	"P%sL\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_capability_set_nonut },
	{ "advanced_eco_mode",		0,	voltronic_e_cap_nonut,	"P%sN\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_capability_set_nonut },
	{ "constant_phase_angle",	0,	voltronic_e_cap_nonut,	"P%sQ\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_capability_set_nonut },
	{ "limited_runtime_on_battery",	0,	voltronic_e_cap_nonut,	"P%sW\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_capability_set_nonut },

	/* Query UPS for programmable outlet (1-4) status
	 * > [QSK1\r]
	 * < [(1\r]	<- if outlet is on -> (1 , if off -> (0 ; (NAK -> outlet is not programmable
	 *    012
	 *    0
	 */

	{ "outlet.1.switchable",	0,	NULL,	"QSK1\r",	"",	3,	'(',	"",	1,	1,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_SKIP,	NULL,	voltronic_outlet },
	{ "outlet.1.status",		0,	NULL,	"QSK1\r",	"",	3,	'(',	"",	1,	1,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_SKIP,	NULL,	voltronic_outlet },
	{ "outlet.2.switchable",	0,	NULL,	"QSK2\r",	"",	3,	'(',	"",	1,	1,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_SKIP,	NULL,	voltronic_outlet },
	{ "outlet.2.status",		0,	NULL,	"QSK2\r",	"",	3,	'(',	"",	1,	1,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_SKIP,	NULL,	voltronic_outlet },
	{ "outlet.3.switchable",	0,	NULL,	"QSK3\r",	"",	3,	'(',	"",	1,	1,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_SKIP,	NULL,	voltronic_outlet },
	{ "outlet.3.status",		0,	NULL,	"QSK3\r",	"",	3,	'(',	"",	1,	1,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_SKIP,	NULL,	voltronic_outlet },
	{ "outlet.4.switchable",	0,	NULL,	"QSK4\r",	"",	3,	'(',	"",	1,	1,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_SKIP,	NULL,	voltronic_outlet },
	{ "outlet.4.status",		0,	NULL,	"QSK4\r",	"",	3,	'(',	"",	1,	1,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_SKIP,	NULL,	voltronic_outlet },

	/* Query UPS for programmable outlet n (1-4) delay time before it shuts down the load when on battery mode
	 * > [QSKT1\r]
	 * < [(008\r]	<- if delay time is set (by PSK[1-4]n) it'll report n (minutes) otherwise it'll report (NAK (also if outlet is not programmable)
	 *    01234
	 *    0
	 */

	{ "outlet.1.delay.shutdown",	ST_FLAG_RW,	voltronic_r_outlet_delay,	"QSKT1\r",	"",	5,	'(',	"",	1,	3,	"%.0f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_outlet_delay },
	{ "outlet.2.delay.shutdown",	ST_FLAG_RW,	voltronic_r_outlet_delay,	"QSKT2\r",	"",	5,	'(',	"",	1,	3,	"%.0f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_outlet_delay },
	{ "outlet.3.delay.shutdown",	ST_FLAG_RW,	voltronic_r_outlet_delay,	"QSKT3\r",	"",	5,	'(',	"",	1,	3,	"%.0f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_outlet_delay },
	{ "outlet.4.delay.shutdown",	ST_FLAG_RW,	voltronic_r_outlet_delay,	"QSKT4\r",	"",	5,	'(',	"",	1,	3,	"%.0f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_outlet_delay },

	/* Set delay time for programmable outlets
	 * > [PSK1nnn\r]	n = 0..9
	 * < [(ACK\r]
	 *    01234
	 *    0
	 */

	{ "outlet.1.delay.shutdown",	0,	voltronic_r_outlet_delay,	"PSK1%03d\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_outlet_delay_set },
	{ "outlet.2.delay.shutdown",	0,	voltronic_r_outlet_delay,	"PSK2%03d\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_outlet_delay_set },
	{ "outlet.3.delay.shutdown",	0,	voltronic_r_outlet_delay,	"PSK3%03d\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_outlet_delay_set },
	{ "outlet.4.delay.shutdown",	0,	voltronic_r_outlet_delay,	"PSK4%03d\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_outlet_delay_set },

	/* Query UPS for ECO Mode voltage limits
	 * > [QHE\r]
	 * < [(242 218\r]
	 *    012345678
	 *    0
	 */

	{ "input.transfer.high",	ST_FLAG_RW,	voltronic_r_eco_volt_max,	"QHE\r",	"",	9,	'(',	"",	1,	3,	"%.0f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_eco_volt },
	{ "input.transfer.low",		ST_FLAG_RW,	voltronic_r_eco_volt_min,	"QHE\r",	"",	9,	'(',	"",	5,	7,	"%.0f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_eco_volt },
	{ "input.transfer.low.min",	0,		NULL,				"QHE\r",	"",	9,	'(',	"",	5,	7,	"%.0f",	QX_FLAG_SEMI_STATIC | QX_FLAG_SKIP,			NULL,	voltronic_eco_volt_range },
	{ "input.transfer.low.max",	0,		NULL,				"QHE\r",	"",	9,	'(',	"",	5,	7,	"%.0f",	QX_FLAG_SEMI_STATIC | QX_FLAG_SKIP,			NULL,	voltronic_eco_volt_range },
	{ "input.transfer.high.min",	0,		NULL,				"QHE\r",	"",	9,	'(',	"",	1,	3,	"%.0f",	QX_FLAG_SEMI_STATIC | QX_FLAG_SKIP,			NULL,	voltronic_eco_volt_range },
	{ "input.transfer.high.max",	0,		NULL,				"QHE\r",	"",	9,	'(',	"",	1,	3,	"%.0f",	QX_FLAG_SEMI_STATIC | QX_FLAG_SKIP,			NULL,	voltronic_eco_volt_range },

	/* Set ECO Mode voltage limits
	 * > [HEHnnn\r]		> [HELnnn\r]		n = 0..9
	 * < [(ACK\r]		< [(ACK\r]
	 *    01234		   01234
	 *    0			   0
	 */

	{ "input.transfer.high",	0,	voltronic_r_eco_volt_max,	"HEH%03.0f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_process_setvar },
	{ "input.transfer.low",		0,	voltronic_r_eco_volt_min,	"HEL%03.0f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_process_setvar },

	/* Query UPS for ECO Mode frequency limits
	 * > [QFRE\r]
	 * < [(53.0 47.0\r]
	 *    01234567890
	 *    0         1
	 */

	{ "input.frequency.high",	ST_FLAG_RW,	voltronic_r_eco_freq_max,	"QFRE\r",	"",	11,	'(',	"",	1,	4,	"%.1f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_eco_freq },
	{ "input.frequency.low",	ST_FLAG_RW,	voltronic_r_eco_freq_min,	"QFRE\r",	"",	11,	'(',	"",	6,	9,	"%.1f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_eco_freq },

	/* Set ECO Mode frequency limits
	 * > [FREHnn.n\r]	> [FRELnn.n\r]		n = 0..9
	 * < [(ACK\r]		< [(ACK\r]
	 *    01234		   01234
	 *    0			   0
	 */

	{ "input.frequency.high",	0,	voltronic_r_eco_freq_max,	"FREH%04.1f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_process_setvar },
	{ "input.frequency.low",	0,	voltronic_r_eco_freq_min,	"FREL%04.1f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE | QX_FLAG_SKIP,	NULL,	voltronic_process_setvar },

	/* Query UPS for Bypass Mode voltage limits
	 * > [QBYV\r]
	 * < [(264 170\r]
	 *    012345678
	 *    0
	 */

	{ "max_bypass_volt",	ST_FLAG_RW,	voltronic_r_bypass_volt_max,	"QBYV\r",	"",	9,	'(',	"",	1,	3,	"%.0f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_bypass },
	{ "min_bypass_volt",	ST_FLAG_RW,	voltronic_r_bypass_volt_min,	"QBYV\r",	"",	9,	'(',	"",	5,	7,	"%.0f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_bypass },

	/* Set Bypass Mode voltage limits
	 * > [PHVnnn\r]		> [PLVnnn\r]		n = 0..9
	 * < [(ACK\r]		< [(ACK\r]
	 *    01234		   01234
	 *    0			   0
	 */

	{ "max_bypass_volt",	0,	voltronic_r_bypass_volt_max,	"PHV%03.0f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_process_setvar },
	{ "min_bypass_volt",	0,	voltronic_r_bypass_volt_min,	"PLV%03.0f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_process_setvar },

	/* Query UPS for Bypass Mode frequency limits
	 * > [QBYF\r]
	 * < [(53.0 47.0\r]
	 *    01234567890
	 *    0         1
	 */

	{ "max_bypass_freq",	ST_FLAG_RW,	voltronic_r_bypass_freq_max,	"QBYF\r",	"",	11,	'(',	"",	1,	4,	"%.1f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_bypass },
	{ "min_bypass_freq",	ST_FLAG_RW,	voltronic_r_bypass_freq_min,	"QBYF\r",	"",	11,	'(',	"",	6,	9,	"%.1f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_bypass },

	/* Set Bypass Mode frequency limits
	 * > [PGFnn.n\r]	> [PSFnn.n\r]		n = 0..9
	 * < [(ACK\r]		< [(ACK\r]
	 *    01234		   01234
	 *    0			   0
	 */

	{ "max_bypass_freq",	0,	voltronic_r_bypass_freq_max,	"PGF%04.1f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_process_setvar },
	{ "min_bypass_freq",	0,	voltronic_r_bypass_freq_min,	"PSF%04.1f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_process_setvar },

	/* Set number of batteries that make a pack to n (integer, 1-9). NOTE: changing the number of batteries will change the UPS's estimation on battery charge/runtime
	 * > [BATNn\r]
	 * < [(ACK\r]
	 *    01234
	 *    0
	 */

	{ "battery_number",	0,	voltronic_r_batt_numb,	"BATN%1.0f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE | QX_FLAG_NONUT,	NULL,	voltronic_process_setvar },

	/* Set number of battery packs in parallel to n (integer, 01-99). NOTE: changing the number of battery packs will change the UPS's estimation on battery charge/runtime
	 * > [BATGNn\r]
	 * < [(ACK\r]
	 *    01234
	 *    0
	 */

	{ "battery.packs",	0,	voltronic_r_batt_packs,	"BATGN%02.0f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE,	NULL,	voltronic_process_setvar },

	/* Query UPS for battery type (Only P31)
	 * > [QBT\r]
	 * < [(01\r]	<- 00="Li", 01="Flooded" or 02="AGM"
	 *    0123
	 *    0
	 */

	{ "battery.type",	ST_FLAG_RW,	voltronic_e_batt_type,	"QBT\r",	"",	4,	'(',	"",	1,	2,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_ENUM | QX_FLAG_SKIP,	NULL,	voltronic_p31b },

	/* Set battery type (Only P31)
	 * > [PBTnn\r]		nn = 00/01/02
	 * < [(ACK\r]
	 *    01234
	 *    0
	 */

	{ "battery.type",	0,	voltronic_e_batt_type,	"PBT%02.0f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_SKIP,	NULL,	voltronic_p31b_set },

	/* Query UPS for device grid working range (Only P31)
	 * > [QGR\r]
	 * < [(01\r]	<- 00=Appliance, 01=UPS
	 *    0123
	 *    0
	 */

	{ "work_range_type",	ST_FLAG_RW,	voltronic_e_work_range,	"QGR\r",	"",	4,	'(',	"",	1,	2,	"%s",	QX_FLAG_SEMI_STATIC | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_p31g },

	/* Set device grid working range type (Only P31)
	 * > [PBTnn\r]		nn = 00/01
	 * < [(ACK\r]
	 *    01234
	 *    0
	 */

	{ "work_range_type",	0,	voltronic_e_work_range,	"PGR%02.0f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_p31g_set },

	/* Query UPS for battery low voltage
	 * > [RE0\r]
	 * < [#20\r]
	 *    012
	 *    0
	 */

	{ "battery.voltage.low",	ST_FLAG_RW,	voltronic_r_batt_low,	"RE0\r",	"",	3,	'#',	"",	1,	2,	"%.1f",	QX_FLAG_SEMI_STATIC | QX_FLAG_RANGE,	NULL,	NULL },

	/* Set voltage for battery low to n (integer, 20..24/20..28). NOTE: changing the battery low voltage will change the UPS's estimation on battery charge/runtime
	 * > [W0En\r]
	 * < [(ACK\r]
	 *    01234
	 *    0
	 */

	{ "battery.voltage.low",	0,	voltronic_r_batt_low,	"W0E%02.0f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_RANGE,	NULL,	voltronic_process_setvar },

	/* Query UPS for Phase Angle
	 * > [QPD\r]
	 * < [(000 120\r]	<- Input Phase Angle - Output Phase Angle
	 *    012345678
	 *    0
	 */

	{ "input_phase_angle",		0,		NULL,			"QPD\r",	"",	9,	'(',	"",	1,	3,	"%03d",	QX_FLAG_SEMI_STATIC | QX_FLAG_NONUT,			NULL,	voltronic_phase },
	{ "output_phase_angle",		ST_FLAG_RW,	voltronic_e_phase,	"QPD\r",	"",	9,	'(',	"",	5,	7,	"%03d",	QX_FLAG_SEMI_STATIC | QX_FLAG_ENUM | QX_FLAG_NONUT,	NULL,	voltronic_phase },

	/* Set output phase angle
	 * > [PPDn\r]		n = (000, 120, 180 or 240)
	 * < [(ACK\r]
	 *    01234
	 *    0
	 */

	{ "output_phase_angle",		0,	voltronic_e_phase,	"PPD%03.0f\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_SETVAR | QX_FLAG_ENUM | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	voltronic_phase_set },

	/* Query UPS for master/slave for a system of UPSes in parallel
	 * > [QPAR\r]
	 * < [(001\r]	<- 001 for master UPS, 002 and 003 for slave UPSes
	 *    01234
	 *    0
	 */

	{ "voltronic_parallel",		0,	NULL,	"QPAR\r",	"",	5,	'(',	"",	1,	3,	"%s",	QX_FLAG_STATIC | QX_FLAG_NONUT,	NULL,	voltronic_parallel },

	/* Query UPS for ??
	 * > [QBDR\r]
	 * < [(1234\r]	<- unknown reply - My UPS (NAK at me
	 *    012345
	 *    0
	 */

	{ "unknown.7",		0,	NULL,	"QBDR\r",	"",	5,	'(',	"",	1,	0,	"%s",	QX_FLAG_STATIC | QX_FLAG_NONUT | QX_FLAG_SKIP,	NULL,	NULL },

	/* Instant commands */
	{ "load.off",			0,	NULL,	"SOFF\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD,	NULL,	NULL },
	{ "load.on",			0,	NULL,	"SON\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD,	NULL,	NULL },

	{ "shutdown.return",		0,	NULL,	"S%s\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD,	NULL,	voltronic_process_command },
	{ "shutdown.stayoff",		0,	NULL,	"S%sR0000\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD,	NULL,	voltronic_process_command },
	{ "shutdown.stop",		0,	NULL,	"CS\r",		"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD,	NULL,	NULL },

	{ "test.battery.start",		0,	NULL,	"T%s\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD,	NULL,	voltronic_process_command },
	{ "test.battery.start.deep",	0,	NULL,	"TL\r",		"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD,	NULL,	NULL },
	{ "test.battery.start.quick",	0,	NULL,	"T\r",		"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD,	NULL,	NULL },
	{ "test.battery.stop",		0,	NULL,	"CT\r",		"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD,	NULL,	NULL },

	{ "beeper.toggle",		0,	NULL,	"BZ%s\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD,	NULL,	voltronic_process_command },
	/* Enable/disable beeper: unskipped if the UPS can control alarm (capability) */
	{ "beeper.enable",		0,	NULL,	"PEA\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD | QX_FLAG_SKIP,	NULL,	NULL },
	{ "beeper.disable",		0,	NULL,	"PDA\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD | QX_FLAG_SKIP,	NULL,	NULL },

	/* Outlet control: unskipped if the outlets are manageable */
	{ "outlet.1.load.off",		0,	NULL,	"SKOFF1\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD | QX_FLAG_SKIP,	NULL,	NULL },
	{ "outlet.1.load.on",		0,	NULL,	"SKON1\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD | QX_FLAG_SKIP,	NULL,	NULL },
	{ "outlet.2.load.off",		0,	NULL,	"SKOFF2\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD | QX_FLAG_SKIP,	NULL,	NULL },
	{ "outlet.2.load.on",		0,	NULL,	"SKON2\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD | QX_FLAG_SKIP,	NULL,	NULL },
	{ "outlet.3.load.off",		0,	NULL,	"SKOFF3\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD | QX_FLAG_SKIP,	NULL,	NULL },
	{ "outlet.3.load.on",		0,	NULL,	"SKON3\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD | QX_FLAG_SKIP,	NULL,	NULL },
	{ "outlet.4.load.off",		0,	NULL,	"SKOFF4\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD | QX_FLAG_SKIP,	NULL,	NULL },
	{ "outlet.4.load.on",		0,	NULL,	"SKON4\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD | QX_FLAG_SKIP,	NULL,	NULL },

	/* Bypass: unskipped if the UPS is capable of ECO Mode */
	{ "bypass.start",		0,	NULL,	"PEE\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD | QX_FLAG_SKIP,	NULL,	NULL },
	{ "bypass.stop",		0,	NULL,	"PDE\r",	"",	5,	'(',	"",	1,	3,	NULL,	QX_FLAG_CMD | QX_FLAG_SKIP,	NULL,	NULL },

	/* Server-side settable vars */
	{ "ups.delay.start",		ST_FLAG_RW,	voltronic_r_ondelay,	NULL,		"",	0,	0,	"",	0,	0,	DEFAULT_ONDELAY,	QX_FLAG_ABSENT | QX_FLAG_SETVAR | QX_FLAG_RANGE,	NULL,	voltronic_process_setvar },
	{ "ups.delay.shutdown",		ST_FLAG_RW,	voltronic_r_offdelay,	NULL,		"",	0,	0,	"",	0,	0,	DEFAULT_OFFDELAY,	QX_FLAG_ABSENT | QX_FLAG_SETVAR | QX_FLAG_RANGE,	NULL,	voltronic_process_setvar },

	/* End of structure. */
	{ NULL,		0,	NULL,	NULL,	"",	0,	0,	"",	0,	0,	NULL,	0,	NULL,	NULL }
};


/* == Testing table == */
#ifdef TESTING
static testing_t	voltronic_testing[] = {
	{ "QGS\r",	"(234.9 50.0 229.8 50.0 000.0 00A 369.1 ---.- 026.5 ---.- 018.8 100000000001\r",	-1 },
	{ "QPI\r",	"(PI01\r",	-1 },
	{ "QRI\r",	"(230.0 004 024.0 50.0\r",	-1 },
	{ "QMF\r",	"(#####VOLTRONIC\r",	-1 },
	{ "I\r",	"#-------------   ------     VT12046Q  \r",	-1 },
	{ "F\r",	"#220.0 000 024.0 50.0\r",	-1 },
	{ "QMD\r",	"(#######OLHVT1K0 ###1000 80 2/2 230 230 02 12.0\r",	-1 },
	{ "QFS\r",	"(14 212.1 50.0 005.6 49.9 006 010.6 343.8 ---.- 026.2 021.8 01101100\r",	-1 },
	{ "QMOD\r",	"(S\r",	-1 },
	{ "QVFW\r",	"(VERFW:00322.02\r",	-1 },
	{ "QID\r",	"(685653211455\r",	-1 },
	{ "QBV\r",	"(026.5 02 01 068 255\r",	-1 },
	{ "QFLAG\r",	"(EpashcjDbroegfl\r",	-1 },
	{ "QWS\r",	"(0000000000000000000000000000000000000000000000000000000001000001\r",	-1 },
	{ "QHE\r",	"(242 218\r",	-1 },
	{ "QBYV\r",	"(264 170\r",	-1 },
	{ "QBYF\r",	"(53.0 47.0\r",	-1 },
	{ "QSK1\r",	"(1\r",	-1 },
	{ "QSK2\r",	"(0\r",	-1 },
	{ "QSK3\r",	"(1\r",	-1 },
	{ "QSK4\r",	"(NAK\r",	-1 },
	{ "QSKT1\r",	"(008\r",	-1 },
	{ "QSKT2\r",	"(012\r",	-1 },
	{ "QSKT3\r",	"(NAK\r",	-1 },
	{ "QSKT4\r",	"(007\r",	-1 },
	{ "RE0\r",	"#20\r",	-1 },
	{ "W0E24\r",	"(ACK\r",	-1 },
	{ "PF\r",	"(ACK\r",	-1 },
	{ "PEA\r",	"(ACK\r",	-1 },
	{ "PDR\r",	"(NAK\r",	-1 },
	{ "HEH250\r",	"(ACK\r",	-1 },
	{ "HEL210\r",	"(ACK\r",	-1 },
	{ "PHV260\r",	"(NAK\r",	-1 },
	{ "PLV190\r",	"(ACK\r",	-1 },
	{ "PGF51.0\r",	"(NAK\r",	-1 },
	{ "PSF47.5\r",	"(ACK\r",	-1 },
	{ "BATN2\r",	"(ACK\r",	-1 },
	{ "BATGN04\r",	"(ACK\r",	-1 },
	{ "QBT\r",	"(01\r",	-1 },
	{ "PBT02\r",	"(ACK\r",	-1 },
	{ "QGR\r",	"(00\r",	-1 },
	{ "PGR01\r",	"(ACK\r",	-1 },
	{ "PSK1008\r",	"(ACK\r",	-1 },
	{ "PSK3987\r",	"(ACK\r",	-1 },
	{ "PSK2009\r",	"(ACK\r",	-1 },
	{ "PSK4012\r",	"(ACK\r",	-1 },
	{ "Q3PV\r",	"(123.4 456.4 789.4 012.4 323.4 223.4\r",	-1 },
	{ "Q3OV\r",	"(253.4 163.4 023.4 143.4 103.4 523.4\r",	-1 },
	{ "Q3OC\r",	"(109 069 023\r",	-1 },
	{ "Q3LD\r",	"(005 033 089\r",	-1 },
	{ "Q3YV\r",	"(303.4 245.4 126.4 222.4 293.4 321.4\r",	-1 },
	{ "Q3PC\r",	"(002 023 051\r",	-1 },
	{ "SOFF\r",	"(NAK\r",	-1 },
	{ "SON\r",	"(ACK\r",	-1 },
	{ "T\r",	"(NAK\r",	-1 },
	{ "TL\r",	"(ACK\r",	-1 },
	{ "CS\r",	"(ACK\r",	-1 },
	{ "CT\r",	"(NAK\r",	-1 },
	{ "BZOFF\r",	"(ACK\r",	-1 },
	{ "BZON\r",	"(ACK\r",	-1 },
	{ "S.3R0002\r",	"(ACK\r",	-1 },
	{ "S02R0024\r",	"(NAK\r",	-1 },
	{ "S.5\r",	"(ACK\r",	-1 },
	{ "T.3\r",	"(ACK\r",	-1 },
	{ "T02\r",	"(NAK\r",	-1 },
	{ "SKON1\r",	"(ACK\r",	-1 },
	{ "SKOFF1\r",	"(NAK\r",	-1 },
	{ "SKON2\r",	"(ACK\r",	-1 },
	{ "SKOFF2\r",	"(ACK\r",	-1 },
	{ "SKON3\r",	"(NAK\r",	-1 },
	{ "SKOFF3\r",	"(ACK\r",	-1 },
	{ "SKON4\r",	"(NAK\r",	-1 },
	{ "SKOFF4\r",	"(NAK\r",	-1 },
	{ "QPAR\r",	"(003\r",	-1 },
	{ "QPD\r",	"(000 240\r",	-1 },
	{ "PPD120\r",	"(ACK\r",	-1 },
	{ "QLDL\r",	"(005 080\r",	-1 },
	{ "QBDR\r",	"(1234\r",	-1 },
	{ "QFRE\r",	"(50.0 00.0\r",	-1 },
	{ "FREH54.0\r",	"(ACK\r",	-1 },
	{ "FREL47.0\r",	"(ACK\r",	-1 },
	{ "PEP\r",	"(ACK\r",	-1 },
	{ "PDP\r",	"(ACK\r",	-1 },
	{ "PEB\r",	"(ACK\r",	-1 },
	{ "PDB\r",	"(ACK\r",	-1 },
	{ "PER\r",	"(NAK\r",	-1 },
	{ "PDR\r",	"(NAK\r",	-1 },
	{ "PEO\r",	"(ACK\r",	-1 },
	{ "PDO\r",	"(ACK\r",	-1 },
	{ "PEA\r",	"(ACK\r",	-1 },
	{ "PDA\r",	"(ACK\r",	-1 },
	{ "PES\r",	"(ACK\r",	-1 },
	{ "PDS\r",	"(ACK\r",	-1 },
	{ "PEV\r",	"(ACK\r",	-1 },
	{ "PDV\r",	"(ACK\r",	-1 },
	{ "PEE\r",	"(ACK\r",	-1 },
	{ "PDE\r",	"(ACK\r",	-1 },
	{ "PEG\r",	"(ACK\r",	-1 },
	{ "PDG\r",	"(NAK\r",	-1 },
	{ "PED\r",	"(ACK\r",	-1 },
	{ "PDD\r",	"(ACK\r",	-1 },
	{ "PEC\r",	"(ACK\r",	-1 },
	{ "PDC\r",	"(NAK\r",	-1 },
	{ "PEF\r",	"(NAK\r",	-1 },
	{ "PDF\r",	"(ACK\r",	-1 },
	{ "PEJ\r",	"(NAK\r",	-1 },
	{ "PDJ\r",	"(ACK\r",	-1 },
	{ "PEL\r",	"(ACK\r",	-1 },
	{ "PDL\r",	"(ACK\r",	-1 },
	{ "PEN\r",	"(ACK\r",	-1 },
	{ "PDN\r",	"(ACK\r",	-1 },
	{ "PEQ\r",	"(ACK\r",	-1 },
	{ "PDQ\r",	"(ACK\r",	-1 },
	{ "PEW\r",	"(NAK\r",	-1 },
	{ "PDW\r",	"(ACK\r",	-1 },
	{ NULL }
};
#endif	/* TESTING */


/* == Support functions == */

/* This function allows the subdriver to "claim" a device: return 1 if the device is supported by this subdriver, else 0. */
static int	voltronic_claim(void)
{

	/* We need at least QGS and QPI to run this subdriver */

	item_t	*item = find_nut_info("input.voltage", 0, 0);

	/* Don't know what happened */
	if (!item)
		return 0;

	/* No reply/Unable to get value */
	if (qx_process(item, NULL))
		return 0;

	/* Unable to process value */
	if (ups_infoval_set(item) != 1)
		return 0;

	/* UPS Protocol */
	item = find_nut_info("ups.firmware.aux", 0, 0);

	/* Don't know what happened */
	if (!item) {
		dstate_delinfo("input.voltage");
		return 0;
	}

	/* No reply/Unable to get value */
	if (qx_process(item, NULL)) {
		dstate_delinfo("input.voltage");
		return 0;
	}

	/* Unable to process value/Protocol out of range */
	if (ups_infoval_set(item) != 1) {
		dstate_delinfo("input.voltage");
		return 0;
	}

	return 1;

}

/* Subdriver-specific flags/vars */
static void	voltronic_makevartable(void)
{
	/* Capability vars */
	addvar(VAR_FLAG, "reset_to_default", "Reset capability options and their limits to safe default values");
	addvar(VAR_VALUE, "bypass_alarm", "Alarm (BEEP!) at Bypass Mode [enabled/disabled]");
	addvar(VAR_VALUE, "battery_alarm", "Alarm (BEEP!) at Battery Mode [enabled/disabled]");
	addvar(VAR_VALUE, "bypass_when_off", "Bypass when the UPS is Off [enabled/disabled]");
	addvar(VAR_VALUE, "alarm_control", "Alarm (BEEP!) Control [enabled/disabled]");
	addvar(VAR_VALUE, "converter_mode", "Converter Mode [enabled/disabled]");
	addvar(VAR_VALUE, "eco_mode", "ECO Mode [enabled/disabled]");
	addvar(VAR_VALUE, "battery_open_status_check", "Battery Open Status Check [enabled/disabled]");
	addvar(VAR_VALUE, "bypass_forbidding", "Bypass not allowed (Bypass Forbidding) [enabled/disabled]");
	addvar(VAR_VALUE, "site_fault_detection", "Site fault detection [enabled/disabled]");
	addvar(VAR_VALUE, "advanced_eco_mode", "Advanced ECO Mode [enabled/disabled]");
	addvar(VAR_VALUE, "constant_phase_angle", "Constant Phase Angle Function (Output and input phase angles are not equal) [enabled/disabled]");
	addvar(VAR_VALUE, "limited_runtime_on_battery", "Limited runtime on battery mode [enabled/disabled]");

	/* Bypass Mode frequency/voltage limits */
	addvar(VAR_VALUE, "max_bypass_volt", "Maximum voltage for Bypass Mode");
	addvar(VAR_VALUE, "min_bypass_volt", "Minimum voltage for Bypass Mode");
	addvar(VAR_VALUE, "max_bypass_freq", "Maximum frequency for Bypass Mode");
	addvar(VAR_VALUE, "min_bypass_freq", "Minimum frequency for Bypass Mode");

	/* Device grid working range type for P31 UPSes */
	addvar(VAR_VALUE, "work_range_type", "Device grid working range for P31 UPSes [Appliance/UPS]");

	/* Output phase angle */
	addvar(VAR_VALUE, "output_phase_angle", "Change output phase angle to the provided value [000, 120, 180, 240]°");

	/* Number of batteries */
	addvar(VAR_VALUE, "battery_number", "Set number of batteries that make a pack to n (integer, 1-9)");

	/* For testing purposes */
	addvar(VAR_FLAG, "testing", "If invoked the driver will exec also commands that still need testing");
}

/* Unskip vars according to protocol used by the UPS */
static void	voltronic_massive_unskip(const int protocol)
{
	item_t	*item;

	for (item = voltronic_qx2nut; item->info_type != NULL; item++) {

		if (!item->command)
			continue;

		if (	/* == Multiphase UPSes == */
			/* P09 */
			(protocol == 9 && (
			/*	(!strcasecmp(item->info_type, "input.L1-L3.voltage") && item->from == 25) ||	*//* Not unskipped because P09 should be 2-phase input/output */
			/*	(!strcasecmp(item->info_type, "input.L2-L3.voltage") && item->from == 31) ||	*//* Not unskipped because P09 should be 2-phase input/output */
			/*	(!strcasecmp(item->info_type, "output.L1-L3.voltage") && item->from == 25) ||	*//* Not unskipped because P09 should be 2-phase input/output */
			/*	(!strcasecmp(item->info_type, "output.L2-L3.voltage") && item->from == 31) ||	*//* Not unskipped because P09 should be 2-phase input/output */
				(!strcasecmp(item->info_type, "output.bypass.L1-N.voltage") && item->answer_len == 19) ||
				(!strcasecmp(item->info_type, "output.bypass.L2-N.voltage") && item->answer_len == 19)/* ||
				(!strcasecmp(item->info_type, "output.bypass.L3-N.voltage") && item->answer_len == 19)	*//* Not unskipped because P09 should be 2-phase input/output */
			)) ||
			/* P10 */
			(protocol == 10 && (
				!strcasecmp(item->info_type, "output.L3-N.voltage") ||
				(!strcasecmp(item->info_type, "output.L2-L3.voltage") && item->from == 25) ||
				(!strcasecmp(item->info_type, "output.L1-L3.voltage") && item->from == 31) ||
				(!strcasecmp(item->info_type, "output.bypass.L1-N.voltage") && item->answer_len == 37) ||
				(!strcasecmp(item->info_type, "output.bypass.L2-N.voltage") && item->answer_len == 37) ||
				(!strcasecmp(item->info_type, "output.bypass.L3-N.voltage") && item->answer_len == 37) ||
				!strcasecmp(item->info_type, "output.bypass.L1-L2.voltage") ||
				!strcasecmp(item->info_type, "output.bypass.L2-L3.voltage") ||
				!strcasecmp(item->info_type, "output.bypass.L1-L3.voltage") ||
				!strcasecmp(item->info_type, "output.L3.current") ||
				!strcasecmp(item->info_type, "output.L3.power.percent")
			)) ||
			/* P09-P10 */
			((protocol == 9 || protocol == 10) && (
				!strcasecmp(item->info_type, "output.L1-N.voltage") ||
				!strcasecmp(item->info_type, "output.L2-N.voltage") ||/*
				!strcasecmp(item->info_type, "output.L3-N.voltage") ||	*//* Not unskipped because P09 should be 2-phase input/output */
				!strcasecmp(item->info_type, "output.L1-L2.voltage") ||
				!strcasecmp(item->info_type, "output.L1.current") ||
				!strcasecmp(item->info_type, "output.L2.current") ||/*
				!strcasecmp(item->info_type, "output.L3.current") ||	*//* Not unskipped because P09 should be 2-phase input/output */
				!strcasecmp(item->info_type, "output.L1.power.percent") ||
				!strcasecmp(item->info_type, "output.L2.power.percent")/* ||
				!strcasecmp(item->info_type, "output.L3.power.percent")	*//* Not unskipped because P09 should be 2-phase input/output */
			)) ||
			/* P03-P09-P10 */
			((protocol == 3 || protocol == 9 || protocol == 10) && (
				!strcasecmp(item->info_type, "input.L1-N.voltage") ||
				!strcasecmp(item->info_type, "input.L2-N.voltage") ||/*
				!strcasecmp(item->info_type, "input.L3-N.voltage") ||*//* Not unskipped because P09 should be 2-phase input/output */
				!strcasecmp(item->info_type, "input.L1-L2.voltage") ||
				!strcasecmp(item->info_type, "input.L1.current") ||
				!strcasecmp(item->info_type, "input.L2.current")/* ||
				!strcasecmp(item->info_type, "input.L3.current")*//* Not unskipped because P09 should be 2-phase input/output */
			)) ||
			/* P03-P10 */
			((protocol == 3 || protocol == 10) && (
				!strcasecmp(item->info_type, "input.L3-N.voltage") ||
				(!strcasecmp(item->info_type, "input.L2-L3.voltage") && item->from == 25) ||
				(!strcasecmp(item->info_type, "input.L1-L3.voltage") && item->from == 31) ||
				!strcasecmp(item->info_type, "input.L3.current")
			)) ||
			/* == P31 battery type/device grid working range == */
			(protocol == 31 && (
				!strcasecmp(item->info_type, "battery.type") ||
				(!strcasecmp(item->info_type, "work_range_type") && !(item->qxflags & QX_FLAG_SETVAR)) ||
				(!strcasecmp(item->info_type, "work_range_type") && (item->qxflags & QX_FLAG_SETVAR) && getval(item->info_type))
			)) ||
			/* == ByPass limits: all but P00/P08/P31 == */
			(protocol != 0 && protocol != 8 && protocol != 31 && (
				(!strcasecmp(item->info_type, "max_bypass_volt") && !(item->qxflags & QX_FLAG_SETVAR)) ||
				(!strcasecmp(item->info_type, "min_bypass_volt") && !(item->qxflags & QX_FLAG_SETVAR)) ||
				(!strcasecmp(item->info_type, "max_bypass_freq") && !(item->qxflags & QX_FLAG_SETVAR)) ||
				(!strcasecmp(item->info_type, "min_bypass_freq") && !(item->qxflags & QX_FLAG_SETVAR))
			)) ||
			/* == Reset capabilities options to safe default values == */
			(!strcasecmp(item->info_type, "reset_to_default") && testvar("reset_to_default")) ||
			/* == QBDR (unknown) == */
			(!strcasecmp(item->info_type, "unknown.7") && testvar("testing"))
		) {

				item->qxflags &= ~QX_FLAG_SKIP;

		}

	}
}


/* == Preprocess functions == */

/* *SETVAR(/NONUT)* Preprocess setvars */
static int	voltronic_process_setvar(item_t *item, char *value, size_t valuelen)
{
	if (!strlen(value)) {
		upsdebugx(2, "%s: value not given for %s", __func__, item->info_type);
		return -1;
	}

	double	val = strtod(value, NULL);

	if (!strcasecmp(item->info_type, "ups.delay.start")) {

		/* Truncate to minute */
		val -= ((int)val % 60);

		snprintf(value, valuelen, "%.0f", val);

		return 0;

	} else if (!strcasecmp(item->info_type, "ups.delay.shutdown")) {

		/* Truncate to nearest setable value */
		if (val < 60) {
			val -= ((int)val % 6);
		} else {
			val -= ((int)val % 60);
		}

		snprintf(value, valuelen, "%.0f", val);

		return 0;

	} else if (!strcasecmp(item->info_type, "max_bypass_freq")) {

		if (val == max_bypass_freq) {
			upslogx(LOG_INFO, "%s is already set to %.1f", item->info_type, val);
			return -1;
		}

	} else if (!strcasecmp(item->info_type, "min_bypass_freq")) {

		if (val == min_bypass_freq) {
			upslogx(LOG_INFO, "%s is already set to %.1f", item->info_type, val);
			return -1;
		}

	} else if (!strcasecmp(item->info_type, "max_bypass_volt")) {

		if (val == max_bypass_volt) {
			upslogx(LOG_INFO, "%s is already set to %.0f", item->info_type, val);
			return -1;
		}

	} else if (!strcasecmp(item->info_type, "min_bypass_volt")) {

		if (val == min_bypass_volt) {
			upslogx(LOG_INFO, "%s is already set to %.0f", item->info_type, val);
			return -1;
		}

	} else if (!strcasecmp(item->info_type, "battery_number")) {

		if (val == battery_number) {
			upslogx(LOG_INFO, "%s is already set to %.0f", item->info_type, val);
			return -1;
		}

	}

	snprintf(value, valuelen, item->command, val);

	return 0;
}

/* *CMD* Preprocess instant commands */
static int	voltronic_process_command(item_t *item, char *value, size_t valuelen)
{
	char	buf[SMALLBUF] = "";

	if (!strcasecmp(item->info_type, "shutdown.return")) {

		/* Sn: Shutdown after n minutes and then turn on when mains is back
		 * SnRm: Shutdown after n minutes and then turn on after m minutes
		 * Accepted values for n: .2 -> .9 , 01 -> 99
		 * Accepted values for m: 0001 -> 9999 */

		int	offdelay = strtol(dstate_getinfo("ups.delay.shutdown"), NULL, 10),
			ondelay = strtol(dstate_getinfo("ups.delay.start"), NULL, 10) / 60;

		if (ondelay == 0) {

			if (offdelay < 60) {
				snprintf(buf, sizeof(buf), ".%d", offdelay / 6);
			} else {
				snprintf(buf, sizeof(buf), "%02d", offdelay / 60);
			}

		} else if (offdelay < 60) {

			snprintf(buf, sizeof(buf), ".%dR%04d", offdelay / 6, ondelay);

		} else {

			snprintf(buf, sizeof(buf), "%02dR%04d", offdelay / 60, ondelay);

		}

	} else if (!strcasecmp(item->info_type, "shutdown.stayoff")) {

		/* SnR0000
		 * Shutdown after n minutes and stay off
		 * Accepted values for n: .2 -> .9 , 01 -> 99 */

		int	offdelay = strtol(dstate_getinfo("ups.delay.shutdown"), NULL, 10);

		if (offdelay < 60) {
			snprintf(buf, sizeof(buf), ".%d", offdelay / 6);
		} else {
			snprintf(buf, sizeof(buf), "%02d", offdelay / 60);
		}

	} else if (!strcasecmp(item->info_type, "test.battery.start")) {

		/* Accepted values for test time: .2 -> .9 (.2=12sec ..), 01 -> 99 (minutes)
		 * -> you have to invoke test.battery.start + number of seconds [12..5940] */

		int	delay;

		if (strlen(value) != strspn(value, "0123456789")) {
			upslogx(LOG_ERR, "%s: non numerical value [%s]", item->info_type, value);
			return -1;
		}

		delay = strlen(value) > 0 ? strtol(value, NULL, 10) : 600;

		if ((delay < 12) || (delay > 5940)) {
			upslogx(LOG_ERR, "%s: battery test time '%d' out of range [12..5940] seconds", item->info_type, delay);
			return -1;
		}

		/* test time < 1 minute */
		if (delay < 60) {

			delay = delay / 6;
			snprintf(buf, sizeof(buf), ".%d", delay);

		/* test time > 1 minute */
		} else {

			delay = delay / 60;
			snprintf(buf, sizeof(buf), "%02d", delay);

		}

	} else if (!strcasecmp(item->info_type, "beeper.toggle")) {

		const char	*beeper_status = dstate_getinfo("ups.beeper.status");

		/* If the UPS is beeping then we can call BZOFF; if we previously set BZOFF we can call BZON, provided that the beeper is not disabled */

		/* The UPS can disable/enable alarm (from UPS capability) */
		if (alarm_control) {

			if (!strcmp(beeper_status, "enabled")) {

				snprintf(buf, sizeof(buf), "OFF");

			} else if (!strcmp(beeper_status, "muted")) {

				snprintf(buf, sizeof(buf), "ON");

			/* Beeper disabled */
			} else {

				upslogx(LOG_INFO, "The beeper is already disabled");
				return -1;

			}

		/* The UPS can't disable/enable alarm (from UPS capability) */
		} else {

			if (!strcmp(beeper_status, "enabled")) {

				snprintf(buf, sizeof(buf), "OFF");

			} else if (!strcmp(beeper_status, "disabled")) {

				snprintf(buf, sizeof(buf), "ON");

			}

		}

	} else {

		/* Don't know what happened */
		return -1;

	}

	snprintf(value, valuelen, item->command, buf);

	return 0;
}

/* UPS capabilities */
static int	voltronic_capability(item_t *item, char *value, size_t valuelen)
{
	char	rawval[SMALLBUF], *enabled, *disabled, *val = NULL, *saveptr = NULL;
	item_t	*unskip;

	snprintf(rawval, sizeof(rawval), "%s", item->value);

	enabled = strtok_r(rawval+1, "D", &saveptr);
	disabled = strtok_r(NULL, "\0", &saveptr);

	if (!enabled && !disabled) {
		upsdebugx(2, "%s: parsing failed", __func__);
		return -1;
	}

	enabled = enabled ? enabled : "";
	disabled = disabled ? disabled : "";

	/* NONUT items */
	if (!strcasecmp(item->info_type, "bypass_alarm")) {

		if (strchr(enabled, 'p')) {
			val = bypass_alarm = "enabled";
		} else if (strchr(disabled, 'p')) {
			val = bypass_alarm = "disabled";
		}

	} else if (!strcasecmp(item->info_type, "battery_alarm")) {

		if (strchr(enabled, 'b')) {
			val = battery_alarm = "enabled";
		} else if (strchr(disabled, 'b')) {
			val = battery_alarm = "disabled";
		}

	} else if (!strcasecmp(item->info_type, "bypass_when_off")) {

		if (strchr(enabled, 'o')) {
			val = bypass_when_off = "enabled";
		} else if (strchr(disabled, 'o')) {
			val = bypass_when_off = "disabled";
		}

	} else if (!strcasecmp(item->info_type, "alarm_control")) {

		if (strchr(item->value, 'a')) {

			if (strchr(enabled, 'a')) {

				const char	*beeper = dstate_getinfo("ups.beeper.status");

				val = alarm_control = "enabled";

				if (!beeper || strcmp(beeper, "muted")) {
					dstate_setinfo("ups.beeper.status", "enabled");
				}

			} else if (strchr(disabled, 'a')) {

				val = alarm_control = "disabled";
				dstate_setinfo("ups.beeper.status", "disabled");

			}

			/* Unskip beeper.{enable,disable} instcmds */
			unskip = find_nut_info("beeper.enable", QX_FLAG_CMD, 0);

			/* Don't know what happened */
			if (!unskip)
				return -1;

			unskip->qxflags &= ~QX_FLAG_SKIP;

			unskip = find_nut_info("beeper.disable", QX_FLAG_CMD, 0);

			/* Don't know what happened */
			if (!unskip)
				return -1;

			unskip->qxflags &= ~QX_FLAG_SKIP;

		}

	} else if (!strcasecmp(item->info_type, "converter_mode")) {

		if (strchr(enabled, 'v')) {
			val = converter_mode = "enabled";
		} else if (strchr(disabled, 'v')) {
			val = converter_mode = "disabled";
		}

	} else if (!strcasecmp(item->info_type, "eco_mode")) {

		if (strchr(item->value, 'e')) {

			if (strchr(enabled, 'e')) {
				val = eco_mode = "enabled";
			} else if (strchr(disabled, 'e')) {
				val = eco_mode = "disabled";
			}

			/* Unskip bypass.{start,stop} instcmds */
			unskip = find_nut_info("bypass.start", QX_FLAG_CMD, 0);

			/* Don't know what happened */
			if (!unskip)
				return -1;

			unskip->qxflags &= ~QX_FLAG_SKIP;

			unskip = find_nut_info("bypass.stop", QX_FLAG_CMD, 0);

			/* Don't know what happened */
			if (!unskip)
				return -1;

			unskip->qxflags &= ~QX_FLAG_SKIP;

			/* Unskip input.transfer.{high,low} */
			unskip = find_nut_info("input.transfer.high", QX_FLAG_SEMI_STATIC, 0);

			/* Don't know what happened */
			if (!unskip)
				return -1;

			unskip->qxflags &= ~QX_FLAG_SKIP;

			unskip = find_nut_info("input.transfer.low", QX_FLAG_SEMI_STATIC, 0);

			/* Don't know what happened */
			if (!unskip)
				return -1;

			unskip->qxflags &= ~QX_FLAG_SKIP;

			/* Unskip input.frequency.{high,low} */
			unskip = find_nut_info("input.frequency.high", QX_FLAG_SEMI_STATIC, 0);

			/* Don't know what happened */
			if (!unskip)
				return -1;

			unskip->qxflags &= ~QX_FLAG_SKIP;

			unskip = find_nut_info("input.frequency.low", QX_FLAG_SEMI_STATIC, 0);

			/* Don't know what happened */
			if (!unskip)
				return -1;

			unskip->qxflags &= ~QX_FLAG_SKIP;

		}

	} else if (!strcasecmp(item->info_type, "battery_open_status_check")) {

		if (strchr(enabled, 'd')) {
			val = battery_open_status_check = "enabled";
		} else if (strchr(disabled, 'd')) {
			val = battery_open_status_check = "disabled";
		}

	} else if (!strcasecmp(item->info_type, "bypass_forbidding")) {

		if (strchr(enabled, 'f')) {
			val = bypass_forbidding = "enabled";
		} else if (strchr(disabled, 'f')) {
			val = bypass_forbidding = "disabled";
		}

	} else if (!strcasecmp(item->info_type, "site_fault_detection")) {

		if (strchr(enabled, 'l')) {
			val = site_fault_detection = "enabled";
		} else if (strchr(disabled, 'l')) {
			val = site_fault_detection = "disabled";
		}

	} else if (!strcasecmp(item->info_type, "advanced_eco_mode")) {

		if (strchr(enabled, 'n')) {
			val = advanced_eco_mode = "enabled";
		} else if (strchr(disabled, 'n')) {
			val = advanced_eco_mode = "disabled";
		}

	} else if (!strcasecmp(item->info_type, "constant_phase_angle")) {

		if (strchr(enabled, 'q')) {
			val = constant_phase_angle = "enabled";
		} else if (strchr(disabled, 'q')) {
			val = constant_phase_angle = "disabled";
		}

	} else if (!strcasecmp(item->info_type, "limited_runtime_on_battery")) {

		if (strchr(enabled, 'w')) {
			val = limited_runtime_on_battery = "enabled";
		} else if (strchr(disabled, 'w')) {
			val = limited_runtime_on_battery = "disabled";
		}

/*	} else if (!strcasecmp(item->info_type, "")) {

		if (strchr(enabled, 'h')) {	unknown/unused
		} else if (strchr(disabled, 'h')) { }

	} else if (!strcasecmp(item->info_type, "")) {

		if (strchr(enabled, 't')) {	unknown/unused
		} else if (strchr(disabled, 't')) { }

	} else if (!strcasecmp(item->info_type, "")) {

		if (strchr(enabled, 'k')) {	unknown/unused
		} else if (strchr(disabled, 'k')) { }

	} else if (!strcasecmp(item->info_type, "")) {

		if (strchr(enabled, 'i')) {	unknown/unused
		} else if (strchr(disabled, 'i')) { }

	} else if (!strcasecmp(item->info_type, "")) {

		if (strchr(enabled, 'm')) {	unknown/unused
		} else if (strchr(disabled, 'm')) { }

	} else if (!strcasecmp(item->info_type, "")) {

		if (strchr(enabled, 'z')) {	unknown/unused
		} else if (strchr(disabled, 'z')) { }
*/
	/* Items with a NUT variable */
	} else if (!strcasecmp(item->info_type, "ups.start.auto")) {

		if (strchr(enabled, 'r')) {
			val = "yes";
		} else if (strchr(disabled, 'r')) {
			val = "no";
		}

	} else if (!strcasecmp(item->info_type, "battery.protection")) {

		if (strchr(enabled, 's')) {
			val = "yes";
		} else if (strchr(disabled, 's')) {
			val = "no";
		}

	} else if (!strcasecmp(item->info_type, "battery.energysave")) {

		if (strchr(enabled, 'g')) {
			val = "yes";
		} else if (strchr(disabled, 'g')) {
			val = "no";
		}

	} else if (!strcasecmp(item->info_type, "ups.start.battery")) {

		if (strchr(enabled, 'c')) {
			val = "yes";
		} else if (strchr(disabled, 'c')) {
			val = "no";
		}

	} else if (!strcasecmp(item->info_type, "outlet.0.switchable")) {

		if (strchr(enabled, 'j')) {

			int	i;
			char	buf[SMALLBUF];

			val = "yes";

			/* Unskip outlet.n.{switchable,status} */
			for (i = 1; i <= 4; i++) {

				snprintf(buf, sizeof(buf), "outlet.%d.switchable", i);

				unskip = find_nut_info(buf, 0, 0);

				/* Don't know what happened */
				if (!unskip)
					return -1;

				unskip->qxflags &= ~QX_FLAG_SKIP;

				snprintf(buf, sizeof(buf), "outlet.%d.status", i);

				unskip = find_nut_info(buf, 0, 0);

				/* Don't know what happened */
				if (!unskip)
					return -1;

				unskip->qxflags &= ~QX_FLAG_SKIP;

			}

		} else if (strchr(disabled, 'j')) {
			val = "no";
		}

	}

	/* UPS doesn't have that capability */
	if (!val)
		return -1;

	snprintf(value, valuelen, item->dfl, val);

	/* This item doesn't have a NUT var and we were not asked by the user to change its value */
	if ((item->qxflags & QX_FLAG_NONUT) && !getval(item->info_type))
		return 0;

	/* Unskip setvar */
	unskip = find_nut_info(item->info_type, QX_FLAG_SETVAR, 0);

	/* Don't know what happened */
	if (!unskip)
		return -1;

	unskip->qxflags &= ~QX_FLAG_SKIP;

	return 0;
}

/* *SETVAR* Set UPS capability options */
static int	voltronic_capability_set(item_t *item, char *value, size_t valuelen)
{
	if (!strcasecmp(value, "yes")) {
		snprintf(value, valuelen, item->command, "E");
		return 0;
	}

	if (!strcasecmp(value, "no")) {
		snprintf(value, valuelen, item->command, "D");
		return 0;
	}

	/* At this point value should have been already checked against enum so this shouldn't happen.. however.. */
	upslogx(LOG_ERR, "%s: given value [%s] is not acceptable. Enter either 'yes' or 'no'.", item->info_type, value);

	return -1;
}

/* *SETVAR/NONUT* Change UPS capability according to user configuration in ups.conf */
static int	voltronic_capability_set_nonut(item_t *item, char *value, size_t valuelen)
{
	const char	*match = NULL;
	int		i;
	const struct {
		const char	*type;	/* Name of the option */
		const char	*match;	/* Value reported by the UPS */
	} capability[] = {
		{ "bypass_alarm",		bypass_alarm },
		{ "battery_alarm",		battery_alarm },
		{ "bypass_when_off",		bypass_when_off },
		{ "alarm_control",		alarm_control },
		{ "converter_mode",		converter_mode },
		{ "eco_mode",			eco_mode },
		{ "battery_open_status_check",	battery_open_status_check },
		{ "bypass_forbidding",		bypass_forbidding },
		{ "site_fault_detection",	site_fault_detection },
		{ "advanced_eco_mode",		advanced_eco_mode },
		{ "constant_phase_angle",	constant_phase_angle },
		{ "limited_runtime_on_battery",	limited_runtime_on_battery },
		{ NULL }
	};

	for (i = 0; capability[i].type; i++) {

		if (strcasecmp(item->info_type, capability[i].type))
			continue;

		match = capability[i].match;

		break;

	}

	/* UPS doesn't have that capability */
	if (!match)
		return -1;

	/* At this point value should have been already checked by nutdrv_qx's own setvar so this shouldn't happen.. however.. */
	if (!strcasecmp(value, match)) {
		upslogx(LOG_INFO, "%s is already %s", item->info_type, match);
		return -1;
	}

	if (!strcasecmp(value, "disabled")) {
		snprintf(value, valuelen, item->command, "D");
	} else if (!strcasecmp(value, "enabled")) {
		snprintf(value, valuelen, item->command, "E");
	} else {
		/* At this point value should have been already checked against enum so this shouldn't happen.. however.. */
		upslogx(LOG_ERR, "%s: [%s] is not within acceptable values [enabled/disabled]", item->info_type, value);
		return -1;
	}

	return 0;
}

/* *SETVAR/NONUT* Reset capability options and their limits to safe default values */
static int	voltronic_capability_reset(item_t *item, char *value, size_t valuelen)
{
	/* Nothing to do */
	if (!testvar("reset_to_default"))
		return -1;

	/* UPS capability options can be reset only when the UPS is in 'Standby Mode' (=OFF) (from QMOD) */
	if (!(qx_status() & STATUS(OFF))) {
		upslogx(LOG_ERR, "%s: UPS capability options can be reset only when the UPS is in Standby Mode (i.e. ups.status = 'OFF').", item->info_type);
		return -1;
	}

	snprintf(value, valuelen, "%s", item->command);

	return 0;
}

/* Voltage limits for ECO Mode */
static int	voltronic_eco_volt(item_t *item, char *value, size_t valuelen)
{
	const int	protocol = strtol(dstate_getinfo("ups.firmware.aux")+1, NULL, 10);
	int		ovn;
	const char	*outvoltnom;
	char		buf[SMALLBUF];
	item_t		*unskip;
	/* Range of accepted values for maximum voltage for ECO Mode */
	struct {
		int	lower;	/* Lower limit */
		int	upper;	/* Upper limit */
	} max;
	/* Range of accepted values for minimum voltage for ECO Mode */
	struct {
		int	lower;	/* Lower limit */
		int	upper;	/* Upper limit */
	} min;

	if (strspn(item->value, "0123456789 .") != strlen(item->value)) {
		upsdebugx(2, "%s: non numerical value [%s: %s]", __func__, item->info_type, item->value);
		return -1;
	}

	snprintf(value, valuelen, item->dfl, strtod(item->value, NULL));

	outvoltnom = dstate_getinfo("output.voltage.nominal");

	/* Since query for ratings (QRI) is not mandatory to run this driver, skip next steps if we can't get the value of output voltage nominal */
	if (!outvoltnom) {
		upsdebugx(2, "%s: unable to get output voltage nominal", __func__);
		/* We return 0 since we have the value and all's ok: simply we can't set its range so we won't unskip SETVAR item and .{min,max} */
		return 0;
	}

	ovn = strtol(outvoltnom, NULL, 10);

	/* For P01/P09 */
	if (protocol == 1 || protocol == 9) {

		if (ovn >= 200) {
			min.lower = ovn - 24;
			min.upper = ovn - 7;
			max.lower = ovn + 7;
			max.upper = ovn + 24;
		} else {
			min.lower = ovn - 12;
			min.upper = ovn - 3;
			max.lower = ovn + 3;
			max.upper = ovn + 12;

		}

	/* For P02/P03/P10/P13/P14/P99 */
	} else if (protocol == 2 || protocol == 3 || protocol == 10 || protocol == 13 || protocol == 14 || protocol == 99) {

		if (ovn >= 200) {
			min.lower = ovn - 24;
			min.upper = ovn - 11;
			max.lower = ovn + 11;
			max.upper = ovn + 24;
		} else {
			min.lower = ovn - 12;
			min.upper = ovn - 5;
			max.lower = ovn + 5;
			max.upper = ovn + 12;
		}

	/* ECO mode not supported */
	} else {
		upsdebugx(2, "%s: the UPS doesn't seem to support ECO Mode", __func__);
		/* We return 0 since we have the value and all's ok: simply we can't set its range so we won't unskip SETVAR item and .{min,max} */
		return 0;
	}

	if (!strcasecmp(item->info_type, "input.transfer.high")) {

		/* Fill voltronic_r_eco_volt_max */
		snprintf(item->info_rw[0].value, sizeof(item->info_rw[0].value), "%d", max.lower);
		snprintf(item->info_rw[1].value, sizeof(item->info_rw[1].value), "%d", max.upper);


	} else if (!strcasecmp(item->info_type, "input.transfer.low")) {

		/* Fill voltronic_r_eco_volt_min */
		snprintf(item->info_rw[0].value, sizeof(item->info_rw[0].value), "%d", min.lower);
		snprintf(item->info_rw[1].value, sizeof(item->info_rw[1].value), "%d", min.upper);

	}

	/* Unskip input.transfer.{high,low}.{min,max} */
	snprintf(buf, sizeof(buf), "%s.min", item->info_type);

	unskip = find_nut_info(buf, QX_FLAG_SEMI_STATIC, 0);

	/* Don't know what happened */
	if (!unskip)
		return -1;

	unskip->qxflags &= ~QX_FLAG_SKIP;

	snprintf(buf, sizeof(buf), "%s.max", item->info_type);

	unskip = find_nut_info(buf, QX_FLAG_SEMI_STATIC, 0);

	/* Don't know what happened */
	if (!unskip)
		return -1;

	unskip->qxflags &= ~QX_FLAG_SKIP;

	/* Unskip input.transfer.{high,low} setvar */
	unskip = find_nut_info(item->info_type, QX_FLAG_SETVAR, 0);

	/* Don't know what happened */
	if (!unskip)
		return -1;

	unskip->qxflags &= ~QX_FLAG_SKIP;

	return 0;
}

/* Voltage limits for ECO Mode (max, min) */
static int	voltronic_eco_volt_range(item_t *item, char *value, size_t valuelen)
{
	char	*buf;
	int	i;
	item_t	*from;

	if (!strcasecmp(item->info_type, "input.transfer.low.min")) {

		buf = "input.transfer.low";
		i = 0;

	} else if (!strcasecmp(item->info_type, "input.transfer.low.max")) {

		buf = "input.transfer.low";
		i = 1;

	} else if (!strcasecmp(item->info_type, "input.transfer.high.min")) {

		buf = "input.transfer.high";
		i = 0;

	} else if (!strcasecmp(item->info_type, "input.transfer.high.max")) {

		buf = "input.transfer.high";
		i = 1;

	} else {

		/* Don't know what happened */
		return -1;

	}

	from = find_nut_info(buf, QX_FLAG_SEMI_STATIC, 0);

	/* Don't know what happened */
	if (!from)
		return -1;

	/* Value is set at runtime by voltronic_eco_volt, so if it's still unset something went wrong */
	if (!strlen(from->info_rw[i].value))
		return -1;

	snprintf(value, valuelen, "%s", from->info_rw[i].value);

	return 0;
}

/* Frequency limits for ECO Mode */
static int	voltronic_eco_freq(item_t *item, char *value, size_t valuelen)
{
	item_t	*unskip;

	if (strspn(item->value, "0123456789 .") != strlen(item->value)) {
		upsdebugx(2, "%s: non numerical value [%s: %s]", __func__, item->info_type, item->value);
		return -1;
	}

	snprintf(value, valuelen, item->dfl, strtod(item->value, NULL));

	/* Unskip input.transfer.{high,low} setvar */
	unskip = find_nut_info(item->info_type, QX_FLAG_SETVAR, 0);

	/* Don't know what happened */
	if (!unskip)
		return -1;

	unskip->qxflags &= ~QX_FLAG_SKIP;

	return 0;
}

/* *NONUT* Voltage/frequency limits for Bypass Mode */
static int	voltronic_bypass(item_t *item, char *value, size_t valuelen)
{
	item_t	*unskip;
	double	val;

	if (strspn(item->value, "0123456789 .") != strlen(item->value)) {
		upsdebugx(2, "%s: non numerical value [%s: %s]", __func__, item->info_type, item->value);
		return -1;
	}

	if (!strcasecmp(item->info_type, "max_bypass_volt")) {

		val = max_bypass_volt = strtol(item->value, NULL, 10);

	} else if (!strcasecmp(item->info_type, "min_bypass_volt")) {

		val = min_bypass_volt = strtol(item->value, NULL, 10);

	} else if (!strcasecmp(item->info_type, "max_bypass_freq")) {

		val = max_bypass_freq = strtod(item->value, NULL);

	} else if (!strcasecmp(item->info_type, "min_bypass_freq")) {

		val = min_bypass_freq = strtod(item->value, NULL);

	} else {

		/* Don't know what happened */
		return -1;

	}

	snprintf(value, valuelen, item->dfl, val);

	/* No user-provided value to change.. */
	if (!getval(item->info_type))
		return 0;

	/* Unskip {min,max}_bypass_volt setvar */
	unskip = find_nut_info(item->info_type, QX_FLAG_SETVAR, 0);

	/* Don't know what happened */
	if (!unskip)
		return -1;

	unskip->qxflags &= ~QX_FLAG_SKIP;

	return 0;
}

/* *NONUT* Number of batteries */
static int	voltronic_batt_numb(item_t *item, char *value, size_t valuelen)
{
	item_t	*unskip;

	if (strspn(item->value, "0123456789 .") != strlen(item->value)) {
		upsdebugx(2, "%s: non numerical value [%s: %s]", __func__, item->info_type, item->value);
		return -1;
	}

	battery_number = strtol(item->value, NULL, 10);

	snprintf(value, valuelen, item->dfl, battery_number);

	/* No user-provided value to change.. */
	if (!getval(item->info_type))
		return 0;

	/* Unskip battery_number setvar */
	unskip = find_nut_info("battery_number", QX_FLAG_SETVAR, 0);

	/* Don't know what happened */
	if (!unskip)
		return -1;

	unskip->qxflags &= ~QX_FLAG_SKIP;

	return 0;
}

/* Battery runtime */
static int	voltronic_batt_runtime(item_t *item, char *value, size_t valuelen)
{
	double	runtime;

	if (strspn(item->value, "0123456789 .") != strlen(item->value)) {
		upsdebugx(2, "%s: non numerical value [%s: %s]", __func__, item->info_type, item->value);
		return -1;
	}

	/* Battery runtime is reported by the UPS in minutes, NUT expects seconds */
	runtime = strtod(item->value, NULL) * 60;

	snprintf(value, valuelen, item->dfl, runtime);

	return 0;
}

/* Protocol used by the UPS */
static int	voltronic_protocol(item_t *item, char *value, size_t valuelen)
{
	int	protocol;

	if (strncasecmp(item->value, "PI", 2)) {
		upsdebugx(2, "%s: invalid start characters [%.2s]", __func__, item->value);
		return -1;
	}

	/* Here we exclude non numerical value and other non accepted protocols (hence the restricted comparison target) */
	if (strspn(item->value+2, "0123489") != strlen(item->value+2)) {
		upslogx(LOG_ERR, "Protocol [%s] is not supported by this driver", item->value);
		return -1;
	}

	protocol = strtol(item->value+2, NULL, 10);

	switch (protocol)
	{
	case 0:
	case 1:
	case 2:
	case 3:
	case 8:
	case 9:
	case 10:
	case 13:
	case 14:
	case 31:
	case 99:

		break;

	default:

		upslogx(LOG_ERR, "Protocol [PI%02d] is not supported by this driver", protocol);
		return -1;

	}

	snprintf(value, valuelen, "P%02d", protocol);

	/* Unskip vars according to protocol */
	voltronic_massive_unskip(protocol);

	return 0;
}

/* Fault reported by the UPS:
 * When the UPS is queried for status (QGS), if it reports a fault (6th bit of 12bit flag of the reply to QGS set to 1), the driver unskips the QFS item in qx2nut array: this function processes the reply to QFS query */
static int	voltronic_fault(item_t *item, char *value, size_t valuelen)
{
	int	protocol = strtol(dstate_getinfo("ups.firmware.aux")+1, NULL, 10);

	char	alarm[SMALLBUF];

	upslogx(LOG_INFO, "Checking for faults..");

	if (!strcasecmp(item->value, "OK")) {
		snprintf(value, valuelen, item->dfl, "No fault found");
		upslogx(LOG_INFO, "%s", value);
		item->qxflags |= QX_FLAG_SKIP;
		return 0;
	}

	if ((strspn(item->value, "0123456789ABC") != 2) || ((item->value[0] != '1') && (strspn(item->value+1, "0123456789") != 1))) {

		snprintf(alarm, sizeof(alarm), "Unknown fault [%s]", item->value);

	/* P31 UPSes */
	} else if (protocol == 31) {

		if (strpbrk(item->value+1, "ABC")) {

			snprintf(alarm, sizeof(alarm), "Unknown fault [%s]", item->value);

		} else {

			switch (strtol(item->value, NULL, 10))
			{
			case 1:

				strcpy(alarm, "Fan failure.");
				break;

			case 2:

				strcpy(alarm, "Over temperature fault.");
				break;

			case 3:

				strcpy(alarm, "Battery voltage is too high.");
				break;

			case 4:

				strcpy(alarm, "Battery voltage too low.");
				break;

			case 5:

				strcpy(alarm, "Inverter relay short-circuited.");
				break;

			case 6:

				strcpy(alarm, "Inverter voltage over maximum value.");
				break;

			case 7:

				strcpy(alarm, "Overload fault.");
				update_status("OVER");
				break;

			case 8:

				strcpy(alarm, "Bus voltage exceeds its upper limit.");
				break;

			case 9:

				strcpy(alarm, "Bus soft start fail.");
				break;

			case 10:

				strcpy(alarm, "Unknown fault [Fault code: 10]");
				break;

			case 51:

				strcpy(alarm, "Over current fault.");
				break;

			case 52:

				strcpy(alarm, "Bus voltage below its under limit.");
				break;

			case 53:

				strcpy(alarm, "Inverter soft start fail.");
				break;

			case 54:

				strcpy(alarm, "Self test fail.");
				break;

			case 55:

				strcpy(alarm, "Output DC voltage exceeds its upper limit.");
				break;

			case 56:

				strcpy(alarm, "Battery open fault.");
				break;

			case 57:

				strcpy(alarm, "Current sensor fault.");
				break;

			case 58:

				strcpy(alarm, "Battery short.");
				break;

			case 59:

				strcpy(alarm, "Inverter voltage below its lower limit.");
				break;

			default:

				snprintf(alarm, sizeof(alarm), "Unknown fault [%s]", item->value);
				break;

			}

		}

	/* All other UPSes */
	} else {

		switch (strtol(item->value, NULL, 10))
		{
		case 1:

			switch (item->value[1])
			{
			case 'A':

				strcpy(alarm, "L1 inverter negative power out of acceptable range.");
				break;

			case 'B':

				strcpy(alarm, "L2 inverter negative power out of acceptable range.");
				break;

			case 'C':

				strcpy(alarm, "L3 inverter negative power out of acceptable range.");
				break;

			default:

				strcpy(alarm, "Bus voltage not within default setting.");
				break;

			}

			break;

		case 2:

			strcpy(alarm, "Bus voltage over maximum value.");
			break;

		case 3:

			strcpy(alarm, "Bus voltage below minimum value.");
			break;

		case 4:

			strcpy(alarm, "Bus voltage differences out of acceptable range.");
			break;

		case 5:

			strcpy(alarm, "Bus voltage of slope rate drops too fast.");
			break;

		case 6:

			strcpy(alarm, "Over current in PFC input inductor.");
			break;

		case 11:

			strcpy(alarm, "Inverter voltage not within default setting.");
			break;

		case 12:

			strcpy(alarm, "Inverter voltage over maximum value.");
			break;

		case 13:

			strcpy(alarm, "Inverter voltage below minimum value.");
			break;

		case 14:

			strcpy(alarm, "Inverter short-circuited.");
			break;

		case 15:

			strcpy(alarm, "L2 phase inverter short-circuited.");
			break;

		case 16:

			strcpy(alarm, "L3 phase inverter short-circuited.");
			break;

		case 17:

			strcpy(alarm, "L1L2 inverter short-circuited.");
			break;

		case 18:

			strcpy(alarm, "L2L3 inverter short-circuited.");
			break;

		case 19:

			strcpy(alarm, "L3L1 inverter short-circuited.");
			break;

		case 21:

			strcpy(alarm, "Battery SCR short-circuited.");
			break;

		case 22:

			strcpy(alarm, "Line SCR short-circuited.");
			break;

		case 23:

			strcpy(alarm, "Inverter relay open fault.");
			break;

		case 24:

			strcpy(alarm, "Inverter relay short-circuited.");
			break;

		case 25:

			strcpy(alarm, "Input and output wires oppositely connected.");
			break;

		case 26:

			strcpy(alarm, "Battery oppositely connected.");
			break;

		case 27:

			strcpy(alarm, "Battery voltage is too high.");
			break;

		case 28:

			strcpy(alarm, "Battery voltage too low.");
			break;

		case 29:

			strcpy(alarm, "Failure for battery fuse being open-circuited.");
			break;

		case 31:

			strcpy(alarm, "CAN-bus communication fault.");
			break;

		case 32:

			strcpy(alarm, "Host signal circuit fault.");
			break;

		case 33:

			strcpy(alarm, "Synchronous signal circuit fault.");
			break;

		case 34:

			strcpy(alarm, "Synchronous pulse signal circuit fault.");
			break;

		case 35:

			strcpy(alarm, "Parallel cable disconnected.");
			break;

		case 36:

			strcpy(alarm, "Load unbalanced.");
			break;

		case 41:

			strcpy(alarm, "Over temperature fault.");
			break;

		case 42:

			strcpy(alarm, "Communication failure between CPUs in control board.");
			break;

		case 43:

			strcpy(alarm, "Overload fault.");
			update_status("OVER");
			break;

		case 44:

			strcpy(alarm, "Fan failure.");
			break;

		case 45:

			strcpy(alarm, "Charger failure.");
			break;

		case 46:

			strcpy(alarm, "Model fault.");
			break;

		case 47:

			strcpy(alarm, "MCU communication fault.");
			break;

		default:

			snprintf(alarm, sizeof(alarm), "Unknown fault [%s]", item->value);
			break;

		}

	}

	snprintf(value, valuelen, item->dfl, alarm);
	upslogx(LOG_INFO, "Fault found: %s", alarm);

	item->qxflags |= QX_FLAG_SKIP;

	return 0;
}

/* Warnings reported by the UPS */
static int	voltronic_warning(item_t *item, char *value, size_t valuelen)
{
	char	warn[SMALLBUF] = "", unk[SMALLBUF] = "", bitwarns[SMALLBUF] = "", warns[4096] = "";
	int	i;

	if (strspn(item->value, "01") != strlen(item->value)) {
		upsdebugx(2, "%s: invalid reply from the UPS [%s]", __func__, item->value);
		return -1;
	}

	/* No warnings */
	if (strspn(item->value, "0") == strlen(item->value)) {
		return 0;
	}

	snprintf(value, valuelen, "UPS warnings:");

	for (i = 0; i < (int)strlen(item->value); i++) {

		int	u = 0;

		if (item->value[i] == '1') {

			switch (i)
			{
			case 0:

				strcpy(warn, "Battery disconnected.");
				break;

			case 1:

				strcpy(warn, "Neutral not connected.");
				break;

			case 2:

				strcpy(warn, "Site fault.");
				break;

			case 3:

				strcpy(warn, "Phase sequence incorrect.");
				break;

			case 4:

				strcpy(warn, "Phase sequence incorrect in bypass.");
				break;

			case 5:

				strcpy(warn, "Input frequency unstable in bypass.");
				break;

			case 6:

				strcpy(warn, "Battery overcharged.");
				break;

			case 7:

				strcpy(warn, "Low battery.");
				update_status("LB");
				break;

			case 8:

				strcpy(warn, "Overload alarm.");
				update_status("OVER");
				break;

			case 9:

				strcpy(warn, "Fan alarm.");
				break;

			case 10:

				strcpy(warn, "EPO enabled.");
				break;

			case 11:

				strcpy(warn, "Unable to turn on UPS.");
				break;

			case 12:

				strcpy(warn, "Over temperature alarm.");
				break;

			case 13:

				strcpy(warn, "Charger alarm.");
				break;

			case 14:

				strcpy(warn, "Remote auto shutdown.");
				break;

			case 15:

				strcpy(warn, "L1 input fuse not working.");
				break;

			case 16:

				strcpy(warn, "L2 input fuse not working.");
				break;

			case 17:

				strcpy(warn, "L3 input fuse not working.");
				break;

			case 18:

				strcpy(warn, "Positive PFC abnormal in L1.");
				break;

			case 19:

				strcpy(warn, "Negative PFC abnormal in L1.");
				break;

			case 20:

				strcpy(warn, "Positive PFC abnormal in L2.");
				break;

			case 21:

				strcpy(warn, "Negative PFC abnormal in L2.");
				break;

			case 22:

				strcpy(warn, "Positive PFC abnormal in L3.");
				break;

			case 23:

				strcpy(warn, "Negative PFC abnormal in L3.");
				break;

			case 24:

				strcpy(warn, "Abnormal in CAN-bus communication.");
				break;

			case 25:

				strcpy(warn, "Abnormal in synchronous signal circuit.");
				break;

			case 26:

				strcpy(warn, "Abnormal in synchronous pulse signal circuit.");
				break;

			case 27:

				strcpy(warn, "Abnormal in host signal circuit.");
				break;

			case 28:

				strcpy(warn, "Male connector of parallel cable not connected well.");
				break;

			case 29:

				strcpy(warn, "Female connector of parallel cable not connected well.");
				break;

			case 30:

				strcpy(warn, "Parallel cable not connected well.");
				break;

			case 31:

				strcpy(warn, "Battery connection not consistent in parallel systems.");
				break;

			case 32:

				strcpy(warn, "AC connection not consistent in parallel systems.");
				break;

			case 33:

				strcpy(warn, "Bypass connection not consistent in parallel systems.");
				break;

			case 34:

				strcpy(warn, "UPS model types not consistent in parallel systems.");
				break;

			case 35:

				strcpy(warn, "Capacity of UPSes not consistent in parallel systems.");
				break;

			case 36:

				strcpy(warn, "Auto restart setting not consistent in parallel systems.");
				break;

			case 37:

				strcpy(warn, "Battery cell over charge.");
				break;

			case 38:

				strcpy(warn, "Battery protection setting not consistent in parallel systems.");
				break;

			case 39:

				strcpy(warn, "Battery detection setting not consistent in parallel systems.");
				break;

			case 40:

				strcpy(warn, "Bypass not allowed setting not consistent in parallel systems.");
				break;

			case 41:

				strcpy(warn, "Converter setting not consistent in parallel systems.");
				break;

			case 42:

				strcpy(warn, "High loss point for frequency in bypass mode not consistent in parallel systems.");
				break;

			case 43:

				strcpy(warn, "Low loss point for frequency in bypass mode not consistent in parallel systems.");
				break;

			case 44:

				strcpy(warn, "High loss point for voltage in bypass mode not consistent in parallel systems.");
				break;

			case 45:

				strcpy(warn, "Low loss point for voltage in bypass mode not consistent in parallel systems.");
				break;

			case 46:

				strcpy(warn, "High loss point for frequency in AC mode not consistent in parallel systems.");
				break;

			case 47:

				strcpy(warn, "Low loss point for frequency in AC mode not consistent in parallel systems.");
				break;

			case 48:

				strcpy(warn, "High loss point for voltage in AC mode not consistent in parallel systems.");
				break;

			case 49:

				strcpy(warn, "Low loss point for voltage in AC mode not consistent in parallel systems.");
				break;

			case 50:

				strcpy(warn, "Warning for locking in bypass mode after 3 consecutive overloads within 30 min.");
				break;

			case 51:

				strcpy(warn, "Warning for three-phase AC input current unbalance.");
				break;

			case 52:

				strcpy(warn, "Warning for a three-phase input current unbalance detected in battery mode.");
				break;

			case 53:

				strcpy(warn, "Warning for Inverter inter-current unbalance.");
				break;

			case 54:

				strcpy(warn, "Programmable outlets cut off pre-alarm.");
				break;

			case 55:

				strcpy(warn, "Warning for Battery replace.");
				update_status("RB");
				break;

			case 56:

				strcpy(warn, "Abnormal warning on input phase angle.");
				break;

			case 57:

				strcpy(warn, "Warning!! Cover of maintain switch is open.");
				break;

			case 61:

				strcpy(warn, "EEPROM operation error.");
				break;

			default:

				snprintf(warn, sizeof(warn), "Unknown warning from UPS [bit: #%02d]", i + 1);
				u++;
				break;

			}

			upslogx(LOG_INFO, "Warning from UPS: %s", warn);

			if (u) {	/* Unknown warnings */

				snprintfcat(unk, sizeof(unk), ", #%02d", i + 1);

			} else {	/* Known warnings */

				if (strlen(warns) > 0) {

					/* For too long warnings (total) */
					snprintfcat(bitwarns, sizeof(bitwarns), ", #%02d", i + 1);

					/* For warnings (total) not too long */
					snprintfcat(warns, sizeof(warns), " %s", warn);

				} else {

					snprintf(bitwarns, sizeof(bitwarns), "Known (see log or manual) [bit: #%02d", i + 1);
					snprintf(warns, sizeof(warns), "%s", warn);

				}

			}
		}
	}

	/* There's some known warning, at least */
	if (strlen(warns) > 0) {

		/* We have both known and unknown warnings */
		if (strlen(unk) > 0) {

			/* Appending unknown ones to known ones; removing leading comma from unk - 'explicit' */
			snprintfcat(warns, sizeof(warns), " Unknown warnings [bit:%s]", unk+1);

			/* Appending unknown ones to known ones; removing leading comma from unk - 'cryptic' */
			snprintfcat(bitwarns, sizeof(bitwarns), "]; Unknown warnings [bit:%s]", unk+1);

		/* We have only known warnings */
		} else {

			snprintfcat(bitwarns, sizeof(bitwarns), "]");

		}

	/* We have only unknown warnings */
	} else if (strlen(unk) > 0) {

		/* Removing leading comma from unk */
		snprintf(warns, sizeof(warns), "Unknown warnings [bit:%s]", unk+1);
		strcpy(bitwarns, warns);

	} else {

		/* Don't know what happened */
		upsdebugx(2, "%s: failed to process warnings", __func__);
		return -1;

	}

	/* If grand total of warnings doesn't exceed value of alarm (=ST_MAX_VALUE_LEN) minus some space (32) for other alarms.. */
	if ((ST_MAX_VALUE_LEN - 32) > strlen(warns)) {
		/* ..then be explicit.. */
		snprintfcat(value, valuelen, " %s", warns);
	/* ..otherwise.. */
	} else {
		/* ..be cryptic */
		snprintfcat(value, valuelen, " %s", bitwarns);
	}

	return 0;
}

/* Working mode reported by the UPS */
static int	voltronic_mode(item_t *item, char *value, size_t valuelen)
{
	char	*status = NULL, *alarm = NULL;

	switch (item->value[0])
	{
	case 'P':

		alarm = "UPS is going ON";
		break;

	case 'S':

		status = "OFF";
		break;

	case 'Y':

		status = "BYPASS";
		break;

	case 'L':

		status = "OL";
		break;

	case 'B':

		status = "!OL";
		break;

	case 'T':

		status = "CAL";
		break;

	case 'F':

		alarm = "Fault reported by UPS.";
		break;

	case 'E':

		alarm = "UPS is in ECO Mode.";
		break;

	case 'C':

		alarm = "UPS is in Converter Mode.";
		break;

	case 'D':

		alarm = "UPS is shutting down!";
		status = "FSD";
		break;

	default:

		upsdebugx(2, "%s: invalid reply from the UPS [%s]", __func__, item->value);
		return -1;

	}

	if (alarm && !strcasecmp(item->info_type, "ups.alarm")) {

		snprintf(value, valuelen, item->dfl, alarm);

	} else if (status && !strcasecmp(item->info_type, "ups.status")) {

		snprintf(value, valuelen, item->dfl, status);

	}

	return 0;
}

/* Process status bits */
static int	voltronic_status(item_t *item, char *value, size_t valuelen)
{
	char	*val = "";

	if (strspn(item->value, "01") != strlen(item->value)) {
		upsdebugx(3, "%s: unexpected value %s@%d->%s", __func__, item->value, item->from, item->value);
		return -1;
	}

	switch (item->from)
	{
	case 63:	/* UPS Type - ups.type */

		{
			int	type = strtol(item->value, NULL, 10);

			if (!type)		/* 00 -> Offline */
				val = "offline";
			else if (type == 1)	/* 01 -> Line-interactive */
				val = "line-interactive";
			else if (type == 10)	/* 10 -> Online */
				val = "online";
			else {
				upsdebugx(2, "%s: invalid type [%s: %s]", __func__, item->info_type, item->value);
				return -1;
			}
		}

		break;

	case 65:	/* Utility Fail (Immediate) - ups.status */

		if (item->value[0] == '1')
			val = "!OL";
		else
			val = "OL";
		break;

	case 66:	/* Battery Low - ups.status */

		if (item->value[0] == '1')
			val = "LB";
		else
			val = "!LB";
		break;

	case 67:	/* Bypass/Boost or Buck Active - ups.{status,alarm} */

		if (item->value[0] == '1') {

			double	vi, vo;

			vi = strtod(dstate_getinfo("input.voltage"), NULL);
			vo = strtod(dstate_getinfo("output.voltage"), NULL);

			if (vo < 0.5 * vi) {
				upsdebugx(2, "%s: output voltage too low", __func__);
				return -1;
			}

			if (vo < 0.95 * vi) {
				val = "TRIM";
			} else if (vo < 1.05 * vi) {

				int	prot = strtol(dstate_getinfo("ups.firmware.aux")+1, NULL, 10);

				if (!prot || prot == 8) {	/* ups.alarm */

					if (!strcasecmp(item->info_type, "ups.alarm"))
						val = "UPS is in AVR Mode.";

				} else {	/* ups.status */

					if (!strcasecmp(item->info_type, "ups.status"))
						val = "BYPASS";

				}

			} else if (vo < 1.5 * vi) {
				val = "BOOST";
			} else {
				upsdebugx(2, "%s: output voltage too high", __func__);
				return -1;
			}

		}

		break;

	case 68:	/* UPS Fault - ups.alarm */

		if (item->value[0] == 1) {

			item_t	*faultitem;

			for (faultitem = voltronic_qx2nut; faultitem->info_type != NULL; faultitem++) {

				if (!faultitem->command)
					continue;

				if (!strcasecmp(faultitem->command, "QFS\r")) {
					faultitem->qxflags &= ~QX_FLAG_SKIP;
					break;
				}

			}

			val = "UPS Fault!";

		}

		break;

/*	case 69:	*//* unknown */
/*		break;*/

	case 70:	/* Test in Progress - ups.status */

		if (item->value[0] == '1')
			val = "CAL";
		else
			val = "!CAL";
		break;

	case 71:	/* Shutdown Active - ups.status */

		if (item->value[0] == '1')
			val = "FSD";
		else
			val = "!FSD";
		break;

	case 72:	/* Beeper status - ups.beeper.status */

		/* The UPS has the ability to enable/disable the alarm (from UPS capability) */
		if (alarm_control) {

			const char	*beeper = dstate_getinfo("ups.beeper.status");

			if (!beeper || strcasecmp(beeper, "disabled")) {

				if (item->value[0] == '0')	/* Beeper On */
					val = "enabled";
				else
					val = "muted";

			}

		/* The UPS lacks the ability to enable/disable the alarm (from UPS capability) */
		} else {

			if (item->value[0] == '0')	/* Beeper On */
				val = "enabled";
			else
				val = "disabled";

		}

		break;

/*	case 73:	*//* unknown */
/*		break;*/
/*	case 74:	*//* unknown */
/*		break;*/

	default:
		/* Don't know what happened */
		return -1;
	}

	snprintf(value, valuelen, "%s", val);

	return 0;
}

/* Output power factor */
static int	voltronic_output_powerfactor(item_t *item, char *value, size_t valuelen)
{
	double	opf;

	if (strspn(item->value, "0123456789 .") != strlen(item->value)) {
		upsdebugx(2, "%s: non numerical value [%s: %s]", __func__, item->info_type, item->value);
		return -1;
	}

	/* UPS report a value expressed in % so -> output.powerfactor*100 e.g. opf = 0,8 -> ups = 80 */
	opf = strtod(item->value, NULL) * 0.01;

	snprintf(value, valuelen, item->dfl, opf);

	return 0;
}

/* UPS serial number */
static int	voltronic_serial_numb(item_t *item, char *value, size_t valuelen)
{
	/* If the UPS report a 00..0 serial we'll log it but we won't store it in device.serial */
	if (strspn(item->value, "0") == strlen(item->value)) {
		upslogx(LOG_INFO, "%s: UPS reported a non-significant serial [%s]", item->info_type, item->value);
		return -1;
	}

	snprintf(value, valuelen, item->dfl, item->value);
	return 0;
}

/* Outlet status */
static int	voltronic_outlet(item_t *item, char *value, size_t valuelen)
{
	const char	*status, *switchable;
	char		number = item->info_type[7],
			buf[SMALLBUF];
	item_t		*outlet_item;

	switch (item->value[0])
	{
	case '1':

		switchable = "yes";
		status = "on";
		break;

	case '0':

		switchable = "yes";
		status = "off";
		break;

	default:

		upsdebugx(2, "%s: invalid reply from the UPS [%s: %s]", __func__, item->info_type, item->value);
		return -1;

	}

	if (strstr(item->info_type, "switchable")) {

		snprintf(value, valuelen, item->dfl, switchable);

	} else if (strstr(item->info_type, "status")) {

		snprintf(value, valuelen, item->dfl, status);

	} else {

		/* Don't know what happened */
		return -1;

	}

	/* Unskip outlet.n.delay.shutdown */
	snprintf(buf, sizeof(buf), "outlet.%c.delay.shutdown", number);

	outlet_item = find_nut_info(buf, QX_FLAG_SEMI_STATIC, 0);

	/* Don't know what happened*/
	if (!outlet_item)
		return -1;

	outlet_item->qxflags &= ~QX_FLAG_SKIP;

	/* Unskip outlet.n.load.on */
	snprintf(buf, sizeof(buf), "outlet.%c.load.on", number);

	outlet_item = find_nut_info(buf, QX_FLAG_CMD, 0);

	/* Don't know what happened*/
	if (!outlet_item)
		return -1;

	outlet_item->qxflags &= ~QX_FLAG_SKIP;

	/* Unskip outlet.n.load.off */
	snprintf(buf, sizeof(buf), "outlet.%c.load.off", number);

	outlet_item = find_nut_info(buf, QX_FLAG_CMD, 0);

	/* Don't know what happened*/
	if (!outlet_item)
		return -1;

	outlet_item->qxflags &= ~QX_FLAG_SKIP;

	return 0;
}

/* Outlet delay time */
static int	voltronic_outlet_delay(item_t *item, char *value, size_t valuelen)
{
	char	number = item->info_type[7],
		buf[SMALLBUF];
	double	val;
	item_t	*setvar_item;

	if (strspn(item->value, "0123456789 .") != strlen(item->value)) {
		upsdebugx(2, "%s: non numerical value [%s: %s]", __func__, item->info_type, item->value);
		return -1;
	}

	/* UPS reports minutes, NUT expects seconds */
	val = strtod(item->value, NULL) * 60;

	snprintf(value, valuelen, item->dfl, val);

	/* Unskip outlet.n.delay.shutdown setvar */
	snprintf(buf, sizeof(buf), "outlet.%c.delay.shutdown", number);

	setvar_item = find_nut_info(buf, QX_FLAG_SETVAR, 0);

	/* Don't know what happened*/
	if (!setvar_item)
		return -1;

	setvar_item->qxflags &= ~QX_FLAG_SKIP;

	return 0;
}

/* *SETVAR* Outlet delay time */
static int	voltronic_outlet_delay_set(item_t *item, char *value, size_t valuelen)
{
	int	delay = strtol(value, NULL, 10);

	/* From seconds to minute */
	delay = delay / 60;

	snprintf(value, valuelen, item->command, delay);

	return 0;
}

/* Type of battery */
static int	voltronic_p31b(item_t *item, char *value, size_t valuelen)
{
	int	val;

	if ((item->value[0] != '0') || (strspn(item->value+1, "012") != 1)) {

		upsdebugx(2, "%s: invalid battery type reported by the UPS [%s]", __func__, item->value);
		return -1;

	}

	val = strtol(item->value, NULL, 10);

	snprintf(value, valuelen, item->dfl, item->info_rw[val].value);

	return 0;
}

/* *SETVAR* Type of battery */
static int	voltronic_p31b_set(item_t *item, char *value, size_t valuelen)
{
	int	i;

	for (i = 0; strlen(item->info_rw[i].value) > 0; i++) {

		if (!strcasecmp(item->info_rw[i].value, value))
			break;

	}

	/* At this point value should already be checked against enum so this shouldn't happen.. however.. */
	if (i >= (int)(sizeof(item->info_rw) / sizeof(item->info_rw[0]))) {
		upslogx(LOG_ERR, "%s: value [%s] out of range", item->info_type, value);
		return -1;
	}

	snprintf(value, valuelen, "%d", i);

	return voltronic_process_setvar(item, value, valuelen);
}

/* *NONUT* Actual device grid working range type for P31 UPSes */
static int	voltronic_p31g(item_t *item, char *value, size_t valuelen)
{
	int	val;

	if ((item->value[0] != '0') || (strspn(item->value+1, "01") != 1)) {

		upsdebugx(2, "%s: invalid device grid working range reported by the UPS [%s]", __func__, item->value);
		return -1;

	}

	val = strtol(item->value, NULL, 10);

	snprintf(value, valuelen, item->dfl, item->info_rw[val].value);
	work_range_type = val;

	return 0;
}

/* *SETVAR/NONUT* Device grid working range type for P31 UPSes */
static int	voltronic_p31g_set(item_t *item, char *value, size_t valuelen)
{
	int	i;

	for (i = 0; strlen(item->info_rw[i].value) > 0; i++) {

		if (!strcasecmp(item->info_rw[i].value, value))
			break;

	}

	/* At this point value should have been already checked against enum so this shouldn't happen.. however.. */
	if (i >= (int)(sizeof(item->info_rw) / sizeof(item->info_rw[0]))) {
		upslogx(LOG_ERR, "%s: value [%s] out of range", item->info_type, value);
		return -1;
	}

	if (i == work_range_type) {
		upslogx(LOG_INFO, "%s is already set to %s", item->info_type, item->info_rw[i].value);
		return -1;
	}

	snprintf(value, valuelen, "%d", i);

	return voltronic_process_setvar(item, value, valuelen);
}

/* *NONUT* UPS actual input/output phase angles */
static int	voltronic_phase(item_t *item, char *value, size_t valuelen)
{
	int	angle;

	if (strspn(item->value, "0123456789 .") != strlen(item->value)) {
		upsdebugx(2, "%s: non numerical value [%s: %s]", __func__, item->info_type, item->value);
		return -1;
	}

	angle = strtol(item->value, NULL, 10);

	if (!strcasecmp(item->info_type, "output_phase_angle")) {

		output_phase_angle = angle;

		/* User-provided value to change.. */
		if (getval(item->info_type)) {

			item_t	*unskip;

			/* Unskip output_phase_angle setvar */
			unskip = find_nut_info(item->info_type, QX_FLAG_SETVAR, 0);

			/* Don't know what happened */
			if (!unskip)
				return -1;

			unskip->qxflags &= ~QX_FLAG_SKIP;

		}

	}

	snprintf(value, valuelen, item->dfl, angle);

	return 0;
}

/* *SETVAR/NONUT* Output phase angle */
static int	voltronic_phase_set(item_t *item, char *value, size_t valuelen)
{
	int	i;

	for (i = 0; strlen(item->info_rw[i].value) > 0; i++) {

		if (!strcasecmp(item->info_rw[i].value, value))
			break;

	}

	/* At this point value should have been already checked against enum so this shouldn't happen.. however.. */
	if (i >= (int)(sizeof(item->info_rw) / sizeof(item->info_rw[0]))) {
		upslogx(LOG_ERR, "%s: value [%s] out of range", item->info_type, value);
		return -1;
	}

	if (strtol(item->info_rw[i].value, NULL, 10) == output_phase_angle) {
		upslogx(LOG_INFO, "%s is already set to %s", item->info_type, item->info_rw[i].value);
		return -1;
	}

	snprintf(value, valuelen, "%d", i);

	return voltronic_process_setvar(item, value, valuelen);
}

/* *NONUT* UPS is master/slave in a system of UPSes in parallel */
static int	voltronic_parallel(item_t *item, char *value, size_t valuelen)
{
	char	*type;

	if (strlen(item->value) != strspn(item->value, "0123456789")) {
		upsdebugx(2, "%s: non numerical value [%s: %s]", __func__, item->info_type, item->value);
		return -1;
	}

	/* 001 for master UPS, 002 and 003 for slave UPSes */
	switch (strtol(item->value, NULL, 10))
	{
	case 1:

		type = "master";
		break;

	case 2:
	case 3:

		type = "slave";
		break;

	default:

		upsdebugx(2, "%s: invalid reply from the UPS [%s]", __func__, item->value);
		return -1;

	}

	snprintf(value, valuelen, "This UPS is *%s* in a system of UPSes in parallel", type);

	return 0;
}


/* == Subdriver interface == */
subdriver_t	voltronic_subdriver = {
	VOLTRONIC_VERSION,
	voltronic_claim,
	voltronic_qx2nut,
	NULL,
	NULL,
	voltronic_makevartable,
	"ACK",
	"(NAK\r",
#ifdef TESTING
	voltronic_testing,
#endif	/* TESTING */
};