-- MIB file for Ethernet Gateway 4, created 10-Apr-2019 by EDR
-- REVISED 3-Dec-2019 for enterprise use
-- REVISED 9-Jul-2020 Signal Strength in Percent and not dBm
EGW4MIB DEFINITIONS ::= BEGIN

IMPORTS
		enterprises
        FROM RFC1155-SMI
		OBJECT-TYPE
        FROM RFC-1212
		TRAP-TYPE
        FROM RFC-1215
		DisplayString
        FROM RFC1213-MIB
		TEXTUAL-CONVENTION
	 	FROM SNMPv2-TC;

manufacturer			OBJECT IDENTIFIER ::= { enterprises 41542 }

EGW4				OBJECT IDENTIFIER ::= { manufacturer 2 }
-- DESCRIPTION
--    "The EGW4 is a product supporting the delivery of data from wireless
--    sensor devices over an Ethernet connection through the SNMP v1 protocol
--     and others. This gateway is major release version 4."

EGW4GatewaySpecificInfo OBJECT IDENTIFIER ::= { EGW4 1 }
-- DESCRIPTION
--    "The EGW4 reports certain information specific to the particular
--    gateway device, which are reported under this hierarchy."

--
-- Gateway-specific section
--

EGW4GatewayID OBJECT-TYPE
    SYNTAX        Unsigned32
    ACCESS        read-only
    STATUS        mandatory
    DESCRIPTION
				"The serial number identifier of the gateway device assigned and
				programmed by the manufacturer. This will ordinarily be printed
				on a label on the housing of the device."
    ::= {EGW4GatewaySpecificInfo 1}

EGW4GatewayFirmwareVerNo OBJECT-TYPE
    SYNTAX        OCTET STRING
    ACCESS        read-only
    STATUS        mandatory
    DESCRIPTION
        "The version number of the firmware of the gateway device. Note that
        this can change upon a firmware update."
    ::= {EGW4GatewaySpecificInfo 2}

EGW4GatewaySensorDeviceCount OBJECT-TYPE
    SYNTAX        INTEGER(0..256)
    ACCESS        read-only
    STATUS        mandatory
    DESCRIPTION
        "The number of sensors registered to the gateway, i.e. on its netlist.
        Note that this can change as sensors are added or removed."
    ::= {EGW4GatewaySpecificInfo 3}

EGW4GatewayTrapIPAddr OBJECT-TYPE
    SYNTAX        IpAddress
    ACCESS        read-only
    STATUS        mandatory
    DESCRIPTION
        "The configured destination IP address for trap messages from this
        gateway."
    ::= {EGW4GatewaySpecificInfo 4}

EGW4GatewaySensorTrapPort OBJECT-TYPE
    SYNTAX        INTEGER(0..65535)
    ACCESS        read-only
    STATUS        mandatory
    DESCRIPTION
        "The configured IP port for trap messages from this gateway."
    ::= {EGW4GatewaySpecificInfo 5}

--
-- Definitions of sensor-specific informational types
--

EGW4SensorID ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"The serial number identifier of the sensor device assigned and
				programmed by the manufacturer. This will ordinarily be printed
				on a label on the housing of the device."
		SYNTAX				Unsigned32

EGW4SensorRegistrationIndex ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"The index number of a sensor device in a gateway's sensor
				registration list. This is determined by the order in which a set
				of sensors has been registered, but will not change so long as
				the list remains fixed. This is included for legacy applications:
				please consider using the more convenient
				EGW4SensorInfoTranslatedFormat and
				EGW4SensorInfoBySensorID hierarchies."
		SYNTAX				INTEGER(0..255)

EGW4DatumNo ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"The datum number of a sequence of data readings from a sensor. The
				range of this type depends upon the number of datums reported by
				a sensor device. Thus, a 3-axis accelerometer sensor might report
				three datums for the X, Y and Z axes, and the datums would range
				from 1 to 3. For a simple temperature sensor reporting one
				reading, this value would always be 1."
		SYNTAX				INTEGER(1..8)

EGW4SensorDeviceType ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"The textual description of the type of the sensor device."
		SYNTAX				OCTET STRING

EGW4DatumNumber ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"The number of a datum in a set of datums comprising a sensor reading.
				For sensors reporting one datum, this will always be one. Otherwise
				it will be a number between 1 and the number of datums reported by
				the particular type of sensor."
		SYNTAX				INTEGER

EGW4SensorDeviceReadingTranslatedValue ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"The value of a sensor reading, in textual format, translated
				according to sensor and datum types. These formats can include
				integers, fixed-point, and binary values. In several examples:
				a pulse counter might report '12345', a current sensor might report
				'1.43', and a door closed sensor might report 'Yes'."
		SYNTAX				OCTET STRING

EGW4SensorDeviceReadingTranslatedUnits ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"The units or scale of value of a sensor reading, reported in textual
				format. In several examples: a pulse counter might report 'Count',
				a current sensor might report 'A', and a door sensor might report
				'Closed'."
		SYNTAX				OCTET STRING

EGW4SensorDeviceReadingValuesAll ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"All of the datums for the most recent reading of the sensor device,
				separated by commas, in textual format. For example, a report for a
				temperature and humidity sensor might read '20.3, 35' indicating
				20.3 degrees at 35 percent humidity. If only one datum is reported
				by a sensor device, e.g. for a simple temperature sensor, it will be
				reported singly with no commas."
		SYNTAX				OCTET STRING

EGW4SensorDeviceReadingUnitsAll ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"All of the units corresponding to the datums for the most recent
				reading of the sensor device, separated by commas, in textual
				format. For example, for a sensor reporting temperature and
				humidity this might read 'degrees C, %RH'"
		SYNTAX				OCTET STRING

