windows-xp/Source/XPSP1/NT/ds/netapi/svcdlls/upssvc/apcsmart/protsmrt.cxx

/*
*
* REVISIONS:
*  pcy29Nov92: New defines from codes.h
*  sja08Dec92: Changed #define BATTERY_TYPE to RATED_BATTERY_VOLTAGE
*  jod13Jan93: Added eventList to InterpretMessage
*  jod28Jan93: Added fixes for support of Data and Decrement Sets
*  pcy02Feb93: InterpretSetMessage needs to return a value
*  ane03Feb93: Changed BuildPollTransactionGroupMessages to check IsPollSet
*              differently
*  jod14Feb93: Handle mulit char sets (@ddd, KK, etc)
*  pcy16Feb92: Move UPS_STATE_SET define to err.h to avoid conflicts
*  pcy16Feb92: Allow gets of UpsState params
*  pcy16Feb93: Made battery test results pollable
*  pcy21Apr93: OS/2 2.0 FE Merge
*  jod05Apr93: Added changes for Deep Discharge
*  jod14May93: Added Matrix changes.
*  cad10Jun93: Added Mups parms
*  cad22Jul93: Fixed up destructor conflicts and omissions
*  cad27Aug93: Added MeasureUPS firmware poll param
*  pcy12Sep93: Split off of proto.cxx
*  pcy12Sep93: Made simulate power fail & lights test poll param a simple set
*  cad07Oct93: Plugging Memory Leaks
*  jod02Nov93: Added CIBC conditional statements
*  ajr17Feb94: Made EventSearch check Buffer before using it.
*  jps14Jul94: commented out INCL_NOPMAPI; replaced strtok() call in findCRLF -
*                I think non-reentrency was causing problems in os2
*  jps28aug94: shorted EepromAllowedValues and BattCalibrationCond for os2 1.3
*  djs22Feb96: added CHANGESET
*  cgm16Apr96: testresponse will not test an incomplete response
*  djs07May96: Added Dark Star parameters
*  cgm05Apr96: Fixed TestResponse
*  srt23May96: Modified test response to accept erroneous serial number responses.
*  djs23Oct96: Modified HIGH_TRANSFER_VOLTAGE to use DECREMENTSET
*  dma05Nov97: Added SYSTEM_FAN_STATE to ProtoList
*  mholly12May1999: add TurnOffSmartModePollParam support
*
*  v-stebe  29Jul2000   Added checks for mem. alloc. failures (bugs #46342-46352)
*  v-stebe  05Sep2000   Fixed additional PREfix errors
*/

#define INCL_BASE
#define INCL_NOPM
//#define INCL_NOPMAPI // jwa

#include "cdefine.h"

extern "C" {
#if (C_OS & C_OS2)
#include <process.h>
#include <os2.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
}

#include "_defs.h"
#include "event.h"
#include "codes.h"
#include "message.h"
#include "pollparm.h"
#include "ulinkdef.h"
#include "trans.h"
#include "protsmrt.h"
#include "err.h"
#include "cfgmgr.h"

#if (C_OS & C_UNIX)
#include "utils.h"
#endif

#define PAUSEWAIT 2100


UpsLinkProtocol :: UpsLinkProtocol()
: SimpleUpsProtocol()
{
   InitProtocol();
}


CHAR* UpsLinkProtocol :: FindCRLF(CHAR *InBuffer)
{
   PCHAR pszTest;
   for (pszTest = InBuffer; *pszTest != 0; ++pszTest)
   {
      if ((*pszTest == '\r' && *(pszTest + 1) == '\n') || *pszTest == '\n')
      {
         *pszTest = 0;
         return InBuffer;
      }
   }
   return (PCHAR)NULL;
}

/*--------------------------------------------------------------------
*
*       Function...:   EventSearch
*
*       Description:   .
*
*-------------------------------------------------------------------*/
VOID UpsLinkProtocol :: EventSearch(CHAR *Buffer, List* eventlist)
{
   if (Buffer) {
      
      int event_code;
      int event_value;
      BOOL do_event;
      INT  bypass;
      CHAR *tmpstr = Buffer;
      
      while ((tmpstr = strpbrk(tmpstr, ASYNC_CHARS)))
      {
         do_event = TRUE;     // until proven otherwise
         bypass   = FALSE;
         
         switch (*tmpstr)
         {
         case LINEFAILCHAR :
            event_code = UTILITY_LINE_CONDITION;
            event_value = LINE_BAD;
            break;
         case RETLINEFAILCHAR :
            event_code = UTILITY_LINE_CONDITION;
            event_value = LINE_GOOD;
            break;
         case LOWBATERYCHAR :
            event_code = BATTERY_CONDITION;
            event_value = BATTERY_BAD;
            break;
         case RETLLOWBATCHAR:
            event_code = BATTERY_CONDITION;
            event_value = BATTERY_GOOD;
            break;
         case REPLACEBATCHAR:
            if ( *(tmpstr+1) == '#') 
            {
               tmpstr = tmpstr+2;
               bypass = TRUE;
            }
            do_event = FALSE;
            
            
            break;
         case EEPROMCHANGECHAR:
            event_code = EEPROM_CHANGED;
            event_value = EEPROM_CHANGED;
            break;
         case MUPSALARMCHAR:
         case LOADOFFCHAR :
            //                 event = new Message(SHUTDOWN,EVENT);    //SHUTDOWN;
         default :
            do_event = FALSE;
            break;
         }
         
         if (do_event)
         {
            PEvent event = new Event(event_code, event_value);
            eventlist->Append(event);
         }
         
         if (!bypass)
            strcpy(tmpstr, (tmpstr+1));
      }
   }
}

INT   UpsLinkProtocol :: BuildMessage(Message*, List* )
{
   return 1;
}

