iso-9506-mms-1.asn

mms ISO9506 moduel descriped in ASN.1

     conclude  [9] IMPLICIT INTEGER {
     other     (0),
     further-communication-required     (1)
     } (0..1)
IF ( cancel )
,    cancel    [10] IMPLICIT INTEGER {  
     other     (0), 
     invoke-id-unknown   (1), 
     cancel-not-possible (2)  
     } (0..2)
ELSE
,    cancel    [10] IMPLICIT NULL
ENDIF
IF ( fileOpen fileClose fileRead fileRename fileDelete fileDirectory obtainFile )
,    file [11] IMPLICIT INTEGER {
     other     (0), 
     filename-ambiguous  (1), 
     file-busy (2),
     filename-syntax-error    (3),
     content-type-invalid     (4),
     position-invalid    (5), 
     file-access-denied  (6),
     file-non-existent   (7),
     duplicate-filename  (8),
     insufficient-space-in-filestore    (9)
     } (0..9)
ELSE
,    file [11] IMPLICIT NULL
ENDIF
,    others    [12] IMPLICIT INTEGER
 } ,
     additionalCode [1] IMPLICIT INTEGER OPTIONAL,
     additionalDescription    [2] IMPLICIT VisibleString OPTIONAL,
     serviceSpecificInfo [3] CHOICE {
IF ( obtainFile )
     obtainFile     [0] IMPLICIT ObtainFile-Error 
ELSE
     obtainFile     [0] IMPLICIT NULL 
ENDIF
IF ( start )
,    start     [1] IMPLICIT Start-Error 
ELSE
,    start     [1] IMPLICIT NULL 
ENDIF
IF ( stop )
,    stop [2] IMPLICIT Stop-Error 
ELSE
,    stop [2] IMPLICIT NULL 
ENDIF
IF ( resume )
,    resume    [3] IMPLICIT Resume-Error 
ELSE
,    resume    [3] IMPLICIT NULL 
ENDIF
IF ( reset )
,    reset     [4] IMPLICIT Reset-Error 
ELSE
,    reset     [4] IMPLICIT NULL 
ENDIF
IF ( deleteVariableAccess )
,    deleteVariableAccess     [5] IMPLICIT DeleteVariableAccess-Error
ELSE
,    deleteVariableAccess     [5] IMPLICIT NULL
ENDIF
IF ( deleteNamedVariableList )
,    deleteNamedVariableList  [6] IMPLICIT DeleteNamedVariableList-Error
ELSE
,    deleteNamedVariableList  [6] IMPLICIT NULL
ENDIF
IF ( deleteNamedType )
,    deleteNamedType     [7] IMPLICIT DeleteNamedType-Error
ELSE
,    deleteNamedType     [7] IMPLICIT NULL
ENDIF
IF ( defineEventEnrollment )
                                   ,    defineEventEnrollment-Error   [8] DefineEventEnrollment-Error
ELSE
                                   ,    defineEventEnrollment-Error   [8] IMPLICIT NULL
ENDIF
     -- [9] Reserved for use by annex D
IF ( fileRename )
,    fileRename     [9] IMPLICIT FileRename-Error
ELSE
,    fileRename     [9] IMPLICIT NULL
ENDIF
IF ( csr cspi )
,    additionalService   [10] AdditionalService-Error
ELSE
,    additionalService   [10] IMPLICIT NULL
ENDIF
IF ( changeAccessControl )
,    changeAccessControl      [11] IMPLICIT ChangeAccessControl-Error
ELSE
     changeAccessControl 11] IMPLICIT NULL