EGW4SensorDeviceReadingUntranslated ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"The untranslated data block received from a sensor, in hexadecimal
				format. This may be used where a translating function isn't yet
				present, and for development purposes. Most users should use the
				translated values delivered in the format of
				EGW4SensorDeviceReadingValuesAll."
		SYNTAX				OCTET STRING

EGW4SensorDeviceReadingU32Value ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"Either a single sensor value of up to 32 bits, or half of a
				64-bit value. Thus where a sensor value is reportable in a
				single Unsigned32, one OID is sufficient to gather that value.
				Where more than 32 bits are needed, the value is reported in two
				successive values of type EGW4SensorDeviceReadingU32Value.
				Where a set of datums is reported, those datums are reported
				beginning with the lowest-numbered OID proceeding sequentially
				through the highest. Thus were a sensor to report a single-bit
				value A followed by 32-bit and a 64 bit ones B and C, and where
				OIDS x.10 through x.17 were used for reporting values, the value A
				would be encoded in x.10, B in x.11 and C in x.12 (low-order bits)
				and x.13 (high-order bits). These values are merely converted
				from sensor-specific internal formats to integers, and not beyond
				to human-readable formats.
				Furthermore, where for a sensor datums extend only part-way through
				the available U32Value OIDs, the ones unused may be filled with 0.
				Where an SNMP walk is performed, the gateway may not traverse these
				unused OIDs."
		SYNTAX				Unsigned32

EGW4SensorDeviceReadingAge ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"The age of the sensor report received most recently from a sensor.
				That time is reported as the number of seconds between the time of
				the sensor report and the time this information is requested."
		SYNTAX				Unsigned32

EGW4SensorDeviceReadingAlarming ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"Either 'Alarming' or 'Not alarming'. A device will report an alarm
				if it is programmed with a threshold found to be exceeded. Examples:
				a temperature sensor for a refrigeration unit can be programmed to
				alarm if the measured temperature rises above a threshold, and
				a door sensor might alarm if a security door is opened."
		SYNTAX				OCTET STRING

--
-- Sensor-specific section, translated format
--

EGW4SensorInfoTranslatedFormatTable OBJECT-TYPE
		SYNTAX				SEQUENCE OF EGW4SensorInfoTranslatedFormatEntry
		ACCESS    		not-accessible
		STATUS        mandatory
		DESCRIPTION
				"The (conceptual) table containing sensor-specific information in an
 				easy-to-use translated string format, indexed by sensor ID is reported
 				under this hierarchy. Sensor data is translated by the gateway from
 				sensor-internal format to human-readable and scriptable values. Use of
 				this format is preferred for most users. The gateway will report the
 				most current information received from sensors, according to their
 				programmed reporting period or heartbeat. When using this section
 				through getRequests or getNextRequests, successive polling is required
 				to keep sensor data current. This table can change as sensors are
 				added or removed. If queried, this OID will return the number of rows
 				in the table, which is the number of sensors registered to this gateway."
		::= { EGW4 2 }

-- Table portion consisting of non-datum-specific info

EGW4SensorInfoTranslatedFormatEntry OBJECT-TYPE
		SYNTAX				EGW4SensorInfoTranslatedFormatEntry
		ACCESS    		not-accessible
		STATUS        mandatory
		DESCRIPTION
				"An entry (conceptual row) in the Translated Format Table containing
				the latest sensor state for a single sensor."
		INDEX   { EGW4SensorInfoTranslatedFormatSensorDeviceID }
		::= { EGW4SensorInfoTranslatedFormatTable 1 }

EGW4SensorInfoTranslatedFormatEntry ::= SEQUENCE {
		EGW4SensorInfoTranslatedFormatSensorDeviceID EGW4SensorID,
		EGW4SensorInfoTranslatedFormatSensorDeviceType EGW4SensorDeviceType,
		EGW4SensorInfoTranslatedFormatSensorDeviceReadingValuesAll EGW4SensorDeviceReadingValuesAll,
		EGW4SensorInfoTranslatedFormatSensorDeviceReadingUnitsAll EGW4SensorDeviceReadingUnitsAll,
		EGW4SensorInfoTranslatedFormatSensorDeviceRptUT EGW4SensorDeviceReadingUntranslated,
		EGW4SensorInfoTranslatedFormatSensorDeviceReadingTime DisplayString,
		EGW4SensorInfoTranslatedFormatSensorDeviceReadingAge EGW4SensorDeviceReadingAge,
		EGW4SensorInfoTranslatedFormatSensorDeviceTypeNo DisplayString,
		EGW4SensorInfoTranslatedFormatSensorDeviceRFStrength DisplayString,
		EGW4SensorInfoTranslatedFormatSensorDeviceActive DisplayString,
		EGW4SensorInfoTranslatedFormatSensorDeviceAlarming EGW4SensorDeviceReadingAlarming,
		EGW4SensorInfoTranslatedFormatSensorDeviceVoltage DisplayString,
		EGW4SensorInfoTranslatedFormatSensorDeviceWDIndexNo DisplayString
}

EGW4SensorInfoTranslatedFormatSensorDeviceID OBJECT-TYPE
    SYNTAX        EGW4SensorID
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"The serial number identifier of the sensor device assigned and
				programmed by the manufacturer. This will ordinarily be printed
				on a label on the housing of the device."
		::= { EGW4SensorInfoTranslatedFormatEntry 1 }

EGW4SensorInfoTranslatedFormatSensorDeviceType OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceType
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"The textual description of the type of the sensor device."
		::= {EGW4SensorInfoTranslatedFormatEntry 2 }