VOID UpsLinkProtocol :: SetupMessage(Message* msg)
{
   
   int msg_id = msg->getId();
   char data[32];
   PCHAR cmd;
   
   switch(msg_id)  {
   case SET_DATA:
      sprintf(data, "%s%-8s", DECREMENTPARAMETER, msg->getValue());
      msg->setSubmit(data);
      msg->setTimeout(ProtoList[msg_id]->GetTime());
      break;
      
   default:
      cmd = ProtoList[msg_id]->Query();
      msg->setSubmit(cmd);
      free(cmd);
      msg->setTimeout(ProtoList[msg_id]->GetTime());
      if (msg->getType() == SET)
         msg->setType(ProtoList[msg_id]->GetSetType());
      
   }
}

INT UpsLinkProtocol :: BuildPollMessage(Message* msg, List* msglist)
{
   int err = ErrNO_ERROR;
   
   int msg_id = msg->getId();
   
   if (ProtoList[msg_id] == (PollParam*)NULL)
   {
      msg->setErrcode(ErrUNSUPPORTED);
      err = ErrUNSUPPORTED;
   }
   
   if(!err)  {
      if(ProtoList[msg_id]->isPollable())  {
         PCHAR cmd = ProtoList[msg_id]->Query();
         msg->setSubmit(cmd);
         free(cmd);
         msg->setTimeout(ProtoList[msg_id]->GetTime());
         msglist->Append(msg);
      }
   }
   else  {
      err = ErrNOT_POLLABLE;
   }
   return err;
}


INT UpsLinkProtocol :: BuildPollTransactionGroupMessages(PTransactionGroup aTransactionGroup)
{
   int err = ErrNO_ERROR;
   
   PTransactionItem theItem = aTransactionGroup->GetFirstTransactionItem();
   while ((theItem != NULL) && (err == ErrNO_ERROR))
   {
      if (ProtoList[theItem->GetCode()] != (PollParam*)NULL)
      {
         PollParam* poll_param = ProtoList[theItem->GetCode()];
         if ( !(poll_param->isPollable()) )
         {
            theItem->SetErrorCode(ErrNOT_POLLABLE);
            err = ErrBUILD_FAILED;
         }
         
         if(!err)  {
            //
            //  We ask the poll param if we're already polling
            //  for the poll_param.  Most pollparms return ErrNO_ERROR.
            //  The special ones TRIP, TRIP1, UPS_STATE, STATE, 
            //  MODULE_COUNTS_AND_STATUS, ABNORMAL_CONDITION_REGISTER,
            //  INPUT_VOLTAGE_FREQUENCY, and OUTPUT_VOLTAGE_CURRENTS have
            //  multiple poll params that use the same ups link character.
            //  We dont want send the same char twice in one poll loop, so
            //  we let the poll param tell us if its been added by someone
            //  else.
            //
            err = poll_param->IsPollSet();
            if (err == ErrUPS_STATE_SET)  {
               err = ErrNO_ERROR;
               theItem->SetCode(UPS_STATE);   // Switch the code
            }
            else if (err == ErrTRIP_SET)  {
               err = ErrNO_ERROR;
               theItem->SetCode(TRIP_REGISTER);   // Switch the code
            }
            else if (err == ErrTRIP1_SET)  {
               err = ErrNO_ERROR;
               theItem->SetCode(TRIP1_REGISTER);   // Switch the code
            }
            else if (err == ErrSTATE_SET)  {
               err = ErrNO_ERROR;
               theItem->SetCode(STATE_REGISTER);   // Switch the code to be upssate
            }
            if (err == ErrABNORMAL_CONDITION_SET)  {
               err = ErrNO_ERROR;
               theItem->SetCode(ABNORMAL_CONDITION_REGISTER); 
            }
            if (err == ErrMODULE_COUNTS_SET)  {
               err = ErrNO_ERROR;
               theItem->SetCode(MODULE_COUNTS_AND_STATUS);  
            }
            if (err == ErrVOLTAGE_FREQUENCY_SET)  {
               err = ErrNO_ERROR;
               theItem->SetCode(INPUT_VOLTAGE_FREQUENCY);   
            }
            if (err == ErrVOLTAGE_CURRENTS_SET)  {
               err = ErrNO_ERROR;
               theItem->SetCode(OUTPUT_VOLTAGE_CURRENTS);  
            }
            else  if(err == ErrSAME_VALUE) {
               err = ErrBUILD_FAILED;
               theItem->SetErrorCode(ErrSAME_VALUE);
            }
            else  {
               err = ErrNO_ERROR;
            }
         }
      }
      else
         err = ErrNOT_POLLABLE;
      
      theItem = aTransactionGroup->GetNextTransactionItem();
   }
   if (err == ErrNO_ERROR)
   {
      err = BuildTransactionGroupMessages(aTransactionGroup);
   }
   return err;
} 


List* UpsLinkProtocol :: BuildTransactionMessageList(Type aType, INT aCode, CHAR* aValue)
{
   List* msglist;
   
   PollParam* poll_param = ProtoList[aCode];
   
   if(poll_param == NULL)  {
      return (List*)NULL;
   }
   
   switch(aType)  {
   case GET:
      msglist = BuildGetMessage(aCode);
      break;
      
   case SET: {
      int set_type = poll_param->GetSetType();
      switch(set_type)  {
      case DATASET:
         msglist = BuildDataSetMessage(aCode, aValue);
         break;
         
      case DECREMENTSET:
         msglist = BuildDecrementSetMessage(aCode, aValue);
         break;
         
      case PAUSESET:
         msglist = BuildPauseSetMessage(aCode, aValue);
         break;
         
      case CHANGESET:
         msglist = BuildChangeSetMessage(aCode, aValue);
         break;
         
      default:
         msglist = BuildStandardSetMessage(aCode, aValue);
         break;
      }
             }
   }
   
   return msglist;
}

