/* * * 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 #include #include } #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 ); }