EGW4SensorInfoTranslatedFormatSensorDeviceReadingValuesAll OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceReadingValuesAll
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"All of the datums for the most recent reading of the sensor device,
				separated by commas, in textual format. For example, a report for a
				temperature and humidity sensor might read '20.3, 35' indicating
				20.3 degrees at 35 percent humidity. If only one datum is reported
				by a sensor device, e.g. for a simple temperature sensor, it will be
				reported singly with no commas. The use of this OID is recommended
				for most users, rather than the single value ones, because all values
				can be retrieved atomically from a sensor in one SNMP request."
		::= {EGW4SensorInfoTranslatedFormatEntry 3 }

EGW4SensorInfoTranslatedFormatSensorDeviceReadingUnitsAll OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceReadingUnitsAll
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"All of the units corresponding to the datums for the most recent
				reading of the sensor device, separated by commas, in textual
				format. For example, for a sensor reporting temperature and
				humidity this might read 'degrees C, %RH'"
		::= {EGW4SensorInfoTranslatedFormatEntry 4 }

EGW4SensorInfoTranslatedFormatSensorDeviceRptUT OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceReadingUntranslated
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"The untranslated data block received from a sensor, in hexadecimal
				format. This may be used where a translating function isn't yet
				present, and for development purposes. Most users should use the
				translated values delivered in the format of
				EGW4SensorDeviceReadingValuesAll."
		::= {EGW4SensorInfoTranslatedFormatEntry 5 }

EGW4SensorInfoTranslatedFormatSensorDeviceReadingTime OBJECT-TYPE
    SYNTAX        DisplayString
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"The time of the sensor report received most recently from a sensor.
				That time is reported as the number of seconds elapsed since the epoch
				of the gateway, which is presently Jan. 1, 2010."
		::= {EGW4SensorInfoTranslatedFormatEntry 6 }

EGW4SensorInfoTranslatedFormatSensorDeviceReadingAge OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceReadingAge
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"The age of the sensor report received most recently from a sensor.
				That time is reported as the number of seconds between the time of
				the sensor report and the time this information is requested."
		::= {EGW4SensorInfoTranslatedFormatEntry 7 }

EGW4SensorInfoTranslatedFormatSensorDeviceTypeNo OBJECT-TYPE
    SYNTAX        DisplayString
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"The manufacturer's type number that identifies the kind of sensor."
		::= {EGW4SensorInfoTranslatedFormatEntry 8 }

EGW4SensorInfoTranslatedFormatSensorDeviceRFStrength OBJECT-TYPE
    SYNTAX        DisplayString
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"The signal strength, in percent, of the radio link between the gateway
				and the particular sensor, as measured at the time of the most recent
				sensor report."
		::= {EGW4SensorInfoTranslatedFormatEntry 9 }

EGW4SensorInfoTranslatedFormatSensorDeviceActive OBJECT-TYPE
    SYNTAX        DisplayString
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"Either 'Active' or '' (an empty string). A sensor will be reported
				active if it has recently communicated with the gateway since the last
				reboot. If a sensor device does not show active, it is likely because
				(1) the sensor lacks a power source, (2) the sensor is not in
				proximity to the gateway, or (3) the gateway has recently been
				powered on, and the sensor hasn't yet communicated."
		::= {EGW4SensorInfoTranslatedFormatEntry 10 }

EGW4SensorInfoTranslatedFormatSensorDeviceAlarming OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceReadingAlarming
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"Either 'Alarming' or 'Not alarming'. A device will report an alarm
				if it is programmed with a threshold found to be exceeded. Examples:
				a temperature sensor for a refrigeration unit can be programmed to
				alarm if the measured temperature rises above a threshold, and
				a door sensor might alarm if a security door is opened."
		::= {EGW4SensorInfoTranslatedFormatEntry 11 }

EGW4SensorInfoTranslatedFormatSensorDeviceVoltage OBJECT-TYPE
    SYNTAX        DisplayString
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"The value of the voltage of the supply powering a sensor device.
				Ordinarily this will report the voltage at the battery terminals of
				a sensor. It is provided mainly so batteries can be changed when
				depleted."
		::= {EGW4SensorInfoTranslatedFormatEntry 12 }

EGW4SensorInfoTranslatedFormatSensorDeviceWDIndexNo OBJECT-TYPE
    SYNTAX        DisplayString
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"The index number of the sensor in the gateway's sensor registration
				table. This is the number used in referencing the sensor in the
				EGW4SensorInformationBySensorRegisOrder
				hierarchy."
		::= {EGW4SensorInfoTranslatedFormatEntry 13 }

-- Table portion consisting of datum-specific info (single values and units addressed by device ID and datum)

EGW4SensorInfoTranslatedFormatByDatumNumberEntry OBJECT-TYPE
		SYNTAX				EGW4SensorInfoTranslatedFormatByDatumNumberEntry
		ACCESS    		not-accessible
		STATUS        mandatory
		DESCRIPTION
				"An entry (conceptual row) in the Translated Format Table containing
				the sensor datums, indexed by a sensor ID and datum number."
		INDEX   { EGW4SensorInfoTranslatedFormatSensorDeviceID,
							EGW4SensorInfoTranslatedFormatByDatumNumberDatumNumber }
		::= { EGW4SensorInfoTranslatedFormatTable 2 }

