--
-- MIB module for
--
-- RMS - Rack Monitoring System
-- 
-- Knuerr plus GmbH RMS Version 1.54 (2001/03/20)
--
--

RMS-MIB DEFINITIONS ::= BEGIN

IMPORTS
        enterprises, OBJECT-TYPE, IpAddress, Counter, Gauge, TimeTicks
              FROM RFC1155-SMI;

--      DisplayString
--              FROM RFC1158-MIB

--        TRAP-TYPE
--                FROM RFC1215-MIB;

Knuerr OBJECT IDENTIFIER ::= { enterprises 2769 }

rms     OBJECT IDENTIFIER ::= { Knuerr 10 }

rmssystem  OBJECT IDENTIFIER ::= { rms 1 }
input      OBJECT IDENTIFIER ::= { rms 2 }
output     OBJECT IDENTIFIER ::= { rms 3 }
temp       OBJECT IDENTIFIER ::= { rms 4 }
humid      OBJECT IDENTIFIER ::= { rms 5 }
mains      OBJECT IDENTIFIER ::= { rms 6 }
filter     OBJECT IDENTIFIER ::= { rms 7 }
message    OBJECT IDENTIFIER ::= { rms 8 }
user       OBJECT IDENTIFIER ::= { rms 9 }
aux        OBJECT IDENTIFIER ::= { rms 20 }
icc        OBJECT IDENTIFIER ::= { rms 21 }
ups        OBJECT IDENTIFIER ::= { rms 22 }

-- system tree

-- The system tree contains general information, such as system version

systemVersion OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"The systemVersion shows the current installed software
		version."
        ::= { rmssystem 1 }

systemSNMPsave OBJECT-TYPE
	SYNTAX INTEGER  {
                         default(1),
                         save(2)
			}
	ACCESS read-write
	STATUS mandatory
	DESCRIPTION
		"systemSNMPsave is used to write all changes 
                made via SNMP into the flash disk. If set to 2 the
		save operation is triggered. After successfull write
                it is reset to 1 (default value)."
        ::= { rmssystem 2 }

systemMsgToSyslog OBJECT-TYPE
	SYNTAX INTEGER  {
                         msglog-off(1),
                         msglog-on(2)
			}
	ACCESS read-write
	STATUS mandatory
	DESCRIPTION
                "If systemMsgToSyslog is set to 2, all messages are
                 additionally logged to all syslog destinations."
        ::= { rmssystem 3 }

systemReset OBJECT-TYPE
	SYNTAX INTEGER {
                        default(1),
                        reset(2)
		       }
	ACCESS read-write
	STATUS mandatory
	DESCRIPTION
                "Writing 2 into systemReset forces the RMS to reboot.
                Reading allways gives back 1 (default value)."
        ::= { rmssystem 4 }

systemSNMPaccess OBJECT-TYPE
	SYNTAX INTEGER {
                        readonly(1),
                        readwrite(2)
		       }
	ACCESS read-only
	STATUS mandatory
	DESCRIPTION
		"systemSNMPaccess displays the current access right
                for SNMP access. If 1, variables only can be read,
                if 2, full SNMP access with SET operaions is allowed.
		This variable corresponds with the option SNMP Access 
		in the SNMP Configuration Menu and can only be mani-
		pulated via telnet or terminal."
        ::= { rmssystem 5 }

-- digitalInTable

-- The digitalInTable contains information about "Digital Inputs 1-8"

digitalInTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF DigitalInEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"The digitalInTable contains all information about 
		physical inputs Digital In 1-8."
	::= { input 1 }

digitalInEntry OBJECT-TYPE
	SYNTAX  DigitalInEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains information for each input"
	INDEX   { digitalInIndex }
	::= { digitalInTable 1 }

DigitalInEntry ::=
	SEQUENCE {
		digitalInIndex
			INTEGER,
		digitalInDescr
			DisplayString,
		digitalInState
			INTEGER,
		digitalInLastChange
			TimeTicks,
		digitalInChanges
			Counter
	}

digitalInIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of Digital Input"
	::= { digitalInEntry 1 }

digitalInDescr OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Descriptive name of Digital Input"
	::= { digitalInEntry 2 }

digitalInState OBJECT-TYPE
	SYNTAX  INTEGER {
                         off(1),
                         on(2)
			}
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Current state of Digital Input"
	::= { digitalInEntry 3 }

digitalInLastChange OBJECT-TYPE
	SYNTAX  TimeTicks
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Timestamp of last change"
	::= { digitalInEntry 4 }

digitalInChanges OBJECT-TYPE
	SYNTAX  Counter
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"How many times the input changed since system startup"
	::= { digitalInEntry 5 }

-- alertInTable

-- The alertInTable contains information about the "Alert In 1-4" inputs,
-- which are used to connect to differential signalling lines.

alertInTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF AlertInEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"The alertInTable contains all information about 
		physical inputs Alert In 1-4."
	::= { input 2 }

alertInEntry OBJECT-TYPE
	SYNTAX  AlertInEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains the values for an alert input"
	INDEX   { alertInIndex }
	::= { alertInTable 1 }

AlertInEntry ::=
	SEQUENCE {
		alertInIndex
			INTEGER,
		alertInDescr
			DisplayString,
		alertInState
			INTEGER,
		alertInLastChange
			TimeTicks,
		alertInChanges
			Counter,
                alertInReset
             		INTEGER
	}

alertInIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of Alert Input"
	::= { alertInEntry 1 }

alertInDescr OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Descriptive name of Alert Input"
	::= { alertInEntry 2 }

alertInState OBJECT-TYPE
	SYNTAX  INTEGER {
                         off(1),
                         on(2)
			}
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Current state of Alert Input"
	::= { alertInEntry 3 }

alertInLastChange OBJECT-TYPE
	SYNTAX  TimeTicks
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Timestamp of last change"
	::= { alertInEntry 4 }

alertInChanges OBJECT-TYPE
	SYNTAX  Counter
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"How many times the input changed since system startup"
	::= { alertInEntry 5 }

alertInReset OBJECT-TYPE
	SYNTAX  INTEGER {
                         default(1),
                         alertIn-reset(2)
			}
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
                "Reset an Alert In by writing 2 in here. 
                 Most sensors use to store an alarm, which only can be 
                 deleted by resetting the sensor respectively the whole 
                 signalling line. This is achieved by powering-off this 
                 signalling line for a short time."
	::= { alertInEntry 6 }

-- upsInTable

-- The upsInTable contains information concerning UPS In 1 and UPS In 2

upsInTable OBJECT-TYPE
        SYNTAX  SEQUENCE OF UPSInEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"The upsInputTable contains all information about 
                 physical inputs UPS In 1-2."
	::= { input 3 }

upsInEntry OBJECT-TYPE
	SYNTAX  UPSInEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains the values for an UPS input"
	INDEX   { upsInIndex }
	::= { upsInTable 1 }

UPSInEntry ::=
	SEQUENCE {
		upsInIndex
			INTEGER,
		upsInDescr
			DisplayString,
		upsInState
			INTEGER,
		upsInLastChange
			TimeTicks,
		upsInChanges
			Counter
	}

upsInIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of UPS Input"
	::= { upsInEntry 1 }

upsInDescr OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Name of UPS Input"
	::= { upsInEntry 2 }

upsInState OBJECT-TYPE
	SYNTAX  INTEGER {
                         off(1),
                         on(2)
			}
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Current state of UPS Input"
	::= { upsInEntry 3 }

upsInLastChange OBJECT-TYPE
	SYNTAX  TimeTicks
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Timestamp of last change"
	::= { upsInEntry 4 }

upsInChanges OBJECT-TYPE
	SYNTAX  Counter
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"How many times the input changed since system startup"
	::= { upsInEntry 5 }


-- output tree

-- The output tree contains information about "Digital Out 1-4"

outputTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF OutputEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"The table used for describing the digital outputs"
	::= { output 1 }

outputEntry OBJECT-TYPE
	SYNTAX  OutputEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains the description of an digital output"
	INDEX   { outputIndex }
	::= { outputTable 1 }

OutputEntry ::=
	SEQUENCE {
		outputIndex
			INTEGER,
		outputDescr
			DisplayString,
                outputEffect
			INTEGER,
		outputLastChange
			TimeTicks,
		outputChanges
			Counter,
                outputLogic
                        INTEGER,
                outputState
                        INTEGER
	}

outputIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of digital output"
	::= { outputEntry 1 }

outputDescr OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Descriptive Name of one digital output"
	::= { outputEntry 2 }

outputEffect OBJECT-TYPE
	SYNTAX  INTEGER {
                         off(1),
                         on(2),
                         thru(3),
                         invert(4)
			}
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the way the physical digital output is 
                influenced by one or more filter results.
		For this the result of the logical output block can be
                passed thru (thru) or inverted (invert).
                Furthermore it is possible to force each output to be 
                switched on or off permanently, which means that the output
                won't be influenced by any filter result. This can be usefull
                for diagnose purposes."
	::= { outputEntry 3 }

outputLastChange OBJECT-TYPE
	SYNTAX  TimeTicks
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Timestamp of last change"
	::= { outputEntry 4 }

outputChanges OBJECT-TYPE
	SYNTAX  Counter
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"How many times an output changed since system startup"
	::= { outputEntry 5 }

outputLogic OBJECT-TYPE
	SYNTAX INTEGER  {
                         and(1),
                         or(2)
			}
	ACCESS read-write
	STATUS mandatory
	DESCRIPTION
		"Each output can be controlled by a couple of filters, which
		are combined in a boolean operation. The logic operation
		(and/or) can be set up with this entry."
	::= { outputEntry 6 }

  outputState OBJECT-TYPE
          SYNTAX  INTEGER { 
                           open(1), 
                           short(2) 
                          }
          ACCESS  read-only
          STATUS  mandatory
          DESCRIPTION
                  "Current state of digital output"
          ::= { outputEntry 7 }


-- ouputLogicTable

-- The outputLogicTable contains information about the filters which will be
-- combined to effect each single digital output

outputLogicTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF OutputLogicEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"The table used for describing the list of filters,
                 which effect an output."
	::= { output 2 }

outputLogicEntry OBJECT-TYPE
	SYNTAX  OutputLogicEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains the description of one logic and/or
                 element"
	INDEX   { outputLogicOutputIndex,
                  outputLogicFilterIndex }
	::= { outputLogicTable 1 }

OutputLogicEntry ::=
	SEQUENCE {
		outputLogicOutputIndex
			INTEGER,
                outputLogicFilterIndex
                        INTEGER,
                outputLogicFilter
                        INTEGER
	}