ENDIF
     } OPTIONAL
     } 

 AdditionalService-Error ::= CHOICE {
IF ( defineEventConditionList )
     defineEcl [0] DefineEventConditionList-Error
ELSE
     defineEcl [0] IMPLICIT NULL
ENDIF
IF ( addEventConditionListReference )
,    addECLReference     [1] AddEventConditionListReference-Error
ELSE
,    addECLReference     [1] IMPLICIT NULL
ENDIF
IF ( removeEventConditionListReference )
,    removeECLReference  [2] RemoveEventConditionListReference-Error
ELSE
,    removeECLReference  [2] IMPLICIT NULL
ENDIF
IF ( initiateUnitControlLoad )
,    initiateUC     [3] InitiateUnitControl-Error
ELSE
,    initiateUC     [3] IMPLICIT NULL
ENDIF
IF ( startUnitControl )
,    startUC   [4] IMPLICIT StartUnitControl-Error
ELSE
,    startUC   [4] IMPLICIT NULL
ENDIF
IF ( stopUnitControl )
,    stopUC    [5] IMPLICIT StopUnitControl-Error
ELSE
,    stopUC    [5] IMPLICIT NULL
ENDIF
IF ( deleteUnitControl )
,    deleteUC  [6] DeleteUnitControl-Error
ELSE
,    deleteUC  [6] IMPLICIT NULL
ENDIF
IF ( loadUnitControlFromFile )
,    loadUCFromFile [7] LoadUnitControlFromFile-Error
ELSE
,    loadUCFromFile [7] IMPLICIT NULL
ENDIF
     } 

 TimeOfDay ::= OCTET STRING (SIZE(4|6)) 

 maxIdentifier INTEGER ::= 32

Identifier ::= 
IF (char)
     UTF8String (SIZE(1..maxIdentifier))
ELSE
     VisibleString ( FROM
     ("A"|"a"|"B"|"b"|"C"|"c"|"D"|"d"|"E"|"e"|"F"|"f"|
     "G"|"g"|"H"|"h"|"I"|"i"|"J"|"j"|"K"|"k"|"L"|"l"|
     "M"|"m"|"N"|"n"|"O"|"o"|"P"|"p"|"Q"|"q"|"R"|"r"|
     "S"|"s"|"T"|"t"|"U"|"u"|"V"|"v"|"W"|"w"|"X"|"x"|
     "Y"|"y"|"Z"|"z"|"$"|"_"|"0"|"1"|"2"|"3"|"4"|"5"|
     "6"|"7"|"8"|"9") ) (SIZE(1..maxIdentifier))
ENDIF 

 Integer8 ::= INTEGER(-128..127)   -- range -128 <= i <= 127

 Integer16 ::= INTEGER(-32768..32767)   -- range -32,768 <= i <= 32,767

 Integer32 ::= INTEGER(-2147483648..2147483647)   -- range -2**31 <= i <= 2**31 - 1

 Unsigned8 ::= INTEGER(0..127)     -- range 0 <= i <= 127

 Unsigned16 ::= INTEGER(0..32767)  -- range 0 <= i <= 32767

 Unsigned32 ::= INTEGER(0..2147483647)  -- range 0 <= i <= 2**31 - 1 

 ObjectName ::= CHOICE {
     vmd-specific   [0] IMPLICIT Identifier,
     domain-specific     [1] IMPLICIT SEQUENCE {
     domainID  Identifier,
     itemID    Identifier
     },
     aa-specific    [2] IMPLICIT Identifier
     } 

 ObjectClass ::=    CHOICE {
     basicObjectClass    [0] IMPLICIT INTEGER {
IF ( vnam )
     namedVariable  (0)
ENDIF
     -- value 1 is reserved for definition in Annex E
IF ( vsca )
,    scatteredAccess     (1)
ENDIF
IF ( vlis )
,    namedVariableList   (2)
ENDIF
IF ( vnam )
,    namedType (3)
ENDIF
,    semaphore (4),
     eventCondition (5),
     eventAction    (6),
     eventEnrollment     (7),
     journal   (8),
     domain    (9),
     programInvocation   (10),
     operatorStation     (11),
     dataExchange   (12),
     -- Shall not appear in minor version 1
     accessControlList   (13)
   -- Shall not appear in minor version 1 or 2
     } (0..13),
     ...
IF ( cspi )
,    csObjectClass  [1] IMPLICIT INTEGER {
     eventConditionList  (0),
     unitControl    (1) } (0..1)
ENDIF
     } 

 MMSString ::= 