EGW4SensorInfoTranslatedFormatByDatumNumberEntry ::= SEQUENCE {
		EGW4SensorInfoTranslatedFormatByDatumNumberSensorDeviceID EGW4SensorID,
		EGW4SensorInfoTranslatedFormatByDatumNumberDatumNumber EGW4DatumNumber,
		EGW4SensorInfoTranslatedFormatByDatumNumberReadingValue EGW4SensorDeviceReadingTranslatedValue,
		EGW4SensorInfoTranslatedFormatByDatumNumberReadingUnits EGW4SensorDeviceReadingTranslatedUnits
}

EGW4SensorInfoTranslatedFormatByDatumNumberSensorDeviceID OBJECT-TYPE
    SYNTAX        EGW4SensorID
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"The serial number identifier of the sensor device assigned and
				programmed by the manufacturer. This will ordinarily be printed
				on a label on the housing of the device."
		::= { EGW4SensorInfoTranslatedFormatByDatumNumberEntry 1 }

EGW4SensorInfoTranslatedFormatByDatumNumberDatumNumber OBJECT-TYPE
		SYNTAX        EGW4DatumNumber
   	ACCESS    		read-only
   	STATUS        mandatory
   	DESCRIPTION
				"The number of a datum in a set of datums comprising a sensor reading.
				For sensors reporting one datum, this will always be one. Otherwise
				it will be a number between 1 and the number of datums reported by
				the particular type of sensor."
		::= { EGW4SensorInfoTranslatedFormatByDatumNumberEntry 2 }

EGW4SensorInfoTranslatedFormatByDatumNumberReadingValue OBJECT-TYPE
		SYNTAX        EGW4SensorDeviceReadingTranslatedValue
   	ACCESS    		read-only
   	STATUS        mandatory
   	DESCRIPTION
				"The value of a sensor reading, in textual format, translated
 				according to sensor and datum types. These formats can include
				integers, fixed-point, and binary values. In several examples:
				a pulse counter might report '12345', a current sensor might report
				'1.43', and a door sensor might report 'closed'."
		::= { EGW4SensorInfoTranslatedFormatByDatumNumberEntry 3 }

EGW4SensorInfoTranslatedFormatByDatumNumberReadingUnits OBJECT-TYPE
		SYNTAX        EGW4SensorDeviceReadingTranslatedUnits
   	ACCESS    		read-only
   	STATUS        mandatory
   	DESCRIPTION
				"The units or scale of value of a sensor reading, reported in textual
				format. In several examples: a pulse counter might report 'Count',
				a current sensor might report 'A', and a door sensor might report
				'Closed'."
		::= { EGW4SensorInfoTranslatedFormatByDatumNumberEntry 4 }

--
-- Sensor-specific section, untranslated legacy format, by sensor ID
--

EGW4SensorInfoBySensorIDTable OBJECT-TYPE
		SYNTAX				SEQUENCE OF EGW4SensorInfoBySensorIDSensorEntry
		ACCESS    		not-accessible
		STATUS        mandatory
		DESCRIPTION
				"The (conceptual) table containing sensor information in a legacy
 				untranslated numeric format, addressed by sensor ID. This is provided
 				for users who need a precise match of the format of the older EGW1
 				platform. The gateway will report the most current information received
 				from sensors, according to their programmed reporting period or
 				heartbeat. A more convenient format to new users is available under
				the EGW4SensorInfoTranslatedFormat. If queried, this
				OID will return the number of rows in the table, which is the number
				of sensors registered to this gateway."
		::= { EGW4 3 }

EGW4SensorInfoBySensorIDEntry OBJECT-TYPE
		SYNTAX				EGW4SensorInfoBySensorIDEntry
		ACCESS    		not-accessible
		STATUS        mandatory
		DESCRIPTION
				"An entry (conceptual row) in the untranslated by-sensor-ID-order
 				table containing the latest sensor state for a single sensor."
		INDEX   { EGW4SensorInfoBySensorIDSensorDeviceID }
		::= { EGW4SensorInfoBySensorIDTable 1 }

EGW4SensorInfoBySensorIDEntry ::= SEQUENCE {
		EGW4SensorInfoBySensorIDSensorDeviceID Unsigned32,
		EGW4SensorInfoBySensorIDSensorDeviceWDIndexNo INTEGER,
		EGW4SensorInfoBySensorIDSensorDeviceTypeNo INTEGER,
		EGW4SensorInfoBySensorIDSensorDeviceReadingAge Unsigned32,
		EGW4SensorInfoBySensorIDSensorDeviceActive INTEGER,
		EGW4SensorInfoBySensorIDSensorDeviceAlarming INTEGER,
		EGW4SensorInfoBySensorIDSensorDeviceVoltage INTEGER,
		EGW4SensorInfoBySensorIDSensorDeviceRFStrength INTEGER,
		EGW4SensorInfoBySensorIDSensorDeviceRptUT DisplayString,
		EGW4SensorInfoBySensorIDSensorDeviceReadingValue1 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorIDSensorDeviceReadingValue2 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorIDSensorDeviceReadingValue3 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorIDSensorDeviceReadingValue4 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorIDSensorDeviceReadingValue5 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorIDSensorDeviceReadingValue6 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorIDSensorDeviceReadingValue7 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorIDSensorDeviceReadingValue8 EGW4SensorDeviceReadingU32Value
}

EGW4SensorInfoBySensorIDSensorDeviceID OBJECT-TYPE
     SYNTAX				Unsigned32
     ACCESS    		read-only
     STATUS       mandatory
     DESCRIPTION
 				"The serial number identifier of the sensor device assigned and
 				programmed by the manufacturer. This will ordinarily be printed
 				on a label on the housing of the device."
		INDEX   { EGW4SensorID }
 		::= {EGW4SensorInfoBySensorIDEntry 1 }