List* UpsLinkProtocol :: BuildDataSetMessage(INT aCode, CHAR* aValue)
{
   List*  msglist = new List();
   
   
   // Initial get
   PollParam* poll_param = ProtoList[aCode];
   PMessage msg = new Message(aCode);
   PCHAR cmd = poll_param->Query();
   
   if (msg != NULL) {
     msg->setSubmit(cmd);
     msg->setTimeout(poll_param->GetTime());
     msglist->Append(msg);
   }
   
   free(cmd);
   
   
   // Data
   poll_param = ProtoList[SET_DATA];
   PMessage datamsg = new Message(SET_DATA);
   char data[32];
   if (datamsg != NULL) {

     sprintf(data, "%s%8s", DECREMENTPARAMETER, aValue);
     datamsg->setSubmit(data);
     datamsg->setTimeout(poll_param->GetTime());
     msglist->Append(datamsg);
   }

   // Put in two dummy gets to fix UPSLinkism that requires a unspecified
   // delay after getting the last OK.  I'm sorry I had to do this, but its
   // December 14, I go on vacation next week an we have to get this don.:(
   poll_param = ProtoList[aCode];
   cmd = poll_param->Query();
   
   Message* dummy_get = new Message(aCode);
   if (dummy_get != NULL) {
     dummy_get->setSubmit(cmd);
     dummy_get->setTimeout(poll_param->GetTime());
     msglist->Append(dummy_get);
   }
   
   dummy_get = new Message(aCode);
   if (dummy_get != NULL) {
     dummy_get->setSubmit(cmd);
     dummy_get->setTimeout(poll_param->GetTime());
     msglist->Append(dummy_get);
   }
   
   
   // Verify with get
   Message* get = new Message(aCode);
   if (get != NULL) {
     get->setSubmit(cmd);
     get->setTimeout(poll_param->GetTime());
     get->setCompare(&(data[1]));   // skip the first char (-)
     msglist->Append(get);
   }
   
   free(cmd);
   
   return msglist;
}



List* UpsLinkProtocol :: BuildPauseSetMessage(INT aCode, CHAR* aValue)
{
   
   List*  msglist = new List();
   
   // Really only action type stuff.  How will we deal with commands that
   // require two letters (S, wait 1 seconds, S).  Possibly use
   // TURN_OFF_UPS as the code, and set an inter character delay as part of
   // protocol message.  For now this only handles the simple stuff. 
   PollParam* poll_param = ProtoList[aCode];
   PMessage msg = new Message(aCode);
   
   if ((msg != NULL) && (msglist != NULL)) {
     CHAR submit_string[50];
     PCHAR cmd = poll_param->Query();
   
     *submit_string = '\0';
     if (cmd != NULL) {
       strcpy(submit_string,cmd);
       strcat(submit_string,cmd);
       free(cmd);
     }
   
     //  if(poll_param->GetSetType() != SIMPLE_SET)  {
     //    if (aValue)  {
     //      strcat(submit_string,aValue);
     //    }
     //  }
   
     msg->setSubmit(submit_string);
     msg->setTimeout(poll_param->GetTime());
     msg->setWaitTime(PAUSEWAIT);
     msglist->Append(msg);
   }
   else {
     // Clean up memory so we don't leak
     delete msglist;
     delete msg;
   }

   return msglist;
}


List* UpsLinkProtocol :: BuildChangeSetMessage(INT aCode, CHAR* aValue)
{
   List*  msglist = new List();
   
   
   // Initial get.  InterpretMessage will verify.
   PollParam* poll_param = ProtoList[aCode];
   PMessage msg = new Message(aCode);
   if (msg != NULL) {
     PCHAR cmd = poll_param->Query();
   
     msg->setSubmit(cmd);
     msg->setTimeout(poll_param->GetTime());
     msg->setCompare(aValue);
     msglist->Append(msg);
   
     free(cmd);
   }
   
   return msglist;
}

List* UpsLinkProtocol :: BuildDecrementSetMessage(INT aCode, CHAR* aValue)
{
   List*  msglist = new List();
   
   
   // Initial get.  InterpretMessage will verify.
   PollParam* poll_param = ProtoList[aCode];
   PMessage msg = new Message(aCode);
   if (msg != NULL) {
     PCHAR cmd = poll_param->Query();
   
     msg->setSubmit(cmd);
     msg->setTimeout(poll_param->GetTime());
     msg->setCompare(aValue);
     msglist->Append(msg);
   
     free(cmd);
   }
   
   return msglist;
}