IF ( char ) 
     UTF8String
ELSE
     VisibleString
ENDIF 

 MMS255String ::= 
IF ( char )
     UTF8String (SIZE(1..255))
ELSE
     VisibleString (SIZE(1..255))
ENDIF 

 FileName ::= SEQUENCE OF GraphicString 

 Initiate-RequestPDU ::= SEQUENCE {

     localDetailCalling  [0] IMPLICIT Integer32 OPTIONAL,
     proposedMaxServOutstandingCalling  [1] IMPLICIT Integer16,
     proposedMaxServOutstandingCalled   [2] IMPLICIT Integer16,
                                             proposedDataStructureNestingLevel  [3] IMPLICIT Integer8 OPTIONAL,
     initRequestDetail   [4] IMPLICIT SEQUENCE {
     proposedVersionNumber    [0] IMPLICIT Integer16,
     proposedParameterCBB     [1] IMPLICIT ParameterSupportOptions,
     servicesSupportedCalling [2] IMPLICIT ServiceSupportOptions ,
     ...
IF (csr cspi)
,    additionalSupportedCalling    [3] IMPLICIT AdditionalSupportOptions
ENDIF
IF (cspi)
,    additionalCbbSupportedCalling [4] IMPLICIT AdditionalCBBOptions,
     privilegeClassIdentityCalling [5] IMPLICIT VisibleString
ENDIF
     }
     } 

 Initiate-ResponsePDU ::= SEQUENCE {
     localDetailCalled   [0] IMPLICIT Integer32 OPTIONAL,
     negotiatedMaxServOutstandingCalling     [1] IMPLICIT Integer16,
     negotiatedMaxServOutstandingCalled [2] IMPLICIT Integer16,
     negotiatedDataStructureNestingLevel     [3] IMPLICIT Integer8 OPTIONAL,
     initResponseDetail  [4] IMPLICIT SEQUENCE {
     negotiatedVersionNumber  [0] IMPLICIT Integer16,
     negotiatedParameterCBB   [1] IMPLICIT ParameterSupportOptions,
     servicesSupportedCalled  [2] IMPLICIT ServiceSupportOptions,
     ...
IF (csr cspi)
,    additionalSupportedCalled     [3] IMPLICIT AdditionalSupportOptions
ENDIF
IF (cspi )
,    additionalCbbSupportedCalled  [4] IMPLICIT AdditionalCBBOptions,
     privilegeClassIdentityCalled  [5] IMPLICIT VisibleString
ENDIF
     }
     } 

 Initiate-ErrorPDU ::= ServiceError 

 Conclude-RequestPDU ::= NULL

 Conclude-ResponsePDU ::= NULL

 Conclude-ErrorPDU ::= ServiceError 

 Cancel-RequestPDU ::= Unsigned32 -- originalInvokeID

 Cancel-ResponsePDU ::= Unsigned32 -- originalInvokeID

 Cancel-ErrorPDU ::= SEQUENCE {
     originalInvokeID    [0] IMPLICIT Unsigned32,
     serviceError   [1] IMPLICIT ServiceError
     } 

 RejectPDU ::= SEQUENCE {
     originalInvokeID    [0] IMPLICIT Unsigned32 OPTIONAL,
     rejectReason   CHOICE {
     confirmed-requestPDU     [1] IMPLICIT INTEGER {
     other     (0), 
     unrecognized-service     (1), 
     unrecognized-modifier    (2), 
     invalid-invokeID    (3), 
     invalid-argument    (4), 
     invalid-modifier    (5), 
     max-serv-outstanding-exceeded (6), 
     -- Value 7 reserved for further definition
     max-recursion-exceeded   (8), 
     value-out-of-range  (9)  
     } (0..9),
     confirmed-responsePDU    [2] IMPLICIT INTEGER {
     other     (0), 
     unrecognized-service     (1), 
     invalid-invokeID    (2), 
     invalid-result      (3), 
     -- Value 4 reserved for further definition
     max-recursion-exceeded   (5), 
     value-out-of-range  (6)
     } (0..6),
     confirmed-errorPDU  [3] IMPLICIT INTEGER {
     other     (0), 
     unrecognized-service     (1), 
     invalid-invokeID    (2),
     invalid-serviceError     (3), 
     value-out-of-range  (4)  
     } (0..4),
     unconfirmedPDU [4] IMPLICIT INTEGER {
     other     (0), 
     unrecognized-service     (1), 
     invalid-argument    (2), 
     max-recursion-exceeded   (3), 
     value-out-of-range  (4)  
     } (0..4),
     pdu-error [5] IMPLICIT INTEGER {
     unknown-pdu-type    (0), 
     invalid-pdu    (1), 
     illegal-acse-mapping     (2)
     },
IF ( cancel )
     cancel-requestPDU   [6] IMPLICIT INTEGER {
     other     (0), 
     invalid-invokeID    (1)  
     } (0..1),
     cancel-responsePDU  [7] IMPLICIT INTEGER {
     other     (0), 
     invalid-invokeID    (1)  
     } (0..1),
     cancel-errorPDU     [8] IMPLICIT INTEGER {
     other     (0), 
     invalid-invokeID    (1), 
     invalid-serviceError     (2), 
     value-out-of-range  (3)  
     } (0..3),
ELSE
     cancel-requestPDU   [6] IMPLICIT NULL,
     cancel-responsePDU  [7] IMPLICIT NULL,
     cancel-errorPDU     [8] IMPLICIT NULL,
ENDIF
     conclude-requestPDU [9] IMPLICIT INTEGER {
     other     (0), 
     invalid-argument    (1)  
     } (0..1),
     conclude-responsePDU     [10] IMPLICIT INTEGER {
     other     (0), 
     invalid-result (1)  
     } (0..1),
     conclude-errorPDU   [11] IMPLICIT INTEGER {
     other     (0), 
     invalid-serviceError     (1), 
     value-out-of-range  (2)  
     } (0..2)
     }
     } 

 DefineAccessControlList-Request ::= SEQUENCE {
     accessControlListName    [0] IMPLICIT Identifier,
     accessControlListElements     [1] IMPLICIT SEQUENCE {
     readAccessCondition [0] AccessCondition OPTIONAL,
     storeAccessCondition     [1] AccessCondition OPTIONAL,
     writeAccessCondition     [2] AccessCondition OPTIONAL,
     loadAccessCondition [3] AccessCondition OPTIONAL,
     executeAccessCondition   [4] AccessCondition OPTIONAL,
     deleteAccessCondition    [5] AccessCondition OPTIONAL,
     editAccessCondition [6] AccessCondition OPTIONAL
     }
     } 

 DefineAccessControlList-Response ::= NULL 

 GetAccessControlListAttributes-Request ::= CHOICE {
     accessControlListName    [0] IMPLICIT Identifier,
     vMD  [1] IMPLICIT NULL,
     namedObject    [2] IMPLICIT SEQUENCE {
     objectClass    [0] ObjectClass,
     objectName     [1] ObjectName
     }
     } 

 GetAccessControlListAttributes-Response ::= SEQUENCE {
     name [0] Identifier,
     accessControlListElements     [1] IMPLICIT SEQUENCE {
     readAccessCondition [0] AccessCondition OPTIONAL,
     storeAccessCondition     [1] AccessCondition OPTIONAL,
     writeAccessCondition     [2] AccessCondition OPTIONAL,
     loadAccessCondition [3] AccessCondition OPTIONAL,
     executeAccessCondition   [4] AccessCondition OPTIONAL,
     deleteAccessCondition    [5] AccessCondition OPTIONAL,
     editAccessCondition [6] AccessCondition OPTIONAL
     },
     vMDuse    [2] IMPLICIT BOOLEAN,
     references     [3] IMPLICIT SEQUENCE OF SEQUENCE {
     objectClass    [0] ObjectClass,
     objectCount    [1] IMPLICIT INTEGER
     }
IF ( aco )
,    accessControlList   [4] IMPLICIT Identifier OPTIONAL
     -- shall be included if and only if
     -- aco has been negotiated
ENDIF
     } 

 ReportAccessControlledObjects-Request ::= SEQUENCE {
     accessControlList   [0] IMPLICIT Identifier,
     objectClass    [1] ObjectClass,
     continueAfter  [2] ObjectName OPTIONAL
     }

