able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/netapi/svcdlls/upssvc/apcsmart/pollparm.cxx

2525 lines
70 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
*
* NOTES:
*
* REVISIONS:
* pcy29Nov92: Used new defines from codes.h to fix 32 char name limit
* jod28Jan93: Added new Pollparams to support the Q command
* pcy02Jan93: Made sure all functions return values
* ane03Feb93: Added destructors
* pcy16Feb93: Move UPS_STATE_SET define to err.h to avoid conflicts
* pcy16Feb93: Correctly declare static class member thePollSet
* pcy16Feb93: Fix handling of UPS_STATE_SET so UpsState params are pollable
* pcy16Feb93: Fix Q command handling so all bits generate events
* pcy16Feb93: Put codes for battery test results in response
* pcy16Feb93: Convert run time remaining to seconds
* jod05Apr93: Added changes for Deep Discharge
* jod14May93: Added Matrix changes.
* pcy21May93: Moved define of NO_RECENT_TEST to codes.h
* cad10Jun93: Added mups parms, fixed pontential bugs
* cad23Jun93: made sure state was known-sized type
* pcy15Sep93: Change dipswitch value from hex to int before returning
* pcy24Sep93: Convert upslink responses to 9 command to codes
* cad07Oct93: Plugging Memory Leaks
* ajr17Feb94: Added some checking to see if getValue returns NULL
* ajr09Mar94: Added some checking to see if getValue returns NULL
* ajr20Jul94: Made sure we cleared eepromValues between usages. prevent core
* jps28aug94: shorten EepromAllowedValues and BattCalibrationCond to prevent
* link problems in os2 1.3
* djs14Jun95: Added additional event to Smart Boost Off condition.
* djs22Feb96: Added Smart Trim and IncrementPollParm
* djs07May96: Added Dark Star parameters
* pav22May96: Added init of DS statics, aded INT as return value of DS IsPollSet
* srt23May96: Checking return of sscanf in EepromAllowedValuesPollParam::ProcessValue
* tjg03Dec97: 1. Updated ModuleCountsandStatusPollParam (and all inherited
* pollparams) to check for NA response before processing.
* 2. Revamped AbnormalConditionPollParam to ensure it generates
* all possible events.
* 3. Added CurrentLoadCapabilityPollParam
* 4. Updated RimInstallationStatusPollParam to report PC+ code
* RIM_INSTALLED/RIM_NOT_INSTALLED instead of Y/N.
* tjg02Mar98: BATTERY_DOESNT_NEED_REPLACING is now reported for each poll
* mds31Jul98: In NullTest(), check value before performing a strlen on it
* mholly12May1999: add TurnOffSmartModePollParam support
*
* v-stebe 29Jul2000 Fixed PREfix errors (bugs #46337-#46341, #112598-#112609)
* v-stebe 05Sep2000 Fixed additional PREfix errors
*/
#define INCL_BASE
#define INCL_NOPM
#include "cdefine.h"
extern "C" {
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
}
#include "_defs.h"
#include "apc.h"
#include "ulinkdef.h"
#include "list.h"
#include "pollparm.h"
#include "codes.h"
#include "event.h"
#include "utils.h"
#include "err.h"
// Static member of UPSStatePollParam initialization
USHORT UPSStatePollParam::thePollSet = 0;
USHORT StateRegisterPollParam::thePollSet = 0;
USHORT TripRegisterPollParam::thePollSet = 0;
USHORT Trip1RegisterPollParam::thePollSet = 0;
USHORT AbnormalCondPollParam::thePollSet = 0;
USHORT ModuleCountsStatusPollParam::thePollSet = 0;
USHORT InputVoltageFrequencyPollParam::thePollSet = 0;
USHORT OutputVoltageCurrentsPollParam::thePollSet = 0;
PollParam :: PollParam(INT id, CHAR* query, INT time, INT poll, Type type)
: Command(NULL), ID(id), SetType(type), RequestTime(time), Pollable(poll)
{
if (Command)
{
free(Command);
Command = NULL;
}
if (query)
{
Command = _strdup(query);
}
else
{
Command = (CHAR*)NULL;
}
}
PollParam::~PollParam()
{
if (Command) free(Command);
}
CHAR* PollParam:: Query()
{
if (Command)
return _strdup(Command);
return (CHAR*)NULL;
}
INT PollParam:: Equal(RObj comp) const
{
RPollParam item = (RPollParam)comp;
if ( ID == item.GetID() )
return TRUE;
return FALSE;
}
INT SmartPollParam::ResponseLength()
{
return theResponseLength;
}
INT SmartPollParam::ProcessValue(PMessage value, PList eventList)
{
INT rval = ErrBAD_RESPONSE_VALUE;
PCHAR response = value->getResponse();
if (response) {
if ((ResponseLength() == VARIABLE_LENGTH_RESPONSE) ||
(strlen(response) == (size_t) ResponseLength()))
rval=ErrNO_ERROR;
}
return rval;
}
INT SmartPollParam :: NullTest(CHAR* value)
{
if (value || strlen(value))
return FALSE;
return TRUE;
}
INT UPSStatePollParam:: IsPollSet()
{
if (!thePollSet)
{
thePollSet = TRUE;
return ErrUPS_STATE_SET;
}
return ErrSAME_VALUE;
}
INT UPSStatePollParam:: ProcessValue(PMessage value, List* events)
{
int err = ErrCONTINUE;
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
if (!events) {
return ErrNO_VALUE;
}
USHORT cur_state = 0;
if (sscanf(value->getResponse(),"%x",&cur_state) == EOF) {
return ErrREAD_FAILED;
}
INT battery_calibration_in_progress = FALSE;
if ( BATTERYCALIBRATIONMASK & cur_state)
{
PEvent tmp = new Event(BATTERY_CALIBRATION_CONDITION,
BATTERY_CALIBRATION_IN_PROGRESS);
battery_calibration_in_progress = TRUE;
events->Append(tmp);
}
else if (BATTERYCALIBRATIONMASK & theCurrentState)
{
PEvent tmp = new Event(BATTERY_CALIBRATION_CONDITION,
NO_BATTERY_CALIBRATION_IN_PROGRESS);
events->Append(tmp);
}
if ( ONBATTERYMASK & cur_state )
{
if (! battery_calibration_in_progress)
{
PEvent tmp = new Event(UTILITY_LINE_CONDITION, LINE_BAD);
events->Append(tmp);
}
}
if ( ONLINEMASK & cur_state )
{
PEvent tmp = new Event(UTILITY_LINE_CONDITION, LINE_GOOD);
events->Append(tmp);
}
if ( LOWBATTERYMASK & cur_state )
{
PEvent tmp = new Event(BATTERY_CONDITION, BATTERY_BAD);
events->Append(tmp);
}
else if (LOWBATTERYMASK & theCurrentState)
{
PEvent tmp = new Event(BATTERY_CONDITION, BATTERY_GOOD);
events->Append(tmp);
}
if ( REPLACEBATTERYMASK & cur_state )
{
PEvent tmp = new Event(BATTERY_REPLACEMENT_CONDITION,
BATTERY_NEEDS_REPLACING);
events->Append(tmp);
}
else if (REPLACEBATTERYMASK & theCurrentState)
{
PEvent tmp = new Event(BATTERY_REPLACEMENT_CONDITION,
BATTERY_DOESNT_NEED_REPLACING);
events->Append(tmp);
}
if ( OVERLOADMASK & cur_state )
{
PEvent tmp = new Event(OVERLOAD_CONDITION, UPS_OVERLOAD);
events->Append(tmp);
}
else if (OVERLOADMASK & theCurrentState)
{
PEvent tmp = new Event(OVERLOAD_CONDITION, NO_UPS_OVERLOAD);
events->Append(tmp);
}
if ( SMARTBOOSTMASK & cur_state )
{
PEvent tmp = new Event(SMART_BOOST_STATE, SMART_BOOST_ON);
events->Append(tmp);
}
else if (SMARTBOOSTMASK & theCurrentState)
{
PEvent tmp = new Event(SMART_BOOST_STATE, SMART_BOOST_OFF);
events->Append(tmp);
}
if ( SMARTTRIMMASK & cur_state )
{
PEvent tmp = new Event(SMART_TRIM_STATE, SMART_TRIM_ON);
events->Append(tmp);
}
else if (SMARTTRIMMASK & theCurrentState)
{
PEvent tmp = new Event(SMART_TRIM_STATE, SMART_TRIM_OFF);
events->Append(tmp);
}
// if ( UPSSHUTDOWNMASK & cur_state ) // Bitwise OR
// {
// PEvent tmp = new Event(UPS_STATE, UPS_SHUTDOWN);
// events->Append(tmp);
// }
// else if (UPSSHUTDOWNMASK & theCurrentState)
// {
// PEvent tmp = new Event(UPS_STATE, UPS_NOT_SHUTDOWN);
// events->Append(tmp);
// }
theCurrentState = cur_state;
//
// Convert value from HEX to decimal for every one else
//
CHAR int_value[32];
sprintf(int_value, "%d", cur_state);
value->setResponse(int_value);
return err;
}
INT AbnormalCondPollParam:: IsPollSet()
{
if (!thePollSet)
{
thePollSet = TRUE;
return ErrABNORMAL_CONDITION_SET;
}
return ErrSAME_VALUE;
}
INT AbnormalCondPollParam:: ProcessValue(PMessage value, List* events)
{
int err = ErrNO_ERROR;
// Check for NULL
if ( NullTest(value->getResponse()) )
{
err = ErrREAD_FAILED;
}
else if ((_strcmpi(value->getResponse(), "NA") == 0) || !events) {
err = ErrNO_VALUE;
}
// If everything checks out OK
if (err == ErrNO_ERROR)
{
USHORT condition = 0;
if (sscanf(value->getResponse(),"%x",&condition) == EOF) {
err = ErrREAD_FAILED;
}
// Check if RIM is in control
if (RIM_IN_CONTROL_MASK & condition) {
// If the RIM is in control, we know its current status is OK
PEvent rim_ok_event = new Event(RIM_STATUS, RIM_OK);
events->Append(rim_ok_event);
// If so, check the IM failed bit. If the IM_FAILED bit is set,
// the IM is installed and has failed.
if (IM_FAILED_MASK & condition) {
PEvent im_installed_event = new Event(IM_INSTALLATION_STATE, IM_INSTALLED);
PEvent im_failed_event = new Event(IM_STATUS, IM_FAILED);
events->Append(im_failed_event);
events->Append(im_installed_event);
}
// If the RIM is in control and the IM failed bit is not set, then
// the IM is not installed.
else {
PEvent im_not_installed_event = new Event(IM_INSTALLATION_STATE, IM_NOT_INSTALLED);
events->Append(im_not_installed_event);
}
}
// If RIM is not in control, IM must be in control
else {
// Since IM is in control, its current state must be OK
PEvent im_ok_event = new Event(IM_STATUS, IM_OK);
PEvent im_installed_event = new Event(IM_INSTALLATION_STATE, IM_INSTALLED);
events->Append(im_ok_event);
events->Append(im_installed_event);
// Check if the RIM has failed ... NOTE that the RIM_INSTALLATION_STATE
// events will be generated by the ModuleCountsStatusPollParam
if (RIM_FAILED_MASK & condition) {
PEvent rim_failed_event = new Event(RIM_STATUS, RIM_FAILED);
events->Append(rim_failed_event);
}
else {
PEvent rim_ok_event = new Event(RIM_STATUS, RIM_OK);
events->Append(rim_ok_event);
}
}
// Check to see if any UPS modules have failed. NOTE: the else is not
// handled because we do not generate the UPS_MODULE_OK event ... this
// condition is handled by the UPS module removed and added sequence.
// (Bad modules must be removed before they will be OK again)
if (FAILED_UPS_MASK & condition) {
PEvent ups_module_failed_event = new Event(UPS_MODULE_FAILED, UPS_MODULE_FAILED);
events->Append(ups_module_failed_event);
}
// Check Redundancy state
if (REDUNDANCY_FAILED_MASK & condition) {
PEvent redundancy_failed_event = new Event(REDUNDANCY_STATE, REDUNDANCY_FAILED);
events->Append(redundancy_failed_event);
}
else {
PEvent redundancy_ok_event = new Event(REDUNDANCY_STATE, REDUNDANCY_OK);
events->Append(redundancy_ok_event);
}
// Check the Bypass contactor state
if (BYPASS_STUCK_MASK & condition) {
PEvent bypass_contactor_failed_event = new Event(BYPASS_CONTACTOR_STATE, BYPASS_CONTACTOR_FAILED);
events->Append(bypass_contactor_failed_event);
}
else {
PEvent bypass_contactor_ok_event = new Event(BYPASS_CONTACTOR_STATE, BYPASS_CONTACTOR_OK);
events->Append(bypass_contactor_ok_event);
}
// Check the input circuit breaker state
if (INPUT_BREAKER_TRIPPED_MASK & condition)
{
PEvent input_breaker_tripped_event = new Event(INPUT_BREAKER_STATE, BREAKER_OPEN);
events->Append(input_breaker_tripped_event);
}
else {
PEvent input_breaker_closed_event = new Event(INPUT_BREAKER_STATE, BREAKER_CLOSED);
events->Append(input_breaker_closed_event);
}
// Check the system fan state
if (SYSTEM_FAN_FAILED_MASK & condition)
{
PEvent fan_failed_event = new Event(SYSTEM_FAN_STATE, SYSTEM_FAN_FAILED);
events->Append(fan_failed_event);
}
else {
PEvent fan_ok_event = new Event(SYSTEM_FAN_STATE, SYSTEM_FAN_OK);
events->Append(fan_ok_event);
}
theCurrentState = condition;
//
// Convert value from HEX to decimal for every one else
//
CHAR int_value[32];
sprintf(int_value, "%d", condition);
value->setResponse(int_value);
}
return err;
}
INT ModuleCountsStatusPollParam :: IsPollSet()
{
if (!thePollSet)
{
thePollSet = TRUE;
return ErrMODULE_COUNTS_SET;
}
return ErrSAME_VALUE;
}
// ProcessValue
//
// This routine parses the UPS response containing module counts and status.
// The response is assumed to be in the following format:
// total UPS modules (dd)
// bad UPS modules (dd)
// fault tolerance level (d)
// fault tolerance alarm threshold (d)
// kVA capacity (dd.d)
// kVA capacity alarm threshold (dd.d)
// RIM present? (Y or N)
//
// All responses must be separated by a comma
INT ModuleCountsStatusPollParam :: ProcessValue(PMessage value, List* events)
{
INT err = ErrNO_ERROR;
if ( NullTest(value->getResponse()) )
{
err = ErrREAD_FAILED;
}
// Check for an NA response from the UPS. This will be returned
// if the the RIM is in control, because the RIM responds to a limited
// subset of the full Symmetra UPS-Link spec.
else if ( (!events) || (_strcmpi(value->getResponse(), "NA") == 0)) {
err = ErrNO_VALUE;
}
// If everything checks out OK
if (err == ErrNO_ERROR)
{
PCHAR module_counts;
// Be a good neighbor and don't destroy the input parameters.
PCHAR ups_response = value->getResponse();
module_counts = _strdup(ups_response);
PCHAR number_of_inverters = strtok(module_counts, ",");
PEvent Number_Of_UPS_Modules_Event =
new Event(TOTAL_INVERTERS, number_of_inverters);
events->Append(Number_Of_UPS_Modules_Event);
PCHAR bad_inverters = strtok(NULL, ",");
PEvent Bad_UPS_Modules_Event =
new Event(NUMBER_BAD_INVERTERS, bad_inverters);
events->Append(Bad_UPS_Modules_Event);
PCHAR current_redundancy = strtok(NULL, ",");
PEvent Current_Redundancy_Event =
new Event(CURRENT_REDUNDANCY,current_redundancy);
events->Append(Current_Redundancy_Event);
PCHAR minimum_redundancy = strtok(NULL, ",");
PEvent Minimum_Redundancy_Event =
new Event(MINIMUM_REDUNDANCY,minimum_redundancy );
events->Append(Minimum_Redundancy_Event);
PCHAR current_load_capability = strtok(NULL, ",");
PEvent Current_Load_Capability_Event =
new Event(CURRENT_LOAD_CAPABILITY, current_load_capability);
events->Append(Current_Load_Capability_Event);
PCHAR maximum_load_capability = strtok(NULL, ",");
PEvent Maximum_Load_Capability_Event =
new Event(MAXIMUM_LOAD_CAPABILITY, maximum_load_capability);
events->Append(Maximum_Load_Capability_Event);
PCHAR rim_installation_state = strtok(NULL, ",");
PEvent RIM_Installation_State_Event;
if ((rim_installation_state != NULL) && (_strcmpi(rim_installation_state, "y") == 0)) {
RIM_Installation_State_Event =
new Event(RIM_INSTALLATION_STATE, RIM_INSTALLED);
}
else {
RIM_Installation_State_Event =
new Event(RIM_INSTALLATION_STATE, RIM_NOT_INSTALLED);
}
events->Append(RIM_Installation_State_Event);
// free local memory allocations
free (module_counts);
}
return err;
}
INT InputVoltageFrequencyPollParam :: IsPollSet()
{
if (!thePollSet)
{
thePollSet = TRUE;
return ErrVOLTAGE_FREQUENCY_SET;
}
return ErrSAME_VALUE;
}
// ProcessValue
//
// This routine parses the UPS response containing the input
// voltages and frequency.
// The response is assumed to be in the following format:
// utility input voltage for phase A
// utility input voltage for phase B
// utility input voltage for phase C
// utility input frequency
// All responses must be separated by a comma
INT InputVoltageFrequencyPollParam :: ProcessValue(PMessage value, List* events)
{
INT err = ErrCONTINUE;
if ( NullTest(value->getResponse()) )
{
err = ErrREAD_FAILED;
}
if (!events)
{
err = ErrNO_VALUE;
}
if (err==ErrCONTINUE)
{
PCHAR input_voltage_frequency;
// Be a good neighbor and don't destroy the input parameters.
PCHAR ups_response = value->getResponse();
input_voltage_frequency = _strdup(ups_response);
// At the minimum, there will always be a phase a voltage
// and an input frequency. At most there will be three
// input voltages and a frequency
const PCHAR cVoltage_Frequency_Separator = ";";
const PCHAR cVoltage_Parameter_Separator = ",";
const PCHAR cZeroVoltage = "0.0";
PCHAR input_voltages = strtok(input_voltage_frequency,cVoltage_Frequency_Separator);
PCHAR input_frequency = strtok(NULL,cVoltage_Frequency_Separator );
PCHAR phase_a_input_voltage = strtok(input_voltages,cVoltage_Parameter_Separator );
PEvent Voltage_A_Event = new Event(INPUT_VOLTAGE_PHASE_A, phase_a_input_voltage );
events->Append(Voltage_A_Event);
PCHAR phase_b_input_voltage = strtok(NULL,cVoltage_Parameter_Separator );
PCHAR phase_c_input_voltage;
INT number_of_input_phases;
if (phase_b_input_voltage == NULL)
{
phase_b_input_voltage = cZeroVoltage;
phase_c_input_voltage = cZeroVoltage;
number_of_input_phases = 1;
}
else
{
phase_c_input_voltage = strtok(NULL, cVoltage_Parameter_Separator);
number_of_input_phases = 3;
if (phase_c_input_voltage == NULL)
{
phase_c_input_voltage = cZeroVoltage;
number_of_input_phases = 2;
}
}
PEvent Voltage_B_Event = new Event(INPUT_VOLTAGE_PHASE_B, phase_b_input_voltage );
events->Append(Voltage_B_Event);
PEvent Voltage_C_Event = new Event(INPUT_VOLTAGE_PHASE_C, phase_c_input_voltage );
events->Append(Voltage_C_Event);
PEvent Input_Frequency_Event = new Event(INPUT_FREQUENCY, input_frequency );
events->Append(Input_Frequency_Event);
CHAR input_phases[10];
_itoa(number_of_input_phases,input_phases,10);
PEvent Number_Of_Phases_Event = new Event(NUMBER_OF_INPUT_PHASES, input_phases );
events->Append(Number_Of_Phases_Event);
// free local memory allocations
free (input_voltage_frequency);
}
return err;
}
INT OutputVoltageCurrentsPollParam :: IsPollSet()
{
if (!thePollSet)
{
thePollSet = TRUE;
return ErrVOLTAGE_CURRENTS_SET;
}
return ErrSAME_VALUE;
}
// ProcessValue
//
// This routine parses the UPS response containing the output
// voltages and currents.
// The response is assumed to be in the following format:
// output voltage for phase A
// output voltage for phase B
// output voltage for phase C
// current for phase A
// current for phase B
// current for phase C
// All responses must be separated by a comma
INT OutputVoltageCurrentsPollParam :: ProcessValue(PMessage value, List* events)
{
INT err = ErrCONTINUE;
if ( NullTest(value->getResponse()) )
{
err = ErrREAD_FAILED;
}
if (!events)
{
err = ErrNO_VALUE;
}
if (err==ErrCONTINUE)
{
PCHAR output_voltage_currents;
// Be a good neighbor and don't destroy the input parameters.
PCHAR ups_response = value->getResponse();
output_voltage_currents = _strdup(ups_response);
// Separate the voltages from the currents and then process.
const PCHAR cVoltage_Currents_Separator = ";";
PCHAR output_voltages = strtok(output_voltage_currents,cVoltage_Currents_Separator );
// Extract phase voltages
const PCHAR cParameter_Separator = ",";
const PCHAR cZeroVoltage = "0.0";
PCHAR phase_a_output_voltage = strtok(output_voltages,cParameter_Separator );
PEvent Voltage_A_Event = new Event(OUTPUT_VOLTAGE_PHASE_A, phase_a_output_voltage );
events->Append(Voltage_A_Event);
PCHAR phase_b_output_voltage = strtok(NULL,cParameter_Separator );
PCHAR phase_c_output_voltage;
INT number_of_output_phases;
if (phase_b_output_voltage == NULL)
{
phase_b_output_voltage = cZeroVoltage;
phase_c_output_voltage = cZeroVoltage;
number_of_output_phases = 1;
}
else
{
phase_c_output_voltage = strtok(NULL, cParameter_Separator);
number_of_output_phases = 3;
if (phase_c_output_voltage == NULL)
{
phase_c_output_voltage = cZeroVoltage;
number_of_output_phases = 2;
}
}
PEvent Voltage_B_Event = new Event(OUTPUT_VOLTAGE_PHASE_B, phase_b_output_voltage );
events->Append(Voltage_B_Event);
PEvent Voltage_C_Event = new Event(OUTPUT_VOLTAGE_PHASE_C, phase_c_output_voltage );
events->Append(Voltage_C_Event);
CHAR output_phases[10];
_itoa(number_of_output_phases,output_phases,10);
PEvent Number_Of_Phases_Event = new Event(NUMBER_OF_OUTPUT_PHASES, output_phases );
events->Append(Number_Of_Phases_Event);
// free local memory allocations
free (output_voltage_currents);
}
return err;
}
//-------------------------------------------------------------
// This handles the CTRL Z command for upss that support it
//-------------------------------------------------------------
#if (C_OS & C_OS2)
INT EepromAllowedValsPollParam:: ProcessValue(PMessage value, List* )
#else
INT EepromAllowedValuesPollParam:: ProcessValue(PMessage value, List* )
#endif
{
CHAR response[512];
CHAR returnString[512];
INT done = FALSE;
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
strcpy (response, value->getResponse());
CHAR *workString;
CHAR command;
CHAR commandString[7];
CHAR upsType;
CHAR numChoices;
CHAR numCharPerChoice;
INT index = 0;
returnString[0] = 0;
INT scanFlag;
workString = &(response[0]);
// Loop over all the parameters that have been return by CTRL Z
//
// The String is Formatted like this
//
// ##CTcSxxxyyyzzz... where ## is the delimiter
// C is the command ex: u -- High Transfer Points
// T is the Ups Type ex M for 208,
// I for 240,
// A for 100,
// D for 120
// c is Number of choices ex 3
// S is the size of each choice 3
// xxx is the first choice -- size = 3
// yyy is the second choice -- size = 3
// zzz is the third choice -- size = 3
while (!done)
{
CHAR eepromValues[1024];
memset(eepromValues,'\0',1024);
//
// Skip over #'s. Old Matrix use two # delimeters. 3G and beyond
// want to use only 1 #.
//
while(*workString == '#') {
workString++;
}
scanFlag = sscanf(workString, "%c%c%c%c%n", &command,&upsType, &numChoices,
&numCharPerChoice, &index); //(SRT) can't rely on index to tell truth,
// when response is trunc'd in middle of
// command so I've added scanFlag instead.
switch (scanFlag) {
case 4: // normal process
{
INT choices = (int)numChoices - 48;
INT charsPChoice = (int)numCharPerChoice - 48;
workString = &(workString[index]);
if (strlen(workString)< (size_t) (choices*charsPChoice)) {
done = TRUE;
break;
}
for (INT i = 0; i < choices; i++)
{
if (i != 0)
strcat(eepromValues, ",");
strncat(eepromValues, workString, charsPChoice);
workString = &(workString[charsPChoice]);
}
// Convert command to the sensor id --
// EX: u High trans voltage to -- HIGH_TRANSFER_VOLTAGE
INT id;
commandString[0] = command;
commandString[1] = 0;
if (!strcmp(commandString, OUTPUTVOLTAGEREPORT))
{
id = OUTPUT_VOLTAGE_REPORT;
}
else if (!strcmp(commandString, LANGUAGE))
{
id = UPS_LANGUAGE;
}
else if (!strcmp(commandString, AUTOSELFTEST))
{
id = UPS_SELF_TEST_SCHEDULE;
}
else if (!strcmp(commandString, HIGHTRANSFERPOINT))
{
id = HIGH_TRANSFER_VOLTAGE;
}
else if (!strcmp(commandString, LOWTRANSFERPOINT))
{
id = LOW_TRANSFER_VOLTAGE;
}
else if (!strcmp(commandString, MINIMUMCAPACITY))
{
id = MIN_RETURN_CAPACITY;
}
else if (!strcmp(commandString, OUTPUTVOLTAGESETTING))
{
id = RATED_OUTPUT_VOLTAGE;
}
else if (!strcmp(commandString, SENSETIVITY))
{
id = UPS_SENSITIVITY;
}
else if (!strcmp(commandString, LOWBATTERYRUNTIME))
{
id = LOW_BATTERY_DURATION;
}
else if (!strcmp(commandString, ALARMDELAY))
{
id = ALARM_DELAY;
}
else if (!strcmp(commandString, SHUTDOWNDELAY))
{
id = SHUTDOWN_DELAY;
}
else if (!strcmp(commandString, SYNCTURNBACKDELAY))
{
id = TURN_ON_DELAY;
}
else if (!strcmp(commandString, EARLYTURNOFF))
{
id = EARLY_TURN_OFF_POINTS;
}
CHAR tmp[124];
sprintf(tmp, "#%d,%c,%s",id,upsType,eepromValues);
strcat(returnString,tmp);
break;
}
case 0: // end of string?
case EOF: // can be end of strin gor error, we'll assume end of string.
done = TRUE;
break;
default: // erroneous truncation
done = TRUE;
break;
} //end switch
} // end while
strcat(returnString, "#");
value->setResponse(returnString);
return ErrNO_ERROR;
}
INT SmartModePollParam::ProcessValue(PMessage value, List* )
{
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
if (strcmp(value->getResponse(), SMARTMODE_OK))
return ErrSMART_MODE_FAILED;
return ErrNO_ERROR;
}
INT TurnOffSmartModePollParam::ProcessValue(PMessage value, List* )
{
return ErrNO_ERROR;
}
INT LineConditionPollParam::ProcessValue(PMessage value, List* events)
{
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
if (!events) {
return ErrNO_VALUE;
}
//
// Convert UPS Link responses to our codes and generate appropriate
// event
//
CHAR code_value[32];
INT code = 0;
if (!strcmp(value->getResponse(), "FF" )) {
code = NO_ABNORMAL_CONDITION;
}
else {
code = ABNORMAL_CONDITION;
}
sprintf(code_value, "%d", code);
value->setResponse(code_value);
PEvent tmp = new Event(LINE_CONDITION_TEST, code);
events->Append(tmp);
return ErrCONTINUE;
}
INT LightsTestPollParam:: ProcessValue(PMessage value, List* )
{
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
if (strcmp(value->getResponse(), LIGHTSTEST_RESP))
return ErrLIGHTSTEST_REQUEST_FAILED;
return ErrNO_ERROR;
}
INT TurnOffAfterDelayPollParam::ProcessValue(PMessage value, List* )
{
PCHAR tmp_value = value->getResponse();
if (tmp_value) {
if (!strcmp(tmp_value, TURNOFFAFTERDELAY_NOT_AVAIL)) {
return ErrTURNOFFAFTERDELAY_NOT_AVAIL;
}
}
return ErrNO_ERROR;
}
INT ShutdownPollParam::ProcessValue(PMessage value, List* )
{
INT rval = ErrNO_ERROR;
PCHAR response = value->getResponse();
if (response) {
if (strcmp(response,SHUTDOWN_RESP)) {
if (!strcmp(response, SHUTDOWN_NOT_AVAIL))
rval=ErrSHUTDOWN_NOT_AVAIL;
}
}
return rval;
}
INT SimulatePowerFailurePollParam::ProcessValue(PMessage value, List* )
{
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
if (strcmp(value->getResponse(), SIMULATEPOWERFAILURE_OK))
{
if (!strcmp(value->getResponse(), SIMULATEPOWERFAILURE_NOT_AVAIL))
return ErrSIMULATEPOWERFAILURE_NOT_AVAIL;
}
return ErrNO_ERROR;
}
INT BatteryTestPollParam:: ProcessValue(PMessage value, List* )
{
if (!strcmp(value->getResponse(), BATTERYTEST_NOT_AVAIL))
{
return ErrBATTERYTEST_NOT_AVAIL;
}
return ErrNO_ERROR;
}
INT TurnOffUpsPollParam:: ProcessValue(PMessage value, List* )
{
if (!strcmp(value->getResponse(), NOT_AVAIL))
{
return ErrREAD_FAILED; //This error should be ErrTURN_OFF_UPS_NOT_AVAIL
}
return ErrNO_ERROR;
}
INT ShutdownWakeupPollParam:: ProcessValue(PMessage value, List* )
{
if (!strcmp(value->getResponse(), NOT_AVAIL))
{
return ErrREAD_FAILED; //This error should be ErrSHUT_WAKE_NOT_AVAIL
}
return ErrNO_ERROR;
}
INT BatteryCalibrationPollParam:: ProcessValue(PMessage value, List* )
{
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
if (strcmp(value->getResponse(), BATTERYCALIBRATION_OK))
{
if (!strcmp(value->getResponse(), BATTERYCALIBRATION_CAP_TOO_LOW))
return ErrBATTERYCALIBRATION_CAP_TOO_LOW;
if (!strcmp(value->getResponse(), BATTERYCALIBRATION_NOT_AVAIL))
return ErrBATTERYCALIBRATION_NOT_AVAIL;
}
return ErrNO_ERROR;
}
INT BatteryTestResultsPollParam:: ProcessValue(PMessage value, List* )
{
if ((value == NULL) || (NullTest(value->getResponse()) ))
return ErrREAD_FAILED;
char buffer[20], *val;
val = value->getResponse();
if (val == NULL)
return ErrREAD_FAILED;
if (!strcmp(val, BATTERYTEST_OK))
value->setResponse(_itoa(SELF_TEST_PASSED,buffer,10));
if (!strcmp(val, BATTERYTEST_BAD_BATTERY))
value->setResponse(_itoa(SELF_TEST_FAILED,buffer,10));
if (!strcmp(val, BATTERYTEST_NO_RECENT_TEST))
value->setResponse(_itoa(SELF_TEST_NO_RECENT_TEST,buffer,10));
if (!strcmp(val, BATTERYTEST_INVALID_TEST))
value->setResponse(_itoa(SELF_TEST_INVALID,buffer,10));
return ErrNO_ERROR;
}
INT TransferCausePollParam:: ProcessValue(PMessage value, List* )
{
if ((value == NULL) || (NullTest(value->getResponse())) )
return ErrREAD_FAILED;
char buffer[20], *val;
val = value->getResponse();
if (val == NULL)
return ErrREAD_FAILED;
if (!strcmp(val, TRANSFERCAUSE_NO_TRANSFERS))
value->setResponse(_itoa(NO_TRANSFERS,buffer,10));
if (!strcmp(val, TRANSFERCAUSE_SELF_TEST))
value->setResponse(_itoa(SELF_TEST_TRANSFER,buffer,10));
if (!strcmp(val, TRANSFERCAUSE_LINE_DETECTED))
value->setResponse(_itoa(NOTCH_SPIKE_TRANSFER,buffer,10));
if (!strcmp(val, TRANSFERCAUSE_LOW_LINE_VOLTAGE))
value->setResponse(_itoa(LOW_LINE_TRANSFER,buffer,10));
if (!strcmp(val, TRANSFERCAUSE_HIGH_LINE_VOLTAGE))
value->setResponse(_itoa(HIGH_LINE_TRANSFER,buffer,10));
if (!strcmp(val, TRANSFERCAUSE_RATE_VOLTAGE_CHANGE))
value->setResponse(_itoa(RATE_TRANSFER,buffer,10));
if (!strcmp(val, TRANSFERCAUSE_INPUT_BREAKER_TRIPPED))
value->setResponse(_itoa(INPUT_BREAKER_TRIPPED_TRANSFER,buffer,10));
return ErrNO_ERROR;
}
INT BatteryCapacityPollParam:: ProcessValue(PMessage value, List* aList)
{
if(SmartPollParam::ProcessValue(value, aList) == ErrNO_ERROR)
{
if ((*(value->getResponse()+3)) == '.')
return ErrNO_ERROR;
}
return ErrBAD_RESPONSE_VALUE;
}
INT DipSwitchPollParam:: ProcessValue(PMessage value, List* )
{
int cur_state = 0;
if (sscanf(value->getResponse(),"%x",&cur_state) == EOF) {
return ErrREAD_FAILED;
}
//
// Convert value from HEX to decimal for every one else
//
CHAR int_value[32];
sprintf(int_value, "%d", cur_state);
value->setResponse(int_value);
return ErrNO_ERROR;
}
INT RuntimeRemainingPollParam:: ProcessValue(PMessage value, List* )
{
INT err = ErrNO_ERROR;
PCHAR val = value->getResponse();
INT len = strlen(val);
if (len == 4) {
if(strcmp(val, ">>>>") == 0) {
value->setResponse("9999");
}
else {
err = ErrBAD_RESPONSE_VALUE;
}
}
else if(len == 5) {
PCHAR time_in_minutes = strtok(value->getResponse(), ":");
if(time_in_minutes) {
LONG secs = atol(time_in_minutes) * 60;
CHAR time_in_seconds[32];
value->setResponse(_ltoa(secs, time_in_seconds, 10));
}
else {
err = ErrBAD_RESPONSE_VALUE;
}
}
else {
err = ErrBAD_RESPONSE_VALUE;
}
return err;
}
INT CopyrightPollParam:: ProcessValue(PMessage value, List* )
{
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
if (strcmp(value->getResponse(), COPYRIGHT_RESP))
{
return ErrCOPYRIGHT_RESP_ERROR;
}
return ErrNO_ERROR;
}
INT BatteryVoltagePollParam:: ProcessValue(PMessage value, List* aList)
{
if(SmartPollParam::ProcessValue(value, aList) == ErrNO_ERROR)
{
if (((*(value->getResponse()+2)) == '.') || ((*(value->getResponse()+3)) == '.'))
return ErrNO_ERROR;
}
return ErrBAD_RESPONSE_VALUE;
}
INT InternalTempPollParam:: ProcessValue(PMessage value, List* aList)
{
if(SmartPollParam::ProcessValue(value, aList) == ErrNO_ERROR)
{
if ((*(value->getResponse()+3)) == '.')
return ErrNO_ERROR;
}
return ErrBAD_RESPONSE_VALUE;
}
INT OutputFreqPollParam:: ProcessValue(PMessage value, List* aList)
{
if(SmartPollParam::ProcessValue(value, aList) == ErrNO_ERROR)
{
if ((*(value->getResponse()+2)) == '.')
return ErrNO_ERROR;
}
return ErrBAD_RESPONSE_VALUE;
}
INT LineVoltagePollParam:: ProcessValue(PMessage value, List* aList)
{
if(SmartPollParam::ProcessValue(value, aList) == ErrNO_ERROR)
{
if ((*(value->getResponse()+3)) == '.')
return ErrNO_ERROR;
}
return ErrBAD_RESPONSE_VALUE;
}
INT MaxVoltagePollParam:: ProcessValue(PMessage value, List* aList)
{
if(SmartPollParam::ProcessValue(value, aList) == ErrNO_ERROR)
{
if ((*(value->getResponse()+3)) == '.')
return ErrNO_ERROR;
}
return ErrBAD_RESPONSE_VALUE;
}
INT MinVoltagePollParam:: ProcessValue(PMessage value, List* aList)
{
if(SmartPollParam::ProcessValue(value, aList) == ErrNO_ERROR)
{
if ((*(value->getResponse()+3)) == '.')
return ErrNO_ERROR;
}
return ErrBAD_RESPONSE_VALUE;
}
INT OutputVoltagePollParam:: ProcessValue(PMessage value, List* aList)
{
if(SmartPollParam::ProcessValue(value, aList) == ErrNO_ERROR)
{
if ((*(value->getResponse()+3)) == '.')
return ErrNO_ERROR;
}
return ErrBAD_RESPONSE_VALUE;
}
INT LoadPowerPollParam :: ProcessValue(PMessage value, List* aList)
{
if(SmartPollParam::ProcessValue(value, aList) == ErrNO_ERROR)
{
if ((*(value->getResponse()+3)) == '.')
return ErrNO_ERROR;
}
return ErrBAD_RESPONSE_VALUE;
}
INT DecrementPollParam:: ProcessValue(PMessage value, List* )
{
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
if (strcmp(value->getResponse(), DECREMENT_OK))
{
if (!strcmp(value->getResponse(), DECREMENT_NOT_AVAIL))
return ErrDECREMENT_NOT_AVAIL;
if (!strcmp(value->getResponse(), DECREMENT_NOT_ALLOWED))
return ErrDECREMENT_NOT_ALLOWED;
}
return ErrNO_ERROR;
}
INT IncrementPollParam:: ProcessValue(PMessage value, List* )
{
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
if (strcmp(value->getResponse(), INCREMENT_OK))
{
if (!strcmp(value->getResponse(), INCREMENT_NOT_AVAIL))
return ErrINCREMENT_NOT_AVAIL;
if (!strcmp(value->getResponse(), INCREMENT_NOT_ALLOWED))
return ErrINCREMENT_NOT_ALLOWED;
}
return ErrNO_ERROR;
}
INT UpsIdPollParam:: ProcessValue(PMessage value, List* )
{
// I had to do this because UPS don't always return a response without
// a significant delay after a data set. We get a response by asking
// for the EEPROM data param twice. The second one always works. pcy.
// The same is tru for the BatteryReplaceDate pollparam. pcy.
return ErrNO_ERROR;
}
INT BatteryReplaceDatePollParam:: ProcessValue(PMessage value, List* )
{
// I had to do this because UPS don't always return a response without
// a significant delay after a data set. We get a response by asking
// for the EEPROM data param twice. The second one always works.
// The same is tru for the UpsId pollparam. pcy.
return ErrNO_ERROR;
}
INT BatteryCondPollParam:: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if ( LOWBATTERYMASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(BATTERY_BAD,buffer,10));
theCurrentState = BATTERY_BAD;
}
else if (LOWBATTERYMASK & theCurrentState)
{
value->setResponse(_itoa(BATTERY_GOOD,buffer,10));
theCurrentState = BATTERY_GOOD;
}
return ErrNO_ERROR;
}
INT UtilLineCondPollParam:: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if ( ONBATTERYMASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(LINE_BAD,buffer,10));
theCurrentState = LINE_BAD;
}
if ( ONLINEMASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(LINE_GOOD,buffer,10));
theCurrentState = LINE_GOOD;
}
return ErrNO_ERROR;
}
INT ReplaceBattCondPollParam:: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if ( REPLACEBATTERYMASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(BATTERY_NEEDS_REPLACING,buffer,10));
theCurrentState = BATTERY_NEEDS_REPLACING;
}
else
{
value->setResponse(_itoa(BATTERY_DOESNT_NEED_REPLACING,buffer,10));
theCurrentState = BATTERY_DOESNT_NEED_REPLACING;
}
return ErrNO_ERROR;
}
INT OverLoadCondPollParam:: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if ( OVERLOADMASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(UPS_OVERLOAD,buffer,10));
theCurrentState = UPS_OVERLOAD;
}
else if (OVERLOADMASK & theCurrentState)
{
value->setResponse(_itoa(NO_UPS_OVERLOAD,buffer,10));
theCurrentState = NO_UPS_OVERLOAD;
}
return ErrNO_ERROR;
}
INT SmartBoostCondPollParam:: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if ( SMARTBOOSTMASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(SMART_BOOST_ON,buffer,10));
theCurrentState = (USHORT) cur_state; // SMART_BOOST_ON;
}
else if (SMARTBOOSTMASK & theCurrentState)
{
value->setResponse(_itoa(SMART_BOOST_OFF,buffer,10));
theCurrentState = (USHORT) cur_state; // SMART_BOOST_OFF;
}
else
value->setResponse(_itoa(SMART_BOOST_OFF,buffer,10));
return ErrNO_ERROR;
}
INT SmartTrimCondPollParam:: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if ( SMARTTRIMMASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(SMART_TRIM_ON,buffer,10));
theCurrentState = (USHORT) cur_state; // SMART_TRIM_ON;
}
else if (SMARTTRIMMASK & theCurrentState)
{
value->setResponse(_itoa(SMART_TRIM_OFF,buffer,10));
theCurrentState = (USHORT) cur_state; // SMART_TRIM_OFF;
}
else
value->setResponse(_itoa(SMART_TRIM_OFF,buffer,10));
return ErrNO_ERROR;
}
INT RedundancyConditionPollParam :: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_condition = UtilHexStringToInt(value->getResponse());
if ( REDUNDANCY_FAILED_MASK & cur_condition ) // Bitwise OR
{
value->setResponse(_itoa(REDUNDANCY_FAILED,buffer,10));
theCurrentState = (USHORT) cur_condition;
}
else if (REDUNDANCY_FAILED_MASK & theCurrentState)
{
value->setResponse(_itoa(REDUNDANCY_OK,buffer,10));
theCurrentState = (USHORT) cur_condition;
}
else
value->setResponse(_itoa(REDUNDANCY_OK,buffer,10));
return ErrNO_ERROR;
}
INT IMInstallationStatusPollParam :: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if ( RIM_IN_CONTROL_MASK & cur_state ) // Bitwise OR
{
if (IM_FAILED_MASK & cur_state)
{
value->setResponse(_itoa(IM_INSTALLED,buffer,10));
theCurrentState = (USHORT) cur_state;
}
else
{
value->setResponse(_itoa(IM_NOT_INSTALLED,buffer,10));
theCurrentState = (USHORT) cur_state;
}
}
else
{
value->setResponse(_itoa(IM_INSTALLED,buffer,10));
}
return ErrNO_ERROR;
}
INT IMStatusPollParam :: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if (IM_FAILED_MASK & cur_state) {
value->setResponse(_itoa(IM_FAILED,buffer,10));
}
else {
value->setResponse(_itoa(IM_OK,buffer,10));
}
return ErrNO_ERROR;
}
INT RIMStatusPollParam :: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if ( RIM_FAILED_MASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(RIM_FAILED,buffer,10));
theCurrentState = (USHORT) cur_state;
}
else {
value->setResponse(_itoa(RIM_OK,buffer,10));
}
return ErrNO_ERROR;
}
INT SystemFanStatusPollParam :: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if ( SYSTEM_FAN_FAILED_MASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(SYSTEM_FAN_FAILED,buffer,10));
theCurrentState = (USHORT) cur_state;
}
else if (SYSTEM_FAN_FAILED_MASK & theCurrentState)
{
value->setResponse(_itoa(SYSTEM_FAN_OK,buffer,10));
theCurrentState = (USHORT) cur_state;
}
else
value->setResponse(_itoa(SYSTEM_FAN_OK,buffer,10));
return ErrNO_ERROR;
}
INT BypassContactorStatusPollParam :: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if (BYPASS_STUCK_MASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(SYSTEM_FAN_FAILED,buffer,10));
theCurrentState = (USHORT) cur_state;
}
else if (SYSTEM_FAN_FAILED_MASK & theCurrentState)
{
value->setResponse(_itoa(BYPASS_CONTACTOR_FAILED,buffer,10));
theCurrentState = (USHORT) cur_state;
}
else
value->setResponse(_itoa(BYPASS_CONTACTOR_OK, buffer,10));
return ErrNO_ERROR;
}
INT InputBreakerTrippedStatusPollParam :: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if (INPUT_BREAKER_TRIPPED_MASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(BREAKER_OPEN,buffer,10));
theCurrentState = (USHORT) cur_state;
}
else if (INPUT_BREAKER_TRIPPED_MASK & theCurrentState)
{
value->setResponse(_itoa(BREAKER_CLOSED,buffer,10));
theCurrentState = (USHORT) cur_state;
}
else
value->setResponse(_itoa(BREAKER_CLOSED, buffer,10));
return ErrNO_ERROR;
}
INT UPSModuleStatusPollParam :: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if ( FAILED_UPS_MASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(UPS_MODULE_FAILED,buffer,10));
theCurrentState = (USHORT) cur_state;
}
else if (FAILED_UPS_MASK & theCurrentState)
{
value->setResponse(_itoa(UPS_MODULE_OK,buffer,10));
theCurrentState = (USHORT) cur_state;
}
else
value->setResponse(_itoa(UPS_MODULE_OK, buffer,10));
return ErrNO_ERROR;
}
INT NumberInstalledInvertersPollParam :: ProcessValue(PMessage value, List* )
{
INT err = ErrNO_ERROR;
PCHAR ups_response = value->getResponse();
if ( NullTest(value->getResponse()) )
{
err = ErrREAD_FAILED;
}
else if (_strcmpi(value->getResponse(), "NA") == 0) {
err = ErrNO_VALUE;
}
else {
PCHAR module_counts = _strdup(ups_response);
PCHAR number_of_inverters = strtok(module_counts, ",");
value->setResponse(number_of_inverters);
free (module_counts);
}
return err;
}
INT NumberBadInvertersPollParam :: ProcessValue(PMessage value, List* )
{
INT err = ErrNO_ERROR;
PCHAR ups_response = value->getResponse();
if ( NullTest(value->getResponse()) )
{
err = ErrREAD_FAILED;
}
else if (_strcmpi(value->getResponse(), "NA") == 0) {
err = ErrNO_VALUE;
}
else {
PCHAR module_counts = _strdup(ups_response);
// Number of bad inverters is the second parameter in list
PCHAR number_of_bad_inverters = strtok(module_counts, ",");
number_of_bad_inverters = strtok(NULL, ",");
value->setResponse(number_of_bad_inverters);
free (module_counts);
}
return err;
}
INT RedundancyLevelPollParam :: ProcessValue(PMessage value, List* )
{
INT err = ErrNO_ERROR;
PCHAR ups_response = value->getResponse();
if ( NullTest(value->getResponse()) )
{
err = ErrREAD_FAILED;
}
else if (_strcmpi(value->getResponse(), "NA") == 0) {
err = ErrNO_VALUE;
}
else {
PCHAR module_counts = _strdup(ups_response);
// Remove the first parameter.
// current redundancy is the second parameter
PCHAR current_redundancy = strtok(module_counts, ",");
current_redundancy = strtok(NULL, ",");
current_redundancy = strtok(NULL, ",");
value->setResponse(current_redundancy);
free (module_counts);
}
return err;
}
INT MinimumRedundancyPollParam :: ProcessValue(PMessage value, List* )
{
INT err = ErrNO_ERROR;
PCHAR ups_response = value->getResponse();
if ( NullTest(value->getResponse()) )
{
err = ErrREAD_FAILED;
}
else if (_strcmpi(value->getResponse(), "NA") == 0) {
err = ErrNO_VALUE;
}
else {
PCHAR module_counts = _strdup(ups_response);
// Remove unwanted parameters.
// minimum redundancy level is the third parameter
PCHAR minimum_redundancy = strtok(module_counts, ",");
minimum_redundancy = strtok(NULL, ",");
minimum_redundancy = strtok(NULL, ",");
minimum_redundancy = strtok(NULL, ",");
value->setResponse(minimum_redundancy);
free (module_counts);
}
return err;
}
INT CurrentLoadCapabilityPollParam :: ProcessValue(PMessage value, List* )
{
INT err = ErrNO_ERROR;
PCHAR ups_response = value->getResponse();
if ( NullTest(value->getResponse()) )
{
err = ErrREAD_FAILED;
}
else if (_strcmpi(value->getResponse(), "NA") == 0) {
err = ErrNO_VALUE;
}
else {
PCHAR module_counts = _strdup(ups_response);
// Remove unwanted parameters.
// current load capability is the fifth parameter
PCHAR current_load_capability = strtok(module_counts, ",");
current_load_capability = strtok(NULL, ",");
current_load_capability = strtok(NULL, ",");
current_load_capability = strtok(NULL, ",");
current_load_capability = strtok(NULL, ",");
value->setResponse(current_load_capability);
free (module_counts);
}
return err;
}
INT MaximumLoadCapabilityPollParam :: ProcessValue(PMessage value, List* )
{
INT err = ErrNO_ERROR;
PCHAR ups_response = value->getResponse();
if ( NullTest(value->getResponse()) )
{
err = ErrREAD_FAILED;
}
else if (_strcmpi(value->getResponse(), "NA") == 0) {
err = ErrNO_VALUE;
}
else {
PCHAR module_counts = _strdup(ups_response);
// Remove unwanted parameters.
// maximum load capability is the sixth parameter
PCHAR maximum_load_capability = strtok(module_counts, ",");
maximum_load_capability = strtok(NULL, ",");
maximum_load_capability = strtok(NULL, ",");
maximum_load_capability = strtok(NULL, ",");
maximum_load_capability = strtok(NULL, ",");
maximum_load_capability = strtok(NULL, ",");
value->setResponse(maximum_load_capability);
free (module_counts);
}
return err;
}
INT RIMInstallationStatusPollParam :: ProcessValue(PMessage value, List* )
{
INT err = ErrNO_ERROR;
PCHAR ups_response = value->getResponse();
if ( NullTest(value->getResponse()) )
{
err = ErrREAD_FAILED;
}
else if (_strcmpi(value->getResponse(), "NA") == 0) {
err = ErrNO_VALUE;
}
else {
PCHAR module_counts = _strdup(ups_response);
// Remove unwanted parameters.
// RIM installation state is the seventh parameter
PCHAR rim_installation_state = strtok(module_counts, ",");
rim_installation_state = strtok(NULL, ",");
rim_installation_state = strtok(NULL, ",");
rim_installation_state = strtok(NULL, ",");
rim_installation_state = strtok(NULL, ",");
rim_installation_state = strtok(NULL, ",");
rim_installation_state = strtok(NULL, ",");
CHAR buf[10];
if ((rim_installation_state != NULL) && (_strcmpi(rim_installation_state, "Y") == 0)) {
value->setResponse(_itoa(RIM_INSTALLED, buf, 10));
}
else {
value->setResponse(_itoa(RIM_NOT_INSTALLED, buf, 10));
}
free (module_counts);
}
return err;
}
INT PhaseAInputVoltagePollParam :: ProcessValue(PMessage value, List* )
{
PCHAR ups_response = value->getResponse();
PCHAR input_voltage_frequency = _strdup(ups_response);
// Phase A input voltage is the first parameter
const PCHAR cVoltage_Frequency_Separator = ";";
const PCHAR cVoltage_Separator = ",";
PCHAR input_voltages = strtok(input_voltage_frequency,cVoltage_Frequency_Separator);
PCHAR phase_a_input_voltage = strtok(input_voltages,cVoltage_Separator );
value->setResponse(phase_a_input_voltage);
free (input_voltage_frequency);
return ErrNO_ERROR;
}
INT PhaseBInputVoltagePollParam :: ProcessValue(PMessage value, List* )
{
PCHAR ups_response = value->getResponse();
PCHAR input_voltage_frequency = _strdup(ups_response);
const PCHAR cZeroVoltage = "0.0";
// Phase B input voltage is the second parameter before the
// the frequency separator. Phase B input voltage may not
// be provided in the case of single phase input.
const PCHAR cVoltage_Parameter_Separator = ",";
const PCHAR cVoltage_Frequency_Separator = ";";
PCHAR input_voltages = strtok(input_voltage_frequency,cVoltage_Frequency_Separator );
PCHAR phase_b_input_voltage = strtok(input_voltages, cVoltage_Parameter_Separator);
if (phase_b_input_voltage != NULL)
{
phase_b_input_voltage = strtok(NULL, cVoltage_Parameter_Separator);
if (phase_b_input_voltage == NULL)
{
phase_b_input_voltage = cZeroVoltage;
}
}
else
{
phase_b_input_voltage = cZeroVoltage;
}
value->setResponse(phase_b_input_voltage);
free (input_voltage_frequency);
return ErrNO_ERROR;
}
INT PhaseCInputVoltagePollParam :: ProcessValue(PMessage value, List* )
{
PCHAR ups_response = value->getResponse();
PCHAR input_voltage_frequency = _strdup(ups_response);
const PCHAR cZeroVoltage = "0.0";
// Phase C input voltage is the third parameter before the
// the frequency separator. Phase C input voltage may not
// be provided in the case of single phase input.
const PCHAR cVoltage_Parameter_Separator = ",";
const PCHAR cFrequency_Parameter_Separator = ";";
PCHAR input_voltages = strtok(input_voltage_frequency,cFrequency_Parameter_Separator );
PCHAR phase_c_input_voltage = strtok(input_voltages, cVoltage_Parameter_Separator);
if (phase_c_input_voltage != NULL)
{
phase_c_input_voltage = strtok(NULL, cVoltage_Parameter_Separator);
if (phase_c_input_voltage != NULL)
{
phase_c_input_voltage = strtok(NULL, cVoltage_Parameter_Separator);
if (phase_c_input_voltage == NULL)
{
phase_c_input_voltage = cZeroVoltage;
}
}
else
{
phase_c_input_voltage = cZeroVoltage;
}
}
else
{
phase_c_input_voltage = cZeroVoltage;
}
value->setResponse(phase_c_input_voltage);
free (input_voltage_frequency);
return ErrNO_ERROR;
}
INT InputFrequencyPollParam :: ProcessValue(PMessage value, List* )
{
const PCHAR cFrequency_Parameter_Separator = ";";
PCHAR ups_response = value->getResponse();
PCHAR input_voltage_frequency = _strdup(ups_response);
PCHAR input_voltages = strtok(input_voltage_frequency,cFrequency_Parameter_Separator );
PCHAR input_frequency = strtok(NULL, cFrequency_Parameter_Separator);
value->setResponse(input_frequency);
free (input_voltage_frequency);
return ErrNO_ERROR;
}
INT NumberOfInputPhasesPollParam :: ProcessValue(PMessage value, List* )
{
const PCHAR cFrequency_Parameter_Separator = ";";
const PCHAR cVoltage_Parameter_Separator = ",";
PCHAR ups_response = value->getResponse();
PCHAR input_voltage_frequency = _strdup(ups_response);
PCHAR input_voltages = strtok(input_voltage_frequency,cFrequency_Parameter_Separator );
input_voltages = strtok(input_voltages, cVoltage_Parameter_Separator);
input_voltages = strtok(NULL, cVoltage_Parameter_Separator);
INT number_of_input_phases;
if (input_voltages != NULL)
{
input_voltages = strtok(NULL, cVoltage_Parameter_Separator);
if (input_voltages != NULL)
{
number_of_input_phases = 3;
}
else
{
number_of_input_phases = 2;
}
}
else
{
number_of_input_phases = 1;
}
CHAR phases_string[8];
_itoa(number_of_input_phases,phases_string,10);
value->setResponse(phases_string);
free (input_voltage_frequency);
return ErrNO_ERROR;
}
INT PhaseAOutputVoltagePollParam :: ProcessValue(PMessage value, List* )
{
PCHAR ups_response = value->getResponse();
PCHAR output_voltage_currents = _strdup(ups_response);
// Phase A output voltage is the first parameter
const PCHAR cVoltage_Current_Separator = ";";
const PCHAR cVoltage_Separator = ",";
PCHAR output_voltages = strtok(output_voltage_currents,cVoltage_Current_Separator);
PCHAR phase_a_output_voltage = strtok(output_voltages,cVoltage_Separator );
value->setResponse(phase_a_output_voltage);
free (output_voltage_currents);
return ErrNO_ERROR;
}
INT PhaseBOutputVoltagePollParam :: ProcessValue(PMessage value, List* )
{
PCHAR ups_response = value->getResponse();
PCHAR output_voltage_current = _strdup(ups_response);
const PCHAR cZeroVoltage = "0.0";
// Phase B output voltage is the second parameter
// Phase B output voltage may not be provided in
// the case of single phase input.
const PCHAR cVoltage_Parameter_Separator = ",";
const PCHAR cVoltage_Current_Separator = ";";
PCHAR output_voltages = strtok(output_voltage_current,cVoltage_Current_Separator );
PCHAR phase_b_output_voltage = strtok(output_voltages, cVoltage_Parameter_Separator);
if (phase_b_output_voltage != NULL)
{
phase_b_output_voltage = strtok(NULL, cVoltage_Parameter_Separator);
if (phase_b_output_voltage == NULL)
{
phase_b_output_voltage = cZeroVoltage;
}
}
else
{
phase_b_output_voltage = cZeroVoltage;
}
value->setResponse(phase_b_output_voltage);
free (output_voltage_current);
return ErrNO_ERROR;
}
INT PhaseCOutputVoltagePollParam :: ProcessValue(PMessage value, List* )
{
PCHAR ups_response = value->getResponse();
PCHAR output_voltage_current = _strdup(ups_response);
// Phase C output voltage is the third parameter before the
// the current separator. Phase C output voltage may not
// be provided in the case of single phase output.
const PCHAR cVoltage_Parameter_Separator = ",";
const PCHAR cVoltage_Current_Separator = ";";
const PCHAR cZeroVoltage = "0.0";
PCHAR output_voltages = strtok(output_voltage_current, cVoltage_Current_Separator);
PCHAR phase_c_output_voltage = strtok(output_voltages, cVoltage_Parameter_Separator);
if (phase_c_output_voltage != NULL)
{
phase_c_output_voltage = strtok(NULL, cVoltage_Parameter_Separator);
if (phase_c_output_voltage != NULL)
{
phase_c_output_voltage = strtok(NULL, cVoltage_Parameter_Separator);
if (phase_c_output_voltage == NULL)
{
phase_c_output_voltage = cZeroVoltage;
}
}
else
{
phase_c_output_voltage = cZeroVoltage;
}
}
else
{
phase_c_output_voltage = cZeroVoltage;
}
value->setResponse(phase_c_output_voltage);
free (output_voltage_current);
return ErrNO_ERROR;
}
INT NumberOfOutputPhasesPollParam :: ProcessValue(PMessage value, List* )
{
const PCHAR cCurrent_Parameter_Separator = ";";
const PCHAR cVoltage_Parameter_Separator = ",";
PCHAR ups_response = value->getResponse();
PCHAR output_voltage_current = _strdup(ups_response);
PCHAR output_voltages = strtok(output_voltage_current,cCurrent_Parameter_Separator );
output_voltages = strtok(output_voltages,cVoltage_Parameter_Separator);
output_voltages = strtok(NULL,cVoltage_Parameter_Separator);
INT number_of_output_phases;
if (output_voltages != NULL)
{
output_voltages = strtok(NULL,cVoltage_Parameter_Separator);
if (output_voltages != NULL)
{
number_of_output_phases = 3;
}
else
{
number_of_output_phases = 2;
}
}
else
{
number_of_output_phases = 1;
}
CHAR phases_string[8];
_itoa(number_of_output_phases,phases_string,10);
value->setResponse(phases_string);
free (output_voltage_current);
return ErrNO_ERROR;
}
#if (C_OS & C_OS2)
INT BattCalibrateCondPollParam:: ProcessValue(PMessage value, List* )
#else
INT BattCalibrationCondPollParam:: ProcessValue(PMessage value, List* )
#endif
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if ( BATTERYCALIBRATIONMASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(BATTERY_CALIBRATION_IN_PROGRESS,buffer,10));
theCurrentState = BATTERY_CALIBRATED;
}
else if (BATTERYCALIBRATIONMASK & theCurrentState)
{
value->setResponse(_itoa(NO_BATTERY_CALIBRATION_IN_PROGRESS,buffer,10));
theCurrentState = NO_BATTERY_CALIBRATION;
}
return ErrNO_ERROR;
}
INT StateRegisterPollParam:: IsPollSet()
{
if (!thePollSet)
{
thePollSet = TRUE;
return ErrSTATE_SET;
}
return ErrSAME_VALUE;
}
INT StateRegisterPollParam:: ProcessValue(PMessage value, List* events)
{
int event_code = 0;
int event_value = 0;
int err = ErrCONTINUE;
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
if (!events) {
return ErrNO_VALUE;
}
int cur_state = 0;
if (sscanf(value->getResponse(),"%x",&cur_state) == EOF) {
return ErrREAD_FAILED;
}
CHAR cause[32];
if ( COMPSELECTBYPASSMASK & cur_state ) // Bitwise OR
{
PEvent tmp = new Event(BYPASS_MODE, UPS_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_SOFTWARE);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
else if (COMPSELECTBYPASSMASK & theCurrentState) {
PEvent tmp = new Event(BYPASS_MODE, UPS_NOT_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_SOFTWARE);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
if ( SWITCHEDBYPASSMASK & cur_state ) // Bitwise OR
{
PEvent tmp = new Event(BYPASS_MODE, UPS_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_SWITCH);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
else if (SWITCHEDBYPASSMASK & theCurrentState) {
PEvent tmp = new Event(BYPASS_MODE, UPS_NOT_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_SWITCH);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
theCurrentState = (USHORT) cur_state;
//
// Convert value from HEX to decimal for every one else
//
CHAR int_value[32];
sprintf(int_value, "%d", cur_state);
value->setResponse(int_value);
return err;
}
INT TripRegisterPollParam:: IsPollSet()
{
if (!thePollSet)
{
thePollSet = TRUE;
return ErrTRIP_SET;
}
return ErrSAME_VALUE;
}
INT TripRegisterPollParam:: ProcessValue(PMessage value, List* events)
{
int event_code = 0;
int event_value = 0;
int err = ErrCONTINUE;
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
if (!events) {
return ErrNO_VALUE;
}
int cur_state = 0;
if (sscanf(value->getResponse(),"%x",&cur_state) == EOF) {
return ErrREAD_FAILED;
}
CHAR cause[32];
if ( OVERTEMPMASK & cur_state ) // Bitwise OR
{
PEvent tmp = new Event(BYPASS_MODE, UPS_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_INTERNAL_TEMP);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
else if (OVERTEMPMASK & theCurrentState) {
PEvent tmp = new Event(BYPASS_MODE, UPS_NOT_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_INTERNAL_TEMP);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
if ( BATTERYCHARGERMASK & cur_state ) // Bitwise OR
{
PEvent tmp = new Event(BYPASS_MODE, UPS_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_BATT_CHARGER_FAILED);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
else if (BATTERYCHARGERMASK & theCurrentState) {
PEvent tmp = new Event(BYPASS_MODE, UPS_NOT_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_BATT_CHARGER_FAILED);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
theCurrentState = (USHORT) cur_state;
//
// Convert value from HEX to decimal for every one else
//
CHAR int_value[32];
sprintf(int_value, "%d", cur_state);
value->setResponse(int_value);
return err;
}
INT Trip1RegisterPollParam:: IsPollSet()
{
if (!thePollSet)
{
thePollSet = TRUE;
return ErrTRIP1_SET;
}
return ErrSAME_VALUE;
}
INT Trip1RegisterPollParam:: ProcessValue(PMessage value, List* events)
{
int err = ErrCONTINUE;
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
if (!events) {
return ErrNO_VALUE;
}
int cur_state = 0;
if (sscanf(value->getResponse(),"%x",&cur_state) == EOF) {
return ErrREAD_FAILED;
}
if ( BOTTOMFANFAILUREMASK & cur_state ) // Bitwise OR
{
PEvent tmp = new Event(MATRIX_FAN_STATE, FAN_FAILURE_IN_BOTTOM_BOX);
events->Append(tmp);
}
else if (BOTTOMFANFAILUREMASK & theCurrentState) {
PEvent tmp = new Event(MATRIX_FAN_STATE, FAN_OK);
events->Append(tmp);
}
if ( BYPASSPOWERSUPPLYMASK & cur_state ) // Bitwise OR
{
PEvent tmp = new Event(BYPASS_POWER_SUPPLY_CONDITION, BYPASS_POWER_SUPPLY_OK);
events->Append(tmp);
}
else if (BYPASSPOWERSUPPLYMASK & theCurrentState) {
PEvent tmp = new Event(BYPASS_POWER_SUPPLY_CONDITION, BYPASS_POWER_SUPPLY_FAULT);
events->Append(tmp);
}
CHAR cause[32];
if ( BYPASSDCIMBALANCEMASK & cur_state ) // Bitwise OR
{
PEvent tmp = new Event(BYPASS_MODE, UPS_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_DC_IMBALANCE);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
else if (BYPASSDCIMBALANCEMASK & theCurrentState) {
PEvent tmp = new Event(BYPASS_MODE, UPS_NOT_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_DC_IMBALANCE);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
if ( BYPASSOUTPUTLIMITSMASK & cur_state ) // Bitwise OR
{
PEvent tmp = new Event(BYPASS_MODE, UPS_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_VOLTAGE_LIMITS);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
else if (BYPASSOUTPUTLIMITSMASK & theCurrentState) {
PEvent tmp = new Event(BYPASS_MODE, UPS_NOT_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_VOLTAGE_LIMITS);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
if ( TOPFANFAILUREMASK & cur_state ) // Bitwise OR
{
PEvent tmp = new Event(BYPASS_MODE, UPS_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_TOP_FAN_FAILURE);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
else if (TOPFANFAILUREMASK & theCurrentState) {
PEvent tmp = new Event(BYPASS_MODE, UPS_NOT_ON_BYPASS);
if (tmp != NULL) {
sprintf(cause, "%d", BYPASS_BY_TOP_FAN_FAILURE);
tmp->AppendAttribute(BYPASS_CAUSE, cause);
events->Append(tmp);
}
}
theCurrentState = (USHORT) cur_state;
//
// Convert value from HEX to decimal for every one else
//
CHAR int_value[32];
sprintf(int_value, "%d", cur_state);
value->setResponse(int_value);
return err;
}
INT BypassPowerSupplyPollParam:: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if ( BYPASSPOWERSUPPLYMASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(BYPASS_POWER_SUPPLY_FAULT,buffer,10));
theCurrentState = BYPASSPOWERSUPPLYMASK;
}
else if (BYPASSPOWERSUPPLYMASK & theCurrentState)
{
value->setResponse(_itoa(BYPASS_POWER_SUPPLY_OK,buffer,10));
theCurrentState = 0;
}
return ErrNO_ERROR;
}
INT FanFailurePollParam:: ProcessValue(PMessage value, List* )
{
char buffer[20];
int cur_state = UtilHexStringToInt(value->getResponse());
if ( BOTTOMFANFAILUREMASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(FAN_FAILURE_IN_BOTTOM_BOX,buffer,10));
theCurrentState = BOTTOMFANFAILUREMASK;
}
else if ( TOPFANFAILUREMASK & cur_state ) // Bitwise OR
{
value->setResponse(_itoa(FAN_FAILURE_IN_TOP_BOX,buffer,10));
theCurrentState = TOPFANFAILUREMASK;
}
else if (BYPASSPOWERSUPPLYMASK & theCurrentState)
{
value->setResponse(_itoa(FAN_OK,buffer,10));
theCurrentState = 0;
}
return ErrNO_ERROR;
}
INT BypassModePollParam:: ProcessValue(PMessage value, List* )
{
if ( NullTest(value->getResponse()) )
return ErrREAD_FAILED;
if ( (strcmp(value->getResponse(), BYPASS_IN_BYPASS)) &&
(strcmp(value->getResponse(), BYPASS_OUT_OF_BYPASS)) )
{
return ErrINVALID_VALUE;
}
return ErrNO_ERROR;
}
INT
MUpsTempPollParam::ProcessValue(
PMessage value,
List* )
{
INT err = ErrNO_ERROR;
if ( NullTest(value->getResponse()) ) {
err = ErrNO_MEASURE_UPS;
}
else if ( (strlen(value->getResponse()) != 5) ||
(((value->getResponse())[2]) != '.')) {
err = ErrBAD_RESPONSE_VALUE;
}
return( err );
}
INT
MUpsHumidityPollParam::ProcessValue(
PMessage value,
List* )
{
INT err = ErrNO_ERROR;
if ( NullTest(value->getResponse()) ) {
err = ErrNO_MEASURE_UPS;
}
else if ( (strlen(value->getResponse()) != 5) ||
(((value->getResponse())[3]) != '.')) {
err = ErrBAD_RESPONSE_VALUE;
}
return( err );
}
INT
MUpsContactPosPollParam::ProcessValue(
PMessage value,
List* )
{
INT err = ErrNO_ERROR;
if ( NullTest(value->getResponse()) ) {
err = ErrNO_MEASURE_UPS;
}
else if (strlen(value->getResponse()) != 2) {
err = ErrBAD_RESPONSE_VALUE;
}
return( err );
}
INT
MUpsFirmwareRevPollParam::ProcessValue(
PMessage value,
List* )
{
INT err = ErrNO_ERROR;
PCHAR resp = value->getResponse();
if ( NullTest(resp) ) {
err = ErrNO_MEASURE_UPS;
}
else if ((strlen(resp) != 3) || (resp[0] != '4') || (resp[2] != 'x')) {
err = ErrBAD_RESPONSE_VALUE;
}
#ifdef MUPSCLEANUPFIRMWAREREV
else {
char buffer[2];
buffer[0] = resp[1];
buffer[1] = '\0';
value->setResponse(buffer);
}
#endif
return( err );
}
Reference in a new issue Copy permalink