EGW4SensorInfoBySensorIDSensorDeviceWDIndexNo OBJECT-TYPE
    SYNTAX				INTEGER(0..255)
    ACCESS    		read-only
    STATUS       mandatory
    DESCRIPTION
 				"The index number of the sensor in the gateway's sensor registration
 				table. This is the number used in referencing the sensor in the
 				EGW4SensorInfoBySensorRegisOrder
 				hierarchy."
		INDEX   { EGW4SensorID }
 		::= {EGW4SensorInfoBySensorIDEntry 2 }

EGW4SensorInfoBySensorIDSensorDeviceTypeNo OBJECT-TYPE
     SYNTAX       INTEGER(1..65535)
     ACCESS    		read-only
     STATUS       mandatory
     DESCRIPTION
 				"The manufacturer's type number that identifies the kind of sensor."
		INDEX   { EGW4SensorID }
 		::= {EGW4SensorInfoBySensorIDEntry 3 }

EGW4SensorInfoBySensorIDSensorDeviceReadingAge OBJECT-TYPE
     SYNTAX       Unsigned32
     ACCESS    		read-only
     STATUS       mandatory
     DESCRIPTION
 				"The age of the sensor report received most recently from a sensor.
 				That time is reported as the number of seconds between the time of
 				the sensor report and the time this information is requested."
		INDEX   { EGW4SensorID }
 		::= {EGW4SensorInfoBySensorIDEntry 4 }

EGW4SensorInfoBySensorIDSensorDeviceActive OBJECT-TYPE
     SYNTAX       INTEGER(0..1)
     ACCESS    		read-only
     STATUS       mandatory
     DESCRIPTION
 				"Either 1 (active) or 0 (inactive). A sensor will be reported active
				if it has recently communicated with the gateway since the last
 				reboot. If a sensor device does not show active, it is likely because
 				(1) the sensor lacks a power source, (2) the sensor is not in
 				proximity to the gateway, or (3) the gateway has recently been
 				powered on, and the sensor hasn't yet communicated."
		INDEX   { EGW4SensorID }
 		::= {EGW4SensorInfoBySensorIDEntry 5 }

EGW4SensorInfoBySensorIDSensorDeviceAlarming OBJECT-TYPE
		 SYNTAX       INTEGER(0..1)
     ACCESS    		read-only
     STATUS       mandatory
     DESCRIPTION
 				"Either 1 (alarming) or 0 (not alarming)'. A device will report an
				alarm if it is programmed with a threshold found to be exceeded.
				Examples: a temperature sensor for a refrigeration unit can be
				programmed to alarm if the measured temperature rises above a
				threshold, and a door sensor might alarm if a security door is opened."
		INDEX   { EGW4SensorID }
 		::= {EGW4SensorInfoBySensorIDEntry 6 }

EGW4SensorInfoBySensorIDSensorDeviceVoltage OBJECT-TYPE
		SYNTAX        INTEGER(0..255)
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
				"A value representing the voltage of the supply powering a sensor
				device. Ordinarily this will report the voltage at the battery
				terminals of a sensor. It is provided mainly so batteries can be
				changed when depleted. The formula for calculating the voltage from
				this number is: voltage=(150 + v) / 10.0."
		INDEX   { EGW4SensorID }
 		::= {EGW4SensorInfoBySensorIDEntry 7 }

EGW4SensorInfoBySensorIDSensorDeviceRFStrength OBJECT-TYPE
     SYNTAX       INTEGER(-128..127)
     ACCESS    		read-only
     STATUS       mandatory
     DESCRIPTION
 				"The signal strength, in percent, of the radio link between the gateway
 				and the particular sensor, as measured at the time of the most recent
 				sensor report."
		INDEX   { EGW4SensorID }
 		::= {EGW4SensorInfoBySensorIDEntry 8 }

EGW4SensorInfoBySensorIDSensorDeviceRptUT OBJECT-TYPE
     SYNTAX       DisplayString
     ACCESS    		read-only
     STATUS       mandatory
     DESCRIPTION
 				"The untranslated data block received from a sensor, in hexadecimal
 				format. This may be used where a translating function isn't yet
 				present, and for development purposes. Most users should use the
				translated values delivered in the format of
				EGW4SensorDeviceReadingValuesAll."
		INDEX   { EGW4SensorID }
 		::= {EGW4SensorInfoBySensorIDEntry 9 }

EGW4SensorInfoBySensorIDSensorDeviceReadingValue1 OBJECT-TYPE
    SYNTAX		EGW4SensorDeviceReadingU32Value
    ACCESS		read-only
    STATUS		mandatory
    DESCRIPTION
				"The value of a single sensor reading, or one half of a 64-bit reading,
				in integer format, not translated to human-readable form. See
				EGW4SensorDeviceReadingU32Value for further explanation."
		INDEX   { EGW4SensorID }
 		::= {EGW4SensorInfoBySensorIDEntry 10 }

EGW4SensorInfoBySensorIDSensorDeviceReadingValue2 OBJECT-TYPE
    SYNTAX		EGW4SensorDeviceReadingU32Value
    ACCESS		read-only
    STATUS		mandatory
    DESCRIPTION
  			"The value of a single sensor reading, or one half of a 64-bit reading,
 				in integer format, not translated to human-readable form. See
 				EGW4SensorDeviceReadingU32Value for further explanation."
		INDEX   { EGW4SensorID }
  	::= {EGW4SensorInfoBySensorIDEntry 11 }