ReportAccessControlledObjects-Response ::= SEQUENCE {
     listOfNames    [0] IMPLICIT SEQUENCE OF ObjectName,
     moreFollows    [1] IMPLICIT BOOLEAN DEFAULT FALSE
     } 

 DeleteAccessControlList-Request ::= Identifier  
         -- Name of Access Control List Object

 DeleteAccessControlList-Response ::= NULL 

 ChangeAccessControl-Request ::= SEQUENCE {
     scopeOfChange  CHOICE {
     vMDOnly   [0] IMPLICIT NULL,
     listOfObjects  [1] IMPLICIT SEQUENCE {
     objectClass    [0] ObjectClass,
     objectScope    [1] CHOICE {
     specific  [0] IMPLICIT SEQUENCE OF ObjectName,
     -- Names of the objects (of class objectClass)
     -- whose access is to be changed
     aa-specific    [1] IMPLICIT NULL,
     domain    [2] IMPLICIT Identifier,
     -- Name of the Domain whose elements
     -- are to be changed
     vmd  [3] IMPLICIT NULL
     }
     }
     },
     accessControlListName    [2] IMPLICIT Identifier
     -- name of the AccessControlList Object that contains
     -- the conditions for access control
     } 

 ChangeAccessControl-Response ::= SEQUENCE {
     numberMatched  [0] IMPLICIT Unsigned32,
     numberChanged  [1] IMPLICIT Unsigned32
     }

 ChangeAccessControl-Error ::= Unsigned32  

 StatusResponse ::= SEQUENCE {
     vmdLogicalStatus    [0] IMPLICIT INTEGER {
     state-changes-allowed    (0),
     no-state-changes-allowed (1),
     limited-services-permitted    (2),
     support-services-allowed (3)
     } (0..3),
     vmdPhysicalStatus   [1] IMPLICIT INTEGER {
     operational    (0),
     partially-operational    (1),
     inoperable     (2),
     needs-commissioning (3)
     } (0..3),
     localDetail    [2] IMPLICIT BIT STRING (SIZE(0..128)) OPTIONAL
     } 

 CS-Status-Response ::= CHOICE {
IF ( csr )
     fullResponse   SEQUENCE {
     operationState [0] IMPLICIT OperationState,
     extendedStatus [1] IMPLICIT ExtendedStatus,
     extendedStatusMask  [2] IMPLICIT ExtendedStatus DEFAULT '1111'B,
     selectedProgramInvocation     CHOICE {
     programInvocation   [3] IMPLICIT Identifier,
     noneSelected   [4] IMPLICIT NULL   } }
ENDIF
IF ( csr cspi )
,
ENDIF
IF ( cspi )
     noExtraResponse     NULL
ENDIF
     } 

 OperationState ::= INTEGER {
     idle (0),
     loaded    (1),
     ready     (2),
     executing (3),
     motion-paused  (4),
     manualInterventionRequired    (5) } (0..5) 

 ExtendedStatus ::= BIT STRING {
     safetyInterlocksViolated (0),
     anyPhysica