outputLogicOutputIndex OBJECT-TYPE
	SYNTAX INTEGER
	ACCESS read-only
	STATUS mandatory
	DESCRIPTION
		"Index of the output"
	::= { outputLogicEntry 1 }

outputLogicFilterIndex OBJECT-TYPE
	SYNTAX INTEGER
	ACCESS read-only
	STATUS mandatory
	DESCRIPTION
		"Index of the filter"
	::= { outputLogicEntry 2 }

outputLogicFilter OBJECT-TYPE
        SYNTAX  INTEGER { 
                         off(1),
                         on (2)
                        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines, if this filter works on the logical and/or
                 element. Default is off."
	::= { outputLogicEntry 3 }


-- tempTable

-- The tempTable contains information about "Temperature 1-4" inputs

tempTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF TempEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Table to hold the information about temperature inputs"
	::= { temp 1 }

tempEntry OBJECT-TYPE
	SYNTAX  TempEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains information about one temperature
		input"
	INDEX   { tempIndex }
	::= { tempTable 1 }

TempEntry ::=
	SEQUENCE {
		tempIndex
			INTEGER,
		tempDescr
			DisplayString,
		tempValue
			INTEGER
	}

tempIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of temperature input"
	::= { tempEntry 1 }

tempDescr OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Descriptive name of temperature input"
	::= { tempEntry 2 }

tempValue OBJECT-TYPE
        SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
                "Current temperature in degree celsius.
                If 655 no sensor is connected."
	::= { tempEntry 3 }

-- humidTable

-- The humidTable contains information about the "Humidity 1-4" inputs

humidTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF HumidEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Table to hold the information about humidity inputs"
	::= { humid 1 }

humidEntry OBJECT-TYPE
	SYNTAX  HumidEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains information about one humidity
		input"
	INDEX   { humidIndex }
	::= { humidTable 1 }

HumidEntry ::=
	SEQUENCE {
		humidIndex
			INTEGER,
		humidDescr
			DisplayString,
		humidValue
			INTEGER
	}

humidIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of humidity input"
	::= { humidEntry 1 }

humidDescr OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Descriptive name of the humidity input"
	::= { humidEntry 2 }

humidValue OBJECT-TYPE
        SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
                "Current humidity in percent rel. humidity.
                 If 255 no sensor is connected."
	::= { humidEntry 3 }

-- mainsTable

-- The mainsTable contains information about "Mains Monitoring 1-3" inputs

mainsTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF MainsEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Table to hold the information about the mains inputs"
	::= { mains 1 }

mainsEntry OBJECT-TYPE
        SYNTAX  MainsEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains information about one mains input"
	INDEX   { mainsIndex }
	::= { mainsTable 1 }

MainsEntry ::=
	SEQUENCE {
		mainsIndex
			INTEGER,
		mainsDescr
			DisplayString,
		mainsValue
			INTEGER
	}

mainsIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of mains input"
	::= { mainsEntry 1 }

mainsDescr OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Descriptive name of the mains input"
	::= { mainsEntry 2 }

mainsValue OBJECT-TYPE
        SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
                "Current voltage of mains input in volt.
                If 13 or 255 no voltage is detected."
	::= { mainsEntry 3 }

-- filterTable

-- The filterTable contains information about the defined filter
-- configurations

filterTable OBJECT-TYPE
        SYNTAX  SEQUENCE OF FilterEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Table containing all information about the defined filters"
	::= { filter 1 }

filterEntry OBJECT-TYPE
	SYNTAX  FilterEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains the description of one filter"
	INDEX   { filterIndex }
	::= { filterTable 1 }

FilterEntry ::=
	SEQUENCE {
		filterIndex
			INTEGER,
		filterDescr
			DisplayString,
		filterResult
			INTEGER,
		filterEffect
			INTEGER,
		filterTrap
			INTEGER,
		filterLED
			INTEGER,
		filterBuzzer
			INTEGER,
		filterMessagePriority
			INTEGER,
		filterConfirmation
			INTEGER,
		filterReactivationTime
			INTEGER,
		filterConfirm
			INTEGER
	}

filterIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the filter entry"
	::= { filterEntry 1 }

filterDescr OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Descriptive name of filter"
	::= { filterEntry 2 }

filterResult OBJECT-TYPE
        SYNTAX  INTEGER { 
                         false(1), 
                         true(2) 
                        }
	ACCESS  read-only
	STATUS  mandatory 
	DESCRIPTION
		"Current filter result, i.e. result of all 'or'ed inputs
		 - see block diagram"
	::= { filterEntry 3 }

filterEffect OBJECT-TYPE
        SYNTAX  INTEGER { 
                         off(1), 
                         thru(2), 
                         invert(3) 
                        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the way the filter is used for further operation
		Can be switched off, passed thru or inverted."
	::= { filterEntry 4 }

filterTrap OBJECT-TYPE
        SYNTAX  INTEGER { 
                         no(1), 
                         once(2),
                         repeat(3) 
                        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the way of trap notification to management
		 station(s) in case of filter events. Traps can be off,
		 sent once (when filter becomes true) or sent repeatedly
		 (as long as filter is true)."
	::= { filterEntry 5 }

filterLED OBJECT-TYPE
        SYNTAX  INTEGER { 
                         no(1), 
                         yes(2) 
                        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"When set to yes(2) a filter event will be signalled 
                 by the warning LED on front of RMS"
	::= { filterEntry 6 }

filterBuzzer OBJECT-TYPE
        SYNTAX  INTEGER { 
                         no(1), 
                         yes(2) 
                        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"When set to yes(2) a filter event will be signalled 
                 by the build-in buzzer"
	::= { filterEntry 7 }

filterMessagePriority OBJECT-TYPE
	SYNTAX  INTEGER {
                         no-message(1),
                         priority-warning(2),
                         priority-critical(3)
		        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"If set to priority-warning(2) or priority-critical(3), 
                 a filter event will be logged in the message log an on 
                 all defined log server(s) with the corresponding priority.
                 This priority has only informational character.
                 If set to no-message(1) logging is switched off."
	::= { filterEntry 8 }

filterConfirmation OBJECT-TYPE
        SYNTAX  INTEGER { 
                         disabled(1), 
                         enabled(2) 
                        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"If set to enabled(1), it is possible to confirme a true
                 filter. This can be done on front panel of RMS, via telnet
                 or via SNMP (see also variable filterConfirm)."
	::= { filterEntry 9 }

filterReactivationTime OBJECT-TYPE
        SYNTAX  INTEGER
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Time after which a confirmed filter will be reactivated
		automatically"
	::= { filterEntry 10 }

filterConfirm OBJECT-TYPE
        SYNTAX  INTEGER { 
                         not-confirmed(1), 
                         confirmed(2) 
                        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"A true filter can be confimed by writing confirmed(2)
                 in here (provided filter confirmation is enabled - 
                 see variable filterConfirmation). By doing this the effect 
                 of this filter will be suspended until the time specified
                 by filterReactivationTime is elapsed."
	::= { filterEntry 11 }

--
-- filterDigitalInTable
--
filterDigitalInTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF FilterDigitalInEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Table containing all information about the filter inputs 
                 Digital 1-8 of each filter"
	::= { filter 2 }

filterDigitalInEntry OBJECT-TYPE
	SYNTAX  FilterDigitalInEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains the description of one digital input"
	INDEX   { filterDigitalInIndex,
		  filterDigitalInPort }
	::= { filterDigitalInTable 1 }

FilterDigitalInEntry ::=
	SEQUENCE {
		filterDigitalInIndex
			INTEGER,
		filterDigitalInPort
			INTEGER,
		filterDigitalInEffect
			INTEGER
	}

filterDigitalInIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the filter"
	::= { filterDigitalInEntry 1 }

filterDigitalInPort OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the digital input"
	::= { filterDigitalInEntry 2 }

filterDigitalInEffect OBJECT-TYPE
        SYNTAX  INTEGER { 
                         off(1), 
                         thru(2), 
                         invert(3) 
                        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the way the digital input effects the filter. 
                 Can be switched off(1), inverted(3) or passed thru(2)."
	::= { filterDigitalInEntry 3 }

--
-- filterAlertInTable
-- 
filterAlertInTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF FilterAlertInEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Table containing all information about the filter inputs 
                 Alert In 1-4 of each filter"
	::= { filter 3 }

filterAlertInEntry OBJECT-TYPE
	SYNTAX  FilterAlertInEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains information of one alert input"
	INDEX   { filterAlertInIndex,
		  filterAlertInPort }
	::= { filterAlertInTable 1 }

FilterAlertInEntry ::=
	SEQUENCE {
		filterAlertInIndex
			INTEGER,
		filterAlertInPort
			INTEGER,
		filterAlertInEffect
			INTEGER
	}

filterAlertInIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the filter"
	::= { filterAlertInEntry 1 }

filterAlertInPort OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the alert input"
	::= { filterAlertInEntry 2 }

filterAlertInEffect OBJECT-TYPE
        SYNTAX  INTEGER { 
                         off(1), 
                         thru(2), 
                         invert(3) 
                        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the way the alert input effects the filter. 
                 Can be switched off(1), inverted(3) or passed thru(2)."
	::= { filterAlertInEntry 3 }

--
-- filterUPSInTable
--
filterUPSInTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF FilterUPSInEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Table containing all information about the filter inputs 
                 UPS In 1-2 of each filter"
	::= { filter 4 }

filterUPSInEntry OBJECT-TYPE
	SYNTAX  FilterUPSInEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains the description of one ups input"
	INDEX   { filterUPSInIndex,
                  filterUPSInPort }
	::= { filterUPSInTable 1 }

FilterUPSInEntry ::=
	SEQUENCE {
		filterUPSInIndex
			INTEGER,
		filterUPSInPort
			INTEGER,
		filterUPSInEffect
			INTEGER
	}

filterUPSInIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the filter"
	::= { filterUPSInEntry 1 }

filterUPSInPort OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the UPS input"
	::= { filterUPSInEntry 2 }

filterUPSInEffect OBJECT-TYPE
        SYNTAX  INTEGER { 
                         off(1), 
                         thru(2), 
                         invert(3) 
                        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the way the UPS input effects the filter. 
                 Can be switched off(1), inverted(3) or passed thru(2)."
	::= { filterUPSInEntry 3 }

--
-- filterTempTable
--
filterTempTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF FilterTempEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Table containing information about temperature inputs of
		each filter, i.e. thresholds and compare operations"
	::= { filter 5 }

filterTempEntry OBJECT-TYPE
	SYNTAX  FilterTempEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains the description of one filter temp input"
	INDEX   { filterTempIndex,
		  filterTempSensor }
	::= { filterTempTable 1 }

FilterTempEntry ::=
	SEQUENCE {
		filterTempIndex
			INTEGER,
		filterTempSensor
			INTEGER,
		filterTempEffect
			INTEGER,
		filterTempAThres
			INTEGER,
		filterTempAMode
			INTEGER,
		filterTempBThres
			INTEGER,
		filterTempBMode
			INTEGER
	}

filterTempIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the filter"
	::= { filterTempEntry 1 }


filterTempSensor OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the temp input"
	::= { filterTempEntry 2 }

filterTempEffect OBJECT-TYPE
        SYNTAX  INTEGER { 
                         off(1), 
                         thru(2), 
                         invert(3) 
                        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the way the result of temp input comparison
		effects on the filter. Can be switched off(1), inverted (3)
                or passed thru(3)."
	::= { filterTempEntry 3 }

filterTempAThres OBJECT-TYPE
	SYNTAX  INTEGER
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Threshold of temp input part A"
	::= { filterTempEntry 4 }

filterTempAMode OBJECT-TYPE
        SYNTAX  INTEGER {  
                         off(1), 
                         greater(2), 
                         less(3) 
                        }
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the operating mode of comparison operation A.
		 Can be set to greater(2) ' >', less(3) '<' or turned off(1),
                 if not needed"
	::= { filterTempEntry 5 }

filterTempBThres OBJECT-TYPE
	SYNTAX  INTEGER
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Threshold of temp input part B"
	::= { filterTempEntry 6 }

filterTempBMode OBJECT-TYPE
        SYNTAX  INTEGER {
                         off(1), 
                         greater(2), 
                         less(3) 
                        }
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the operating mode of comparison operation B.
		 Can be set to greater(2) ' >', less(3) '<' or turned off(1),
                 if not needed"
	::= { filterTempEntry 7 }

--
-- filterHumidityTable
--
filterHumidityTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF FilterHumidityEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Table containing information about humidity inputs of
		each filter, i.e. thresholds and compare operations"
	::= { filter 6 }

filterHumidityEntry OBJECT-TYPE
	SYNTAX  FilterHumidityEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains the description of one filter"
	INDEX   { filterHumidityIndex,
		  filterHumiditySensor }
	::= { filterHumidityTable 1 }

FilterHumidityEntry ::=
	SEQUENCE {
		filterHumidityIndex
			INTEGER,
		filterHumiditySensor
			INTEGER,
		filterHumidityEffect
			INTEGER,
		filterHumidityAThres
			INTEGER,
		filterHumidityAMode
			INTEGER,
		filterHumidityBThres
			INTEGER,
		filterHumidityBMode
			INTEGER
	}

filterHumidityIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the filter"
	::= { filterHumidityEntry 1 }


filterHumiditySensor OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the humidity input"
	::= { filterHumidityEntry 2 }

filterHumidityEffect OBJECT-TYPE
        SYNTAX  INTEGER { 
                         off(1), 
                         thru(2), 
                         invert(3) 
                        }
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the way the result of humidity input comparison
		effects the filter. Can be switched off(1), inverted(3) or
		passed thru(2), if not needed."
	::= { filterHumidityEntry 3 }

filterHumidityAThres OBJECT-TYPE
	SYNTAX  INTEGER
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Threshold of humidity input part A"
	::= { filterHumidityEntry 4 }

filterHumidityAMode OBJECT-TYPE
        SYNTAX  INTEGER { 
                         off(1), 
                         greater(2), 
                         less(3) 
                        }
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the operating mode of comparison operation A.
		 Can be set to greater(2) ' >', less(3) '<' or turned off(1),
                 if not needed"
	::= { filterHumidityEntry 5 }

filterHumidityBThres OBJECT-TYPE
	SYNTAX  INTEGER
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Threshold of humidity input part B"
	::= { filterHumidityEntry 6 }

filterHumidityBMode OBJECT-TYPE
        SYNTAX  INTEGER { 
                         off(1), 
                         greater(2), 
                         less(3)     
                        }
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the operating mode of comparison operation B.
		 Can be set to greater(2) ' >', less(3) '<' or turned off(1),
                 if not needed"
	::= { filterHumidityEntry 7 }

filterMainsTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF FilterMainsEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Table containing information about mains inputs of
		each filter, i.e. thresholds and compare operations"
	::= { filter 7 }

filterMainsEntry OBJECT-TYPE
	SYNTAX  FilterMainsEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains the description of one filter"
	INDEX   { filterMainsIndex,
		  filterMainsSensor }
	::= { filterMainsTable 1 }

FilterMainsEntry ::=
	SEQUENCE {
		filterMainsIndex
			INTEGER,
		filterMainsSensor
			INTEGER,
		filterMainsEffect
			INTEGER,
		filterMainsAThres
			INTEGER,
		filterMainsAMode
			INTEGER,
		filterMainsBThres
			INTEGER,
		filterMainsBMode
			INTEGER
	}

filterMainsIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the filter"
	::= { filterMainsEntry 1 }

filterMainsSensor OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the mains sensor"
	::= { filterMainsEntry 2 }

filterMainsEffect OBJECT-TYPE
        SYNTAX  INTEGER { 
                         off(1), 
                         thru(2), 
                         invert(3) 
                        }
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the way the result of mains input comparison
		effects on the filter. Can be switched off(1), inverted(3)
                or passed thru (2)."
	::= { filterMainsEntry 3 }

filterMainsAThres OBJECT-TYPE
	SYNTAX  INTEGER
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Threshold of mains input part B"
	::= { filterMainsEntry 4 }

filterMainsAMode OBJECT-TYPE
        SYNTAX  INTEGER { 
                         off(1), 
                         greater(2), 
                         less(3) 
                        }
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the operating mode of comparison operation A.
		 Can be set to greater(2) ' >', less(3) '<' or turned off(1),
                 if not needed"
	::= { filterMainsEntry 5 }

filterMainsBThres OBJECT-TYPE
	SYNTAX  INTEGER
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Threshold of mains input part B"
	::= { filterMainsEntry 6 }

filterMainsBMode OBJECT-TYPE
        SYNTAX  INTEGER { 
                         off(1), 
                         greater(2), 
                         less(3) 
                        }
        ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the operating mode of comparison operation B.
		 Can be set to greater(2) ' >', less(3) '<' or turned off(1),
                 if not needed"
	::= { filterMainsEntry 7 }

--
-- filterFeedbackTable
--
filterFeedbackTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF FilterFeedbackEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Table containing information about feedback inputs"
	::= { filter 8 }

filterFeedbackEntry OBJECT-TYPE
	SYNTAX  FilterFeedbackEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains the description of one filter"
	INDEX   { filterFeedbackIndex,
		  filterFeedbackInput }
	::= { filterFeedbackTable 1 }

FilterFeedbackEntry ::=
	SEQUENCE {
		filterFeedbackIndex
			INTEGER,
		filterFeedbackInput
			INTEGER,
		filterFeedbackInFilter
			INTEGER,
		filterFeedbackDelay
			INTEGER,
                filterFeedbackPassCondition
			INTEGER,
		filterFeedbackHold
			INTEGER,
		filterFeedbackEffect
			INTEGER
	}

filterFeedbackIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the filter"
	::= { filterFeedbackEntry 1 }


filterFeedbackInput OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of the feedback input"
	::= { filterFeedbackEntry 2 }

filterFeedbackInFilter OBJECT-TYPE
        SYNTAX  INTEGER
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Number of the filter which is connected
		 to this feedback input"
	::= { filterFeedbackEntry 3 }

filterFeedbackDelay OBJECT-TYPE
        SYNTAX  INTEGER
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Delay time to wait until signal is forwarded"
	::= { filterFeedbackEntry 4 }

filterFeedbackPassCondition OBJECT-TYPE
        SYNTAX  INTEGER { 
                         thru(1), 
                         conditional(2)
                        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the way an incoming signal is forwarded to the 
                 filter structure.
                 If set to thru(1), all incoming signals are straight 
                 forwarded. 
                 If set to conditional(2), an incoming signal only will be 
                 forwarded, if after the elapsed time specified in 
                 filterFeedbackDelay the original trigger signal is still
                 pending. Otherwise the signal will be absorbed.
                 See timing diagram in manual for further details."
	::= { filterFeedbackEntry 5 }

filterFeedbackHold OBJECT-TYPE
        SYNTAX  INTEGER
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the time the passed signal will be held up, after
                 the falling edge of the original trigger signal.
                 See timing diagram in manual for further details."
	::= { filterFeedbackEntry 6 }

filterFeedbackEffect OBJECT-TYPE
        SYNTAX  INTEGER { 
                         off(1), 
                         on(2), 
                         invert(3) 
                        }
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Determines the way the result of feedback input effects 
                 the filter. Can be switched off(1), inverted(3) or passed 
                 thru (2)."
	::= { filterFeedbackEntry 7 }

--
-- messageTable
--
messageTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF MessageEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"The message table contains the logged filter events"
	::= { message 1 }

messageEntry OBJECT-TYPE
	SYNTAX  MessageEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains information of one message"
	INDEX   { messageIndex }
	::= { messageTable 1 }

MessageEntry ::=
	SEQUENCE {
		messageIndex
			INTEGER,
		messageFilter
			INTEGER,
		messageFilterDescr
			DisplayString,
		messageTime
			TimeTicks,
		messagePriority
			INTEGER,
		messageAcknoledged
			INTEGER
	}

messageIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of message line"
	::= { messageEntry 1 }

messageFilter OBJECT-TYPE
        SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Number of filter which caused the message"
	::= { messageEntry 2 }

messageFilterDescr OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Name of the filter which caused the message"
	::= { messageEntry 3 }

messageTime OBJECT-TYPE
	SYNTAX  TimeTicks
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Timestamp of event"
	::= { messageEntry 4 }

messagePriority OBJECT-TYPE
        SYNTAX  INTEGER {
                        no-priority(1),
                        warning(2),
                        critical(3)
                        }
        ACCESS  read-only
        STATUS  mandatory
        DESCRIPTION
                "Priority of the message. If set to no-priority(1) no message
                will be logged. The Priority has only informational character
                and doesn't affect the way it is handled"
        ::= { messageEntry 5 }

messageAcknoledged OBJECT-TYPE
	SYNTAX  INTEGER {
                        not-acknowledged(1),
                        acknowledged(2)
			}
	ACCESS  read-write
	STATUS  mandatory
	DESCRIPTION
		"Displays, if event was acknoledged already. Has only
		 informational character for operator"
	::= { messageEntry 6 }


--
-- Information about all registered users
--
userTable OBJECT-TYPE
	SYNTAX  SEQUENCE OF UserEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Some infos about all registered users, e.g.
                 name, right and chipcard key (if reader installed)"
	::= { user 1 }

userEntry OBJECT-TYPE
	SYNTAX  UserEntry
	ACCESS  not-accessible
	STATUS  mandatory
	DESCRIPTION
		"Each entry contains information about one user"
	INDEX   { userIndex }
	::= { userTable 1 }

UserEntry ::=
	SEQUENCE {
		userIndex
			INTEGER,
		userName
			DisplayString,
		userRight
			INTEGER,
		userChipcardKey
			DisplayString,
                userChipcardAccess
                        INTEGER
	}

userIndex OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Index of user. Is dynamically filled from 1..n"
        ::= { userEntry 1 }


userName OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
                 "name of one user"
        ::= { userEntry 2 }

userRight OBJECT-TYPE
	SYNTAX  INTEGER {
                         readonly(1),
                         readwrite(2)
                        }
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
                 "Access right of one user"
        ::= { userEntry 3 }

userChipcardKey OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
                 "Displays the chipcard key of this user - 
                  only available, if optional chipcard reader installed."
        ::= { userEntry 4 }

userChipcardAccess OBJECT-TYPE
	SYNTAX  INTEGER {
                          denied(1),
                          granted(2)
                        }
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
                 "Holds the status of the last access try via 
                  chipcard reader. In case of failure a rmsChipcardTrap
                  will be sent."
        ::= { userEntry 5 }


-- AUX device information
--
auxDevice OBJECT-TYPE
	SYNTAX  INTEGER 
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"AUX device number - currently supported numbers are 
                    1 - <no device>
                    2 - Chipcard Reader
                 The set of supported devices will grow.
                 Check the support server from time to time"

	::= { aux 1 }

auxDeviceName OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Name of the device connected to the AUX port or
                 <no device>."
	::= { aux 2 }


-- Chipcard Reader (optional)
-- 
readerConnected OBJECT-TYPE
	SYNTAX  INTEGER {
                          no(1),
                          yes(2)
                        }
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
                "Shows if chipcard reader is connected to the RMS"
	::= { icc 1 }

readerCardInside OBJECT-TYPE
	SYNTAX  INTEGER {
                          no(1),
                          yes(2)
                        }
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
                "Shows if reader contains a chipcard"
	::= { icc 2 }

readerCardKey OBJECT-TYPE
	SYNTAX  DisplayString
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
                "Shows key of chipcard in Chipcard Reader"
	::= { icc 3 }

readerLEDcolor OBJECT-TYPE
	SYNTAX  INTEGER {
                          red(1),
                          green(2),
                          yellow(3)
                        }
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
                "Shows if reader contains a chipcard"
	::= { icc 4 }


openerLogic OBJECT-TYPE
	SYNTAX  INTEGER {
                          break(1),
                          make(2)
                        }
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Logic of door opener connected to chipcard reader.
                 If make(1) Digital Out 4 will get short in case of
                 successfull access attempt, and open else.
                 If break(2) Digital Out 4 will get open in case of
                 successfull access attempt, and short else."
	::= { icc 5 }

openerOpenTime OBJECT-TYPE
	SYNTAX  INTEGER
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"How long the door opener (e.g. Digital Out 4) will get 
                 open/short in case of successfull access attempt (in secs)."
	::= { icc 6 }

openerState OBJECT-TYPE
	SYNTAX  INTEGER {
                          closed(1),
                          open(2)
                        } 
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
		"Current state of the door opener."
	::= { icc 7 }

-- UPS ( optional )

upsConnected OBJECT-TYPE
	SYNTAX  INTEGER {
						no(1),
						yes(2)
				 }
	ACCESS  read-only
	STATUS  mandatory
	DESCRIPTION
			"Shows if ups is connected to AUX on the RMS"
	::= { ups 1 }  

upsManufacturer OBJECT-TYPE
	SYNTAX     DisplayString (SIZE (0..31))
	MAX-ACCESS read-only
	STATUS     current
	DESCRIPTION
		 "The name of the UPS manufacturer."
	::= { ups 2 }  

upsModel OBJECT-TYPE
	SYNTAX     DisplayString (SIZE (0..63))
	MAX-ACCESS read-only
	STATUS     current
	DESCRIPTION
		 "The UPS Model designation."
	::= { ups 3 }  

upsFirmwareVersion OBJECT-TYPE
	SYNTAX     DisplayString (SIZE (0..63))
	MAX-ACCESS read-only
	STATUS     current
	DESCRIPTION
		 "The UPS firmware/software version(s).  This variable
		 may or may not have the same value as
		 upsIdentAgentSoftwareVersion in some implementations."
	::= { ups 4 }  

upsSoftwareVersion OBJECT-TYPE
	SYNTAX     DisplayString (SIZE (0..63))
	MAX-ACCESS read-only
	STATUS     current
	DESCRIPTION
		 "The UPS agent software version.  This variable may or
		 may not have the same value as
		 upsIdentUPSSoftwareVersion in some implementations."
	::= { ups 5 }  

upsID OBJECT-TYPE
	SYNTAX     DisplayString (SIZE(0..63))
	MAX-ACCESS read-write
	STATUS     current
	DESCRIPTION
		 "The UPS Serial Number"
	::= { ups 6 }

upsBatteryLastReplaced OBJECT-TYPE
	SYNTAX     INTEGER
	MAX-ACCESS not-accessible
	STATUS     current
	DESCRIPTION
			"
			"
	::= { ups 7 }  

upsTimeOnBattery OBJECT-TYPE
	SYNTAX     NonNegativeInteger
	UNITS      "seconds"
	MAX-ACCESS read-only
	STATUS     current
	DESCRIPTION
		 "If the unit is on battery power, the elapsed time
		 since the UPS last switched to battery power, or the
		 time since the network management subsystem was last
		 restarted, whichever is less.  Zero shall be returned
		 if the unit is not on battery power."
	::= { ups 8 }  

upsTimeRemaining OBJECT-TYPE
	SYNTAX     PositiveInteger
	UNITS      "minutes"
	MAX-ACCESS read-only
	STATUS     current
	DESCRIPTION
		 "An estimate of the time to battery charge depletion
		 under the present load conditions if the utility power
		 is off and remains off, or if it were to be lost and
		 remain off."
	::= { ups 9 }  

upsBatteryVoltage OBJECT-TYPE
	SYNTAX     NonNegativeInteger
	UNITS      "0.1 Volt DC"
	MAX-ACCESS read-only
	STATUS     current
	DESCRIPTION
		 "The magnitude of the present battery voltage."
	::= { ups 10 }  

upsBatteryCurrent OBJECT-TYPE
	SYNTAX     Integer32
	UNITS      "0.1 Amp DC"
	MAX-ACCESS read-only
	STATUS     current
	DESCRIPTION
		 "The present battery current."
	::= { ups 11 }  

upsBatteryTemp OBJECT-TYPE
	SYNTAX     Integer32
	UNITS      "degrees Centigrade"
	MAX-ACCESS read-only
	STATUS     current
	DESCRIPTION
		 "The ambient temperature at or near the UPS Battery
		 casing."
	::= { ups 12 }  

upsBatteryStatus OBJECT-TYPE
	SYNTAX INTEGER {
					unknown(1),
					batteryNormal(2),
					batteryLow(3),
					batteryDepleted(4)
				   }
	MAX-ACCESS read-only
	STATUS     current
	DESCRIPTION
		 "The indication of the capacity remaining in the UPS
		 system's batteries.   A value of batteryNormal
		 indicates that the remaining run-time is greater than
		 upsConfigLowBattTime.  A value of batteryLow indicates
		 that the remaining battery run-time is less than or
		 equal to upsConfigLowBattTime.  A value of
		 batteryDepleted indicates that the UPS will be unable
		 to sustain the present load when and if the utility
		 power is lost (including the possibility that the
		 utility power is currently absent and the UPS is
		 unable to sustain the output)."
	::= { ups 13 }  

upsLineFrequency OBJECT-TYPE
	SYNTAX     NonNegativeInteger
	UNITS      "0.1 Hertz"
	MAX-ACCESS read-only
	STATUS     current
	DESCRIPTION
		 "The present input frequency."
	::= { ups 14 }  

upsLineVoltage OBJECT-TYPE
	SYNTAX     NonNegativeInteger
	UNITS      "RMS Volts"
	MAX-ACCESS read-only
	STATUS     current
	DESCRIPTION
		 "The magnitude of the present input voltage."
	::= { ups 15 }  

upsOutputVoltage OBJECT-TYPE
	SYNTAX     NonNegativeInteger
	UNITS      "RMS Volts"
	MAX-ACCESS read-only
	STATUS     current
	DESCRIPTION
		 "The present output voltage."
	::= { ups 16 }  

upsNominalOutputVoltage OBJECT-TYPE
	SYNTAX     NonNegativeInteger
	UNITS      "RMS Volts"
	MAX-ACCESS read-write
	STATUS     current
	DESCRIPTION
		 "The magnitude of the nominal output voltage.  On
		 those systems which support read-write access to this
		 object, if there is an attempt to set this variable to
		 a value that is not supported, the request must be
		 rejected and the agent shall respond with an
		 appropriate error message, i.e., badValue for SNMPv1,
		 or inconsistentValue for SNMPv2."
	::= { ups 17 }  

upsOnline OBJECT-TYPE
	SYNTAX     INTEGER
	MAX-ACCESS not-accessible
	STATUS     current
	DESCRIPTION
			"
			"
	::= { ups 18 }  

upsCalibrating OBJECT-TYPE
	SYNTAX     INTEGER
	MAX-ACCESS not-accessible
	STATUS     current
	DESCRIPTION
			"
			"
	::= { ups 19 }  

upsSleeping OBJECT-TYPE
	SYNTAX     INTEGER
	MAX-ACCESS not-accessible
	STATUS     current
	DESCRIPTION
			"
			"
	::= { ups 20 }  

upsLoad OBJECT-TYPE
	SYNTAX     INTEGER
	MAX-ACCESS not-accessible
	STATUS     current
	DESCRIPTION
			"
			"
	::= { ups 21 }  

-- traps

-- trap notification in case of filter event

rmsFilterTrap TRAP-TYPE
	ENTERPRISE      rms
	VARIABLES       { filterIndex, filterDescr }
	DESCRIPTION
                "A rmsFilterTrap signals that a filter became true.
                The index of the filter and its description are transmitted
                to all registered trap destinations."
	::= 1

-- trap notification in case of access try via chipcard reader (optional)

rmsChipcardTrap TRAP-TYPE
	ENTERPRISE      rms
	VARIABLES       { userName, userChipcardKey, userChipcardAccess }
	DESCRIPTION
		"A rmsChipcardTrap signals any access by use of the 
                 (optional) chipcard reader. In any case all informations 
                 are transmitted."                 
	::= 50

END