INT UpsLinkProtocol :: InterpretSetMessage(Message* msg, List* newmsglist)
{
   INT err = ErrNO_ERROR;
   
   if (msg->getCompare()) {
      
      if (strncmp(msg->getCompare(), msg->getResponse(), 8 ) == 0) {
         msg->setErrcode(ErrNO_ERROR);
      }
      else {
         
         if (theCurrentTransactionGroup->GetInitialSetResponse() == (CHAR*)NULL)
            theCurrentTransactionGroup->SetInitialSetResponse(msg->getResponse());
         else {  
            
            if (!strncmp(theCurrentTransactionGroup->GetInitialSetResponse(),
               msg->getResponse(), strlen(msg->getResponse()) )){
               
               if (theCurrentTransactionGroup->GetInitialSetResponseRepeated()) {
                  msg->setErrcode(ErrSET_VALUE_NOT_FOUND);
                  return ErrSET_VALUE_NOT_FOUND;
               }
               else {
                  theCurrentTransactionGroup->SetInitialSetResponseRepeated(TRUE);
               }
            }
         }
         CHAR compare[32];
         
         PollParam* poll_param = (PollParam*)NULL;
         Message* decrement = (Message*)NULL;
         Message* verify = (Message*)NULL;
         PCHAR cmd;
         
         PollParam* orig_poll_param = ProtoList[msg->getId()];
         
         switch(orig_poll_param->GetSetType()) {
            
         case DECREMENTSET:
            {
               // save the compare value, we'll use it later
               strcpy(compare, msg->getCompare());
               
               PMessage orig_msg = new Message(msg->getId(),
                  msg->getType(),
                  msg->getValue());

               if (orig_msg !=NULL) {
                 orig_msg->setSubmit(msg->getSubmit());
                 orig_msg->setTimeout(msg->getTimeout());
                 newmsglist->Append(orig_msg);
               }
               
               
               // Reset get message. should we create a new message here,
               // or is it OK to use the old one??
               // msg->setResponse((CHAR*)NULL);
               // msg->setErrcode(ErrNO_ERROR);
               // msg->setCompare((CHAR*)NULL);
               //           newmsglist = new List();
               // newmsglist->Append(msg);
               
               // Now add the Decrement message
               poll_param = ProtoList[EEPROM_DECREMENT];
               decrement = new Message(EEPROM_DECREMENT);
               if (decrement != NULL) {
                 cmd = poll_param->Query();
               
                 decrement->setSubmit(cmd);
                 decrement->setTimeout(poll_param->GetTime());
                 newmsglist->Append(decrement);
               
                 free(cmd);
               }
               
               // Now Verify with another get
               verify = new Message(msg);
               if (verify!=NULL) {
                 verify->setCompare(compare);
                 newmsglist->Append(verify);
               }
            }
            break;      //   this is new ?????  JIMD
            
         case CHANGESET:
            {
               // A CHANGESET message will increment or
               // decrement a UPS parameter  based upon the 
               // current value stored in the UPS.
               
               // save the compare value, we'll use it later
               strcpy(compare, msg->getCompare());
               
               PMessage orig_msg = new Message(msg->getId(),
                  msg->getType(),
                  msg->getValue());
               if (orig_msg != NULL) {
                 orig_msg->setSubmit(msg->getSubmit());
                 orig_msg->setTimeout(msg->getTimeout());
                 newmsglist->Append(orig_msg);
               }
               
               // Now add the Change message
               PMessage changemsg = (PMessage)NULL;
               if (atoi(msg->getCompare()) < atoi(msg->getResponse())) 
               {
                  poll_param = ProtoList[EEPROM_DECREMENT];
                  changemsg = new Message(EEPROM_DECREMENT);
               }
               else {
                  poll_param = ProtoList[EEPROM_INCREMENT];
                  changemsg = new Message(EEPROM_INCREMENT);
               }  

               if (changemsg != NULL) {
                 cmd = poll_param->Query();
               
                 changemsg->setSubmit(cmd);
                 changemsg->setTimeout(poll_param->GetTime());
                 newmsglist->Append(changemsg);
               
                 free(cmd);
               }
               
               // Now Verify with another get
               verify = new Message(msg);
               if (verify != NULL) {
                 verify->setCompare(compare);
                 newmsglist->Append(verify);
               }
            }
            break;
            
         case DATASET:
            
         default:
            msg->setErrcode(ErrSET_FAILED);
         }        // end switch
   }        // end strncmp
    }
    else  {
       PollParam* orig_poll_param = ProtoList[msg->getId()];
       err = orig_poll_param->ProcessValue(msg, (PList)NULL);
       msg->setErrcode(err);
    }
    return err;
}

INT UpsLinkProtocol :: InterpretMessage(Message* msg, List* eventList, List* newmsglist)
{
   PList tiList = (PList)NULL;
   PTransactionItem trans_item = (PTransactionItem)NULL;
   PTransactionItem tmpti = (PTransactionItem)NULL;
   
   EventSearch(msg->getResponse(),eventList);
   
   FindCRLF(msg->getResponse());
   
   PollParam* orig_poll_param = ProtoList[msg->getId()];
   switch(theCurrentTransactionGroup->GetType())
   {
     case SET:
        InterpretSetMessage(msg, newmsglist);
        break;
     case GET:
        msg->setErrcode(orig_poll_param->ProcessValue(msg, eventList));
        
        tiList = theCurrentTransactionGroup->GetTransactionItemList();
        tmpti = new TransactionItem(GET,msg->getId());
        trans_item = (PTransactionItem)tiList->Find(tmpti);
        if (trans_item)
        {
           trans_item->SetErrorCode(msg->getErrcode());
           trans_item->SetValue(msg->getResponse());
        }
        delete tmpti;
        tmpti = NULL;
        break;
   }        // end switch GetType()
   
   return msg->getErrcode();
}
INT UpsLinkProtocol :: TestResponse(Message* msg,CHAR* Buffer,USHORT BufferSize)
{
   
   int err = ErrREAD_FAILED;
   CHAR lBuffer[512];
   PCHAR lPtr = NULL;
   strncpy(lBuffer,Buffer,BufferSize);      //make a local copy
   lBuffer[BufferSize]= '\0';
   switch (msg->getId()) {
   case UPS_SERIAL_NUMBER: {// fixes serial number problem
      for(INT i=0;i<BufferSize;i++) {
           if(Buffer[i]=='\n') {
              Message tmpMsg(msg->getId());
              tmpMsg.setResponse(Buffer);
              PollParam* pollparm = ProtoList[msg->getId()];
              
              err = pollparm->ProcessValue(&tmpMsg);
              break;
           }
      }
      return err;
                           }
      break;
   case UPS_ALLOWED_VALUES:
      // test allowed values response, a bad snmp adaptor will truncate
      // the response, but terminate it with \r\n making it look valid.
      if ((lPtr = strstr(lBuffer, "\r\n")) == NULL)
           return err;        // broken ctrl-z (no \r\n), return error.
      break;               // possibly real, allow response to be validated.
      
      
   default:
      if ((lPtr = strstr(lBuffer, "\r\n")) == NULL)
           return err;
      break;          // should hardly ever get here cuz this function is only
      // called for HARD read errors or responses w/o \r\n.
      // though you can get here if using a flaky snmp adapter
      // which truncates commands and terminates them w/ \r\n
      // making them look valid.  IN such a case, the individual
      // response's processValue funciton should catch the error.
   }
   
   *lPtr = '\0';     // most ProcessValue funcs expect \0 not \r\n, so convert.
   Message tmpMsg(msg->getId());
   tmpMsg.setResponse(lBuffer);
   
   PollParam *pollparm = ProtoList[msg->getId()];
   err = pollparm->ProcessValue(&tmpMsg);        
   
   return err;
}