EGW4SensorInfoBySensorIDSensorDeviceReadingValue3 OBJECT-TYPE
		SYNTAX		EGW4SensorDeviceReadingU32Value
	  ACCESS		read-only
	  STATUS		mandatory
		DESCRIPTION
				"The value of a single sensor reading, or one half of a 64-bit reading,
				in integer format, not translated to human-readable form. See
				EGW4SensorDeviceReadingU32Value for further explanation."
		INDEX   { EGW4SensorID }
 		::= {EGW4SensorInfoBySensorIDEntry 12 }

EGW4SensorInfoBySensorIDSensorDeviceReadingValue4 OBJECT-TYPE
    SYNTAX		EGW4SensorDeviceReadingU32Value
    ACCESS		read-only
    STATUS		mandatory
    DESCRIPTION
				"The value of a single sensor reading, or one half of a 64-bit reading,
	 			in integer format, not translated to human-readable form. See
	 			EGW4SensorDeviceReadingU32Value for further explanation."
		INDEX   { EGW4SensorID }
	  ::= {EGW4SensorInfoBySensorIDEntry 13 }

EGW4SensorInfoBySensorIDSensorDeviceReadingValue5 OBJECT-TYPE
    SYNTAX		EGW4SensorDeviceReadingU32Value
    ACCESS		read-only
    STATUS		mandatory
    DESCRIPTION
		 		"The value of a single sensor reading, or one half of a 64-bit reading,
				in integer format, not translated to human-readable form. See
				EGW4SensorDeviceReadingU32Value for further explanation."
		INDEX   { EGW4SensorID }
 		::= {EGW4SensorInfoBySensorIDEntry 14 }

EGW4SensorInfoBySensorIDSensorDeviceReadingValue6 OBJECT-TYPE
    SYNTAX		EGW4SensorDeviceReadingU32Value
    ACCESS		read-only
    STATUS		mandatory
    DESCRIPTION
		  	"The value of a single sensor reading, or one half of a 64-bit reading,
		 		in integer format, not translated to human-readable form. See
		 		EGW4SensorDeviceReadingU32Value for further explanation."
		INDEX   { EGW4SensorID }
		::= {EGW4SensorInfoBySensorIDEntry 15 }

EGW4SensorInfoBySensorIDSensorDeviceReadingValue7 OBJECT-TYPE
    SYNTAX		EGW4SensorDeviceReadingU32Value
    ACCESS		read-only
    STATUS		mandatory
    DESCRIPTION
			 	"The value of a single sensor reading, or one half of a 64-bit reading,
				in integer format, not translated to human-readable form. See
				EGW4SensorDeviceReadingU32Value for further explanation."
		INDEX   { EGW4SensorID }
		::= {EGW4SensorInfoBySensorIDEntry 16 }

EGW4SensorInfoBySensorIDSensorDeviceReadingValue8 OBJECT-TYPE
    SYNTAX		EGW4SensorDeviceReadingU32Value
    ACCESS		read-only
    STATUS		mandatory
    DESCRIPTION
				"The value of a single sensor reading, or one half of a 64-bit reading,
				in integer format, not translated to human-readable form. See
				EGW4SensorDeviceReadingU32Value for further explanation."
		INDEX   { EGW4SensorID }
		::= {EGW4SensorInfoBySensorIDEntry 17 }

 --
 -- Sensor-specific section, untranslated legacy format, by registration order
 --

EGW4SensorInfoBySensorRegisOrderTable OBJECT-TYPE
		SYNTAX				SEQUENCE OF EGW4SensorInfoBySensorRegisOrderSensorEntry
		ACCESS    		not-accessible
		STATUS        mandatory
		DESCRIPTION
				"The (conceptual) table containing an untranslated numeric format,
				addressed by sensor registration order starting at 1 and ascending by
				one, in a legacy integer format. This is provided for users who need a
 				precise match of the format and order of the older EGW1 platform.
 				The gateway will report the most current information received from
 				sensors, according to their programmed reporting period or heartbeat.
				A more convenient format to new users is available under
				the EGW4SensorInfoTranslatedFormat. If queried, this
				OID will return the number of rows in the table, which is the number
				of sensors registered to this gateway."
		::= { EGW4 4 }

EGW4SensorInfoBySensorRegisOrderEntry OBJECT-TYPE
		SYNTAX				EGW4SensorInfoBySensorRegisOrderEntry
		ACCESS    		not-accessible
		STATUS        mandatory
		DESCRIPTION
				"An entry (conceptual row) in the untranslated by-registration-order
 				table containing the latest sensor state for a single sensor."
		INDEX   { EGW4SensorInfoBySensorRegisOrderSensDevID }
		::= { EGW4SensorInfoBySensorRegisOrderTable 1 }

EGW4SensorInfoBySensorRegisOrderEntry ::= SEQUENCE {
		EGW4SensorInfoBySensorRegisOrderSensorDeviceID Unsigned32,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceWDIndexNo INTEGER,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceTypeNo INTEGER,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceReadingAge Unsigned32,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceActive INTEGER,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceAlarming INTEGER,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceVoltage INTEGER,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceRFStrength INTEGER,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceRptUT DisplayString,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceReadingValue1 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceReadingValue2 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceReadingValue3 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceReadingValue4 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceReadingValue5 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceReadingValue6 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceReadingValue7 EGW4SensorDeviceReadingU32Value,
		EGW4SensorInfoBySensorRegisOrderSensorDeviceReadingValue8 EGW4SensorDeviceReadingU32Value
}

EGW4SensorInfoBySensorRegisOrderSensDevID OBJECT-TYPE
    SYNTAX        Unsigned32
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The serial number identifier of the sensor device assigned and
  			programmed by the manufacturer. This will ordinarily be printed
  			on a label on the housing of the device."
		INDEX   { EGW4SensorRegistrationIndex }
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 1 }

EGW4SensorInfoBySensorRegisOrderSensDevWDIndexNo OBJECT-TYPE
    SYNTAX        INTEGER(0..255)
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The index number of the sensor in the gateway's sensor registration
  			table. This is the number used in referencing the sensor in the
  			EGW4SensorInfoBySensorRegisOrder hierarchy."
		INDEX   { EGW4SensorRegistrationIndex }
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 2 }

EGW4SensorInfoBySensorRegisOrderSensDevTypeNo OBJECT-TYPE
    SYNTAX        INTEGER(1..65535)
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The manufacturer's type number that identifies the kind of sensor."
		INDEX   { EGW4SensorRegistrationIndex }
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 3 }

EGW4SensorInfoBySensorRegisOrderSensDevReadingAge OBJECT-TYPE
    SYNTAX        Unsigned32
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The age of the sensor report received most recently from a sensor.
  			That time is reported as the number of seconds between the time of
  			the sensor report and the time this information is requested."
		INDEX   { EGW4SensorRegistrationIndex }
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 4 }

EGW4SensorInfoBySensorRegisOrderSensDevActive OBJECT-TYPE
    SYNTAX        INTEGER(0..1)
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"Either 1 (active) or 0 (inactive). A sensor will be reported active
 				if it has recently communicated with the gateway since the last
  			reboot. If a sensor device does not show active, it is likely because
  			(1) the sensor lacks a power source, (2) the sensor is not in
  			proximity to the gateway, or (3) the gateway has recently been
  			powered on, and the sensor hasn't yet communicated."
		INDEX   { EGW4SensorRegistrationIndex }
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 5 }

EGW4SensorInfoBySensorRegisOrderSensDevAlarming OBJECT-TYPE
		SYNTAX        	INTEGER(0..1)
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"Either 1 (alarming) or 0 (not alarming)'. A device will report an
 				alarm if it is programmed with a threshold found to be exceeded.
 				Examples: a temperature sensor for a refrigeration unit can be
 				programmed to alarm if the measured temperature rises above a
 				threshold, and a door sensor might alarm if a security door is opened."
		INDEX   { EGW4SensorRegistrationIndex }
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 6 }

EGW4SensorInfoBySensorRegisOrderSensDevVoltage OBJECT-TYPE
		SYNTAX        	INTEGER(0..255)
    ACCESS    			read-only
    STATUS       	mandatory
    DESCRIPTION
 				"A value representing the voltage of the supply powering a sensor
 				device. Ordinarily this will report the voltage at the battery
 				terminals of a sensor. It is provided mainly so batteries can be
 				changed when depleted. The formula for calculating the voltage from
 				this number is: voltage=(150 + v) / 10.0."
		INDEX   { EGW4SensorRegistrationIndex }
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 7 }

EGW4SensorInfoBySensorRegisOrderSensDevRFStrength OBJECT-TYPE
    SYNTAX        INTEGER(-128..127)
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The signal strength, in percent, of the radio link between the gateway
  			and the particular sensor, as measured at the time of the most recent
  			sensor report."
		INDEX   { EGW4SensorRegistrationIndex }
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 8 }

EGW4SensorInfoBySensorRegisOrderSensDevRptUT OBJECT-TYPE
    SYNTAX        DisplayString
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The untranslated data block received from a sensor, in hexadecimal
  			format. This may be used where a translating function isn't yet
  			present, and for development purposes. Most users should use the
				translated values delivered in the format of
				EGW4SensorDeviceReadingValuesAll."
		INDEX   { EGW4SensorRegistrationIndex }
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 9 }

EGW4SensorInfoBySensorRegisOrderSensDevReadingVl1 OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceReadingU32Value
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The value of a single sensor reading, or one half of a 64-bit reading,
 				in integer format, not translated to human-readable form. See
 				EGW4SensorDeviceReadingU32Value for further explanation."
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 10 }

EGW4SensorInfoBySensorRegisOrderSensDevReadingVl2 OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceReadingU32Value
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The value of a single sensor reading, or one half of a 64-bit reading,
 				in integer format, not translated to human-readable form. See
 				EGW4SensorDeviceReadingU32Value for further explanation."
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 11 }

EGW4SensorInfoBySensorRegisOrderSensDevReadingVl3 OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceReadingU32Value
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The value of a single sensor reading, or one half of a 64-bit reading,
 				in integer format, not translated to human-readable form. See
 				EGW4SensorDeviceReadingU32Value for further explanation."
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 12 }

EGW4SensorInfoBySensorRegisOrderSensDevReadingVl4 OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceReadingU32Value
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The value of a single sensor reading, or one half of a 64-bit reading,
 				in integer format, not translated to human-readable form. See
 				EGW4SensorDeviceReadingU32Value for further explanation."
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 13 }

EGW4SensorInfoBySensorRegisOrderSensDevReadingVl5 OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceReadingU32Value
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The value of a single sensor reading, or one half of a 64-bit reading,
 				in integer format, not translated to human-readable form. See
 				EGW4SensorDeviceReadingU32Value for further explanation."
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 14 }

EGW4SensorInfoBySensorRegisOrderSensDevReadingVl6 OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceReadingU32Value
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The value of a single sensor reading, or one half of a 64-bit reading,
 				in integer format, not translated to human-readable form. See
 				EGW4SensorDeviceReadingU32Value for further explanation."
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 15 }

EGW4SensorInfoBySensorRegisOrderSensDevReadingVl7 OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceReadingU32Value
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The value of a single sensor reading, or one half of a 64-bit reading,
 				in integer format, not translated to human-readable form. See
 				EGW4SensorDeviceReadingU32Value for further explanation."
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 16 }