/*--------------------------------------------------------------------
*
*       Function...:   InitProtocol
*
*       Description:   Initializes all the protocol. 
*
*-------------------------------------------------------------------*/

VOID UpsLinkProtocol::InitProtocol()
{
   FLOAT DELAY_FACTOR = (FLOAT)50.0;
   
   // I wish there was a better way...
   //
   delete ProtoList[UTILITY_LINE_CONDITION];
   ProtoList[UTILITY_LINE_CONDITION] = NULL;
   delete ProtoList[BATTERY_CONDITION];
   ProtoList[BATTERY_CONDITION] = NULL;
   delete ProtoList[TURN_OFF_UPS];
   ProtoList[TURN_OFF_UPS] = NULL;
   delete ProtoList[TURN_OFF_UPS_ON_BATTERY];
   ProtoList[TURN_OFF_UPS_ON_BATTERY] = NULL;
   delete ProtoList[TURN_ON_SMART_MODE];
   ProtoList[TURN_ON_SMART_MODE] = NULL;
   ProtoList[TURN_ON_SMART_MODE] = new SmartModePollParam(TURN_ON_SMART_MODE, SMARTMODE, (int)(50*DELAY_FACTOR), NO_POLL);
   ProtoList[TURN_OFF_SMART_MODE] = new TurnOffSmartModePollParam(TURN_OFF_SMART_MODE, TURNOFFSMARTMODE, (int)(50*DELAY_FACTOR), NO_POLL);
   ProtoList[LIGHTS_TEST] = new LightsTestPollParam(LIGHTS_TEST, LIGHTSTEST, (int)(50*DELAY_FACTOR), NO_POLL, SIMPLE_SET);
   ProtoList[TURN_OFF_UPS_AFTER_DELAY] = new TurnOffAfterDelayPollParam(TURN_OFF_UPS_AFTER_DELAY, TURNOFFAFTERDELAY, (int)(50*DELAY_FACTOR), NO_POLL, PAUSESET);
   ProtoList[TURN_OFF_UPS_ON_BATTERY] = new ShutdownPollParam(TURN_OFF_UPS_ON_BATTERY,TURNOFFUPSONBATT , (int)(50*DELAY_FACTOR), NO_POLL);
   ProtoList[SIMULATE_POWER_FAIL] = new SimulatePowerFailurePollParam(SIMULATE_POWER_FAIL, SIMULATEPOWERFAIL, (int)(50*DELAY_FACTOR), NO_POLL, SIMPLE_SET);
   ProtoList[SELF_TEST] = new BatteryTestPollParam(SELF_TEST, BATTERYTEST, (int)(50*DELAY_FACTOR), NO_POLL);
   ProtoList[TURN_OFF_UPS] = new TurnOffUpsPollParam(TURN_OFF_UPS, SHUTDOWNUPS, (int)(50*DELAY_FACTOR), NO_POLL, PAUSESET);
   ProtoList[PUT_UPS_TO_SLEEP] = new ShutdownWakeupPollParam(PUT_UPS_TO_SLEEP, SHUTDOWNUPSWAKEUP, (int)(50*DELAY_FACTOR), NO_POLL);
   ProtoList[BATTERY_CALIBRATION_TEST] = new BatteryCalibrationPollParam(BATTERY_CALIBRATION_TEST, BATTERYCALIBRATION,(int)(50*DELAY_FACTOR), NO_POLL, SIMPLE_SET);
#ifndef CIBC
   ProtoList[BYPASS_MODE] = new BypassModePollParam(BYPASS_MODE, BYPASSMODE, (int)(50*DELAY_FACTOR), POLL,SIMPLE_SET);
   ProtoList[BYPASS_POWER_SUPPLY_CONDITION] = new BypassPowerSupplyPollParam(BYPASS_POWER_SUPPLY_CONDITION, TRIPREGISTER1, (int)(50*DELAY_FACTOR), POLL);
#endif
   /****   STATUS INQUERY COMMANDS  ****/
   ProtoList[SELF_TEST_RESULT] = new BatteryTestResultsPollParam(SELF_TEST_RESULT, BATTERYTESTRESULT, (int)(50*DELAY_FACTOR), POLL);
#ifndef CIBC
   //    ProtoList[BATTERY_PACKS] = new NumberBatteryPacksPollParam(BATTERY_PACKS, BATTERYPACKS, (int)(60*DELAY_FACTOR), POLL,CHANGESET);
   ProtoList[EXTERNAL_BATTERY_PACKS] = new NumberBatteryPacksPollParam(EXTERNAL_BATTERY_PACKS, BATTERYPACKS, (int)(60*DELAY_FACTOR), POLL,CHANGESET);
   ProtoList[BAD_BATTERY_PACKS] = new NumberBadBatteryPacksPollParam(BAD_BATTERY_PACKS, BADBATTERYPACKS, (int)(60*DELAY_FACTOR), POLL);
#endif
   ProtoList[DECIMAL_FIRMWARE_REV] = new FirmwareVersionPollParam(DECIMAL_FIRMWARE_REV, UPSNEWFIRMWAREREV, (int)(60*DELAY_FACTOR), NO_POLL);
   ProtoList[TRANSFER_CAUSE] = new TransferCausePollParam(TRANSFER_CAUSE,TRANSFERCAUSE, (int)(40*DELAY_FACTOR), NO_POLL);
   ProtoList[FIRMWARE_REV] = new FirmwareVersionPollParam(FIRMWARE_REV, FIRMWAREREV, (int)(60*DELAY_FACTOR), NO_POLL);
   ProtoList[RATED_BATTERY_VOLTAGE] = new BatteryTypePollParam(RATED_BATTERY_VOLTAGE, UPSTYPE, (int)(60*DELAY_FACTOR), NO_POLL);
   ProtoList[BATTERY_CAPACITY] = new BatteryCapacityPollParam(BATTERY_CAPACITY, BATTERYCAPACITY,(int)(80*DELAY_FACTOR), POLL);
   ProtoList[UPS_STATE] = new UPSStatePollParam(UPS_STATE, UPSSTATE, (int)(50*DELAY_FACTOR), POLL);
#ifndef CIBC
   ProtoList[STATE_REGISTER] = new StateRegisterPollParam(STATE_REGISTER, STATEREGISTER, (int)(50*DELAY_FACTOR), POLL);
   ProtoList[MATRIX_FAN_STATE] = new FanFailurePollParam(MATRIX_FAN_STATE, TRIPREGISTER1, (int)(50*DELAY_FACTOR), POLL);
#endif
   ProtoList[DIP_SWITCH_POSITION] = new DipSwitchPollParam(DIP_SWITCH_POSITION, DIPSWITCHES, (int)(50*DELAY_FACTOR), POLL);
   ProtoList[RUN_TIME_REMAINING] = new RuntimeRemainingPollParam(RUN_TIME_REMAINING, BATTERYRUNTIMEAVAIL, (int)(80*DELAY_FACTOR), POLL);
   ProtoList[COPYRIGHT] = new CopyrightPollParam(COPYRIGHT, COPYRIGHTCOMMAND,(int)(100*DELAY_FACTOR), NO_POLL);
   ProtoList[BATTERY_VOLTAGE] = new BatteryVoltagePollParam(BATTERY_VOLTAGE, BATTERYVOLTAGE,(int)(80*DELAY_FACTOR), POLL);
   ProtoList[UPS_TEMPERATURE] = new InternalTempPollParam(UPS_TEMPERATURE, INTERNALTEMP,(int)(80*DELAY_FACTOR), POLL);
   ProtoList[OUTPUT_FREQUENCY] = new OutputFreqPollParam(OUTPUT_FREQUENCY, OUTPUTFREQ,(int)(80*DELAY_FACTOR), POLL);
   ProtoList[LINE_VOLTAGE] = new LineVoltagePollParam(LINE_VOLTAGE, LINEVOLTAGE,(int)(80*DELAY_FACTOR), POLL);
   ProtoList[MAX_LINE_VOLTAGE] = new MaxVoltagePollParam(MAX_LINE_VOLTAGE, MAXLINEVOLTAGE,(int)(80*DELAY_FACTOR), POLL);
   ProtoList[MIN_LINE_VOLTAGE] = new MinVoltagePollParam(MIN_LINE_VOLTAGE, MINLINEVOLTAGE,(int)(80*DELAY_FACTOR), POLL);
   ProtoList[OUTPUT_VOLTAGE] = new OutputVoltagePollParam(OUTPUT_VOLTAGE, OUTPUTVOLTAGE,(int)(80*DELAY_FACTOR), POLL);
   ProtoList[UPS_LOAD] = new LoadPowerPollParam(UPS_LOAD, LOADPOWER,(int)(80*DELAY_FACTOR), POLL);
   ProtoList[EEPROM_DECREMENT] = new DecrementPollParam(EEPROM_DECREMENT, DECREMENTPARAMETER, (int)(50*DELAY_FACTOR), NO_POLL,DECREMENTSET);
   ProtoList[EEPROM_INCREMENT] = new IncrementPollParam(EEPROM_INCREMENT, INCREMENTPARAMETER, (int)(50*DELAY_FACTOR), NO_POLL,INCREMENTSET);
   ProtoList[DATA_DECREMENT] = new DataDecrementPollParam(DATA_DECREMENT, DECREMENTPARAMETER, 50, NO_POLL);
   ProtoList[UPS_SELF_TEST_SCHEDULE] = new AutoSelfTestPollParam(UPS_SELF_TEST_SCHEDULE, AUTOSELFTEST, (int)(60*DELAY_FACTOR), NO_POLL, DECREMENTSET);
   ProtoList[UPS_ID] = new UpsIdPollParam(UPS_ID, UPSID, (int)(250*DELAY_FACTOR), NO_POLL,DATASET);
   ProtoList[UPS_SERIAL_NUMBER] = new SerialNumberPollParam(UPS_SERIAL_NUMBER, UPSSERIALNUMBER, (int)(250*DELAY_FACTOR), NO_POLL, DATASET);
   ProtoList[MANUFACTURE_DATE] = new ManufactureDatePollParam(MANUFACTURE_DATE, UPSMANUFACTUREDATE, (int)(250*DELAY_FACTOR), NO_POLL, DATASET);
   ProtoList[BATTERY_REPLACEMENT_DATE] = new BatteryReplaceDatePollParam(BATTERY_REPLACEMENT_DATE, BATTERYREPLACEDATE,
      (int)(250*DELAY_FACTOR), NO_POLL, DATASET);
   ProtoList[HIGH_TRANSFER_VOLTAGE] = new HighTransferPollParam(HIGH_TRANSFER_VOLTAGE,
      HIGHTRANSFERPOINT, (int)(60*DELAY_FACTOR), NO_POLL,DECREMENTSET);
   ProtoList[LOW_TRANSFER_VOLTAGE] = new LowTransferPollParam(LOW_TRANSFER_VOLTAGE, LOWTRANSFERPOINT, (int)(60*DELAY_FACTOR), NO_POLL,DECREMENTSET);
   ProtoList[MIN_RETURN_CAPACITY] = new MinCapacityPollParam(MIN_RETURN_CAPACITY, MINIMUMCAPACITY, (int)(50*DELAY_FACTOR), NO_POLL,DECREMENTSET);
   ProtoList[RATED_OUTPUT_VOLTAGE] = new RatedOutputVoltagePollParam(RATED_OUTPUT_VOLTAGE,
      OUTPUTVOLTAGESETTING, (int)(60*DELAY_FACTOR), NO_POLL,DECREMENTSET);
   ProtoList[UPS_SENSITIVITY] = new SensitivityPollParam(UPS_SENSITIVITY, SENSETIVITY, (int)(40*DELAY_FACTOR), NO_POLL,DECREMENTSET);
   ProtoList[LOW_BATTERY_DURATION] = new LowBattDurationPollParam(LOW_BATTERY_DURATION,
      LOWBATTERYRUNTIME, (int)(50*DELAY_FACTOR), NO_POLL,DECREMENTSET);
   ProtoList[ALARM_DELAY] = new AlarmDelayPollParam(ALARM_DELAY, ALARMDELAY, (int)(40*DELAY_FACTOR), NO_POLL,DECREMENTSET);
   ProtoList[SHUTDOWN_DELAY] = new ShutdownDelayPollParam(SHUTDOWN_DELAY, SHUTDOWNDELAY, (int)(60*DELAY_FACTOR), NO_POLL,DECREMENTSET);
   ProtoList[TURN_ON_DELAY] = new TurnBackOnDelayPollParam(TURN_ON_DELAY, SYNCTURNBACKDELAY, (int)(60*DELAY_FACTOR), NO_POLL,DECREMENTSET);
   ProtoList[SET_DATA] = new SimplePollParam(SET_DATA, "", (int)(250*DELAY_FACTOR), NO_POLL);
   ProtoList[NO_MSG] = new SimplePollParam(NO_MSG, "", (int)(250*DELAY_FACTOR), NO_POLL);
   ProtoList[LINE_CONDITION_TEST] = new LineConditionPollParam(LINE_CONDITION_TEST, LINECONDITIONTEST, (int)(60*DELAY_FACTOR), POLL);
   ProtoList[UTILITY_LINE_CONDITION] = new UtilLineCondPollParam(UTILITY_LINE_CONDITION, UPSSTATE, (int)(50*DELAY_FACTOR), POLL);
   ProtoList[BATTERY_CONDITION] = new BatteryCondPollParam(BATTERY_CONDITION, UPSSTATE, (int)(50*DELAY_FACTOR), POLL);
   ProtoList[BATTERY_REPLACEMENT_CONDITION] = new ReplaceBattCondPollParam(BATTERY_REPLACEMENT_CONDITION, UPSSTATE, (int)(50*DELAY_FACTOR), POLL);
   ProtoList[OVERLOAD_CONDITION] = new OverLoadCondPollParam(OVERLOAD_CONDITION, UPSSTATE, (int)(50*DELAY_FACTOR), POLL);
   ProtoList[SMART_BOOST_STATE] = new SmartBoostCondPollParam(SMART_BOOST_STATE, UPSSTATE, (int)(50*DELAY_FACTOR), POLL);
   ProtoList[SMART_TRIM_STATE] = new SmartTrimCondPollParam(SMART_TRIM_STATE, UPSSTATE, (int)(50*DELAY_FACTOR), POLL);
#if (C_OS & C_OS2)
   ProtoList[BATTERY_CALIBRATION_CONDITION] = new BattCalibrateCondPollParam(BATTERY_CALIBRATION_CONDITION, UPSSTATE, (int)(50*DELAY_FACTOR),
      POLL);
#else
   ProtoList[BATTERY_CALIBRATION_CONDITION] = new BattCalibrationCondPollParam(BATTERY_CALIBRATION_CONDITION, UPSSTATE, (int)(50*DELAY_FACTOR),
      POLL);
#endif
   ProtoList[AMBIENT_TEMPERATURE] = new MUpsTempPollParam(AMBIENT_TEMPERATURE, MUPSAMBIENTTEMP, (int)(80*DELAY_FACTOR), POLL);
   ProtoList[HUMIDITY] = new MUpsHumidityPollParam(HUMIDITY, MUPSHUMIDITY, (int)(80*DELAY_FACTOR), POLL);
   ProtoList[MUPS_FIRMWARE_REV] = new MUpsFirmwareRevPollParam(MUPS_FIRMWARE_REV, MUPSFIRMWAREREV, (int)(60*DELAY_FACTOR), NO_POLL);
   ProtoList[CONTACT_POSITION] = new MUpsContactPosPollParam(CONTACT_POSITION, MUPSCONTACTPOSITION, (int)(50*DELAY_FACTOR), POLL);
   ProtoList[UPS_FRONT_PANEL_PASSWORD] = new FrontPanelPasswordPollParam(UPS_FRONT_PANEL_PASSWORD, EEPROMPASSWORD, (int)(125*DELAY_FACTOR), POLL);
   ProtoList[UPS_RUN_TIME_AFTER_LOW_BATTERY] = new RunTimeAfterLowBatteryPollParam(UPS_RUN_TIME_AFTER_LOW_BATTERY, EARLYTURNOFF, (int)(50*DELAY_FACTOR), POLL);
#ifndef CIBC
   ProtoList[TRIP_REGISTER] = new TripRegisterPollParam(TRIP_REGISTER, TRIPREGISTERS, (int)(50*DELAY_FACTOR), POLL);
   ProtoList[TRIP1_REGISTER] = new Trip1RegisterPollParam(TRIP1_REGISTER, TRIPREGISTER1, (int)(50*DELAY_FACTOR), POLL);
#if (C_OS & C_OS2)
   ProtoList[UPS_ALLOWED_VALUES] = new EepromAllowedValsPollParam(UPS_ALLOWED_VALUES, EEPROMVALUES, (int)(2000*DELAY_FACTOR), NO_POLL);
#else
   ProtoList[UPS_ALLOWED_VALUES] = new EepromAllowedValuesPollParam(UPS_ALLOWED_VALUES, EEPROMVALUES, (int)(2000*DELAY_FACTOR), NO_POLL);
#endif
   ProtoList[UPS_MODEL_NAME] = new UpsModelPollParam(UPS_MODEL_NAME, UPSMODELNAME, (int)(2000*DELAY_FACTOR), NO_POLL);
#endif
   
   const INT TBD = 200;  // This must be finalized by hardware group
   // Dark Star additions
   ProtoList[TOTAL_INVERTERS] = new NumberInstalledInvertersPollParam(TOTAL_INVERTERS, MODULECOUNTSSTATUS, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[NUMBER_BAD_INVERTERS] = new NumberBadInvertersPollParam(NUMBER_BAD_INVERTERS, MODULECOUNTSSTATUS, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[CURRENT_REDUNDANCY] = new RedundancyLevelPollParam(CURRENT_REDUNDANCY,MODULECOUNTSSTATUS , (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[MINIMUM_REDUNDANCY] = new MinimumRedundancyPollParam(MINIMUM_REDUNDANCY, MODULECOUNTSSTATUS, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[CURRENT_LOAD_CAPABILITY] = new CurrentLoadCapabilityPollParam(CURRENT_LOAD_CAPABILITY, MODULECOUNTSSTATUS, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[MAXIMUM_LOAD_CAPABILITY] = new MaximumLoadCapabilityPollParam(MAXIMUM_LOAD_CAPABILITY, MODULECOUNTSSTATUS, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[INPUT_VOLTAGE_PHASE_A] = new PhaseAInputVoltagePollParam(INPUT_VOLTAGE_PHASE_A,INPUTVOLTAGEFREQ , (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[INPUT_VOLTAGE_PHASE_B] = new PhaseBInputVoltagePollParam(INPUT_VOLTAGE_PHASE_B,INPUTVOLTAGEFREQ , (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[INPUT_VOLTAGE_PHASE_C] = new PhaseCInputVoltagePollParam(INPUT_VOLTAGE_PHASE_C, INPUTVOLTAGEFREQ, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[INPUT_FREQUENCY] = new InputFrequencyPollParam(INPUT_FREQUENCY, INPUTVOLTAGEFREQ, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[OUTPUT_VOLTAGE_PHASE_A] = new PhaseAOutputVoltagePollParam(OUTPUT_VOLTAGE_PHASE_A,OUTPUTVOLTAGECURRENT , (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[OUTPUT_VOLTAGE_PHASE_B] = new PhaseBOutputVoltagePollParam(OUTPUT_VOLTAGE_PHASE_B,OUTPUTVOLTAGECURRENT , (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[OUTPUT_VOLTAGE_PHASE_C] = new PhaseCOutputVoltagePollParam(OUTPUT_VOLTAGE_PHASE_C, OUTPUTVOLTAGECURRENT, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[MODULE_COUNTS_AND_STATUS] = new ModuleCountsStatusPollParam(MODULE_COUNTS_AND_STATUS, MODULECOUNTSSTATUS, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[ABNORMAL_CONDITION_REGISTER] = new AbnormalCondPollParam(ABNORMAL_CONDITION_REGISTER, ABNORMALCONDITION, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[INPUT_VOLTAGE_FREQUENCY] = new InputVoltageFrequencyPollParam(INPUT_VOLTAGE_FREQUENCY, INPUTVOLTAGEFREQ, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[OUTPUT_VOLTAGE_CURRENTS] = new OutputVoltageCurrentsPollParam(OUTPUT_VOLTAGE_CURRENTS,OUTPUTVOLTAGECURRENT , (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[IM_STATUS] = new IMStatusPollParam(IM_STATUS, ABNORMALCONDITION, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[IM_INSTALLATION_STATE] = new IMInstallationStatusPollParam(IM_INSTALLATION_STATE, ABNORMALCONDITION, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[RIM_INSTALLATION_STATE] = new RIMInstallationStatusPollParam(RIM_INSTALLATION_STATE, MODULECOUNTSSTATUS, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[RIM_STATUS] = new RIMStatusPollParam(RIM_STATUS, ABNORMALCONDITION, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[REDUNDANCY_STATE] = new RedundancyConditionPollParam(REDUNDANCY_STATE, ABNORMALCONDITION, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[BYPASS_CONTACTOR_STATE] = new BypassContactorStatusPollParam(BYPASS_CONTACTOR_STATE, ABNORMALCONDITION, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[INPUT_BREAKER_STATE] = new InputBreakerTrippedStatusPollParam(INPUT_BREAKER_STATE, ABNORMALCONDITION, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[NUMBER_OF_INPUT_PHASES] = new NumberOfInputPhasesPollParam(NUMBER_OF_INPUT_PHASES, INPUTVOLTAGEFREQ, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[NUMBER_OF_OUTPUT_PHASES] = new NumberOfOutputPhasesPollParam(NUMBER_OF_OUTPUT_PHASES, INPUTVOLTAGEFREQ, (int)(TBD*DELAY_FACTOR), POLL);
   ProtoList[SYSTEM_FAN_STATE] = new SystemFanStatusPollParam(SYSTEM_FAN_STATE, ABNORMALCONDITION, (int)(TBD*DELAY_FACTOR), POLL);

}