EGW4SensorInfoBySensorRegisOrderSensDevReadingVl8 OBJECT-TYPE
    SYNTAX        EGW4SensorDeviceReadingU32Value
    ACCESS    		read-only
    STATUS        mandatory
    DESCRIPTION
  			"The value of a single sensor reading, or one half of a 64-bit reading,
 				in integer format, not translated to human-readable form. See
 				EGW4SensorDeviceReadingU32Value for further explanation."
  	::= {EGW4SensorInfoBySensorRegisOrderEntry 17 }

--
-- Traps
--

--Map of types used in traps to those used in requests
--	EGW4-Trap-DevIDReported ::= EGW4-GatewayID
--	EGW4-Trap-AllValuesReported ::=
-- 		CHOICE {
--							EGW4-trap-values-translatable EGW4-SensorDeviceReadingValuesAll,
--							EGW4-trap-values-unknown EGW4-SensorDeviceReadingUntranslated
--					 }
--	EGW4-Trap-AllUnitsReported ::= EGW4-SensorDeviceReadingUnitsAll
--	EGW4-Trap-AgeReported ::= EGW4-SensorDeviceReadingUnitsAll
--	EGW4-Trap-AlarmingReported ::= EGW4-SensorDeviceReadingUnitsAll

EGW4TrapDevIDReported ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"The serial number identifier of the sensor device assigned and
				programmed by the manufacturer. This will ordinarily be printed
				on a label on the housing of the device. EGW4TrapDevIDReported
				is the same as EGW4SensorID."
		SYNTAX				Unsigned32(1..2147483631)

EGW4TrapAllValuesReported ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"This will make one of two reports. For the case the sensor type is
				known to the gateway, this will be all of the datums for the most
 				recent reading of the sensor device, separated by commas, in textual
 				format, using the EGW4SensorDeviceReadingValuesAll format.
				Where the sensor type is not known to the gateway, this will be
				the untranslated data block received from a sensor, in hexadecimal
				format. This EGW4TrapAllValuesReported is the same as either
				EGW4SensorDeviceReadingValuesAll or
 				EGW4SensorDeviceReadingUntranslated."
		SYNTAX				OCTET STRING

EGW4TrapAllUnitsReported ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"All of the units corresponding to the datums for the most recent
				reading of the sensor device, separated by commas, in textual
				format. For example, for a sensor reporting temperature and
				humidity this might read 'degrees C, %RH'.
				EGW4TrapAllUnitsReported is the same as
 				EGW4SensorDeviceReadingUnitsAll."
		SYNTAX				OCTET STRING

EGW4TrapAgeReported ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"The age of the sensor report received most recently from a sensor.
				That time is reported as the number of seconds between the time of
				the sensor report and the time this information is requested.
				EGW4TrapAgeReported is the same as
				EGW4SensorDeviceReadingAge."
		SYNTAX				OCTET STRING

EGW4TrapAlarmingReported ::= TEXTUAL-CONVENTION
		STATUS        mandatory
		DESCRIPTION
				"Either 'Alarming' or 'Not alarming'. A device will report an alarm
				if it is programmed with a threshold found to be exceeded. Examples:
				a temperature sensor for a refrigeration unit can be programmed to
				alarm if the measured temperature rises above a threshold, and
				a door sensor might alarm if a security door is opened.
				EGW4TrapAlarmingReported is the same as
				EGW4SensorDeviceReadingAlarming."
		SYNTAX				OCTET STRING

EGW4NewSensorTraffic TRAP-TYPE
	ENTERPRISE EGW4
	VARIABLES {
							EGW4SensorInfoTranslatedFormatSensorDeviceID, EGW4TrapDevIDReported,
							EGW4SensorInfoTranslatedFormatSensorDeviceReadingValuesAll, EGW4TrapAllValuesReported,
							EGW4SensorInfoTranslatedFormatSensorDeviceReadingUnitsAll, EGW4TrapAllUnitsReported,
							EGW4SensorInfoTranslatedFormatSensorDeviceReadingAge, EGW4TrapAgeReported,
							EGW4SensorInfoTranslatedFormatSensorDeviceAlarming, EGW4TrapAlarmingReported
						}
	DESCRIPTION
			"This trap, when enabled, will generate a report corresponding to new
 			data from any registered sensor as it is received. Included with the
 			trap message are the sensor ID, all values the sensor reports, units for
 			all those values, the age, and whether the sensor is alarming."
	::= 1

EGW4DeviceAlarming TRAP-TYPE
	ENTERPRISE EGW4
	VARIABLES {
							EGW4SensorInfoTranslatedFormatSensorDeviceID, EGW4TrapDevIDReported,
							EGW4SensorInfoTranslatedFormatSensorDeviceReadingValuesAll, EGW4TrapAllValuesReported,
							EGW4SensorInfoTranslatedFormatSensorDeviceReadingUnitsAll, EGW4TrapAllUnitsReported,
							EGW4SensorInfoTranslatedFormatSensorDeviceReadingAge, EGW4TrapAgeReported,
							EGW4SensorInfoTranslatedFormatSensorDeviceAlarming, EGW4TrapAlarmingReported
						}
	DESCRIPTION
			"This trap, when enabled, will generate a report corresponding to new
 			data from any registered sensor as it is received, but only if that
			sensor is alarming and the EGW4NewSensorTraffic trap is disabled.
			(That trap will generate the same message, rendering this trap redundant.)
			Included with the trap message are the sensor ID, all values the sensor
 			reports, units for all those values, the age, and whether the sensor
 			is alarming."
	::= 2

END
