Ejemplo n.º 1
0
        /// <summary>
        /// Sends a request, expecting a simple ack in response
        /// </summary>
        /// <param name="deviceInstance">The device instance of the destination device</param>
        /// <param name="request">The request to send</param>
        /// <returns>The task to wait for a simple ack in response</returns>
        public Task SendRequestAsync(uint deviceInstance, IConfirmedRequest request)
        {
            var handle = new SimpleAckHandle();

            Host.SendConfirmedRequest(handle, deviceInstance, request);
            return(handle.WaitAsync());
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Sends a request and retrieves the response as a specific type
        /// </summary>
        /// <typeparam name="T">The response type</typeparam>
        /// <param name="deviceInstance">The device instance of the destination device</param>
        /// <param name="request">The request to send</param>
        /// <returns>The response value</returns>
        public Task <TAck> SendRequestAsync <TAck>(uint deviceInstance, IConfirmedRequest request)
            where TAck : IComplexAck
        {
            var handle = new ComplexAckHandle <TAck>();

            Host.SendConfirmedRequest(handle, deviceInstance, request);
            return(handle.GetResponseAsync());
        }
Ejemplo n.º 3
0
 /// <summary>
 /// Sends a confirmed request
 /// </summary>
 /// <param name="handle">The handle used to control the transaction</param>
 /// <param name="instance">The address of the destination device</param>
 /// <param name="request">The request to send</param>
 public void SendConfirmedRequest(ClientTransactionHandle handle, uint instance, IConfirmedRequest request)
 {
     lock (_lock)
     {
         var bytes = _saveConfirmedRequest(request);
         _txManager.SendConfirmedRequest(handle, instance, (byte)request.ServiceChoice, bytes);
     }
 }
Ejemplo n.º 4
0
        /// <summary>
        /// Tags a confirmed request and retrieves its content
        /// as a byte array
        /// </summary>
        /// <param name="request">The request to save</param>
        /// <returns>The tagged byte array</returns>
        private byte[] _saveConfirmedRequest(IConfirmedRequest request)
        {
            switch (request.ServiceChoice)
            {
            case ConfirmedServiceChoice.AcknowledgeAlarm:
                return(Tags.EncodeBytes((AcknowledgeAlarmRequest)request));

            case ConfirmedServiceChoice.AddListElement:
                return(Tags.EncodeBytes((AddListElementRequest)request));

            case ConfirmedServiceChoice.AtomicReadFile:
                return(Tags.EncodeBytes((AtomicReadFileRequest)request));

            case ConfirmedServiceChoice.AtomicWriteFile:
                return(Tags.EncodeBytes((AtomicWriteFileRequest)request));

            case ConfirmedServiceChoice.Authenticate:
                return(Tags.EncodeBytes((AuthenticateRequest)request));

            case ConfirmedServiceChoice.ConfirmedCOVNotification:
                return(Tags.EncodeBytes((ConfirmedCOVNotificationRequest)request));

            case ConfirmedServiceChoice.ConfirmedEventNotification:
                return(Tags.EncodeBytes((ConfirmedEventNotificationRequest)request));

            case ConfirmedServiceChoice.ConfirmedPrivateTransfer:
                return(Tags.EncodeBytes((ConfirmedPrivateTransferRequest)request));

            case ConfirmedServiceChoice.ConfirmedTextMessage:
                return(Tags.EncodeBytes((ConfirmedTextMessageRequest)request));

            case ConfirmedServiceChoice.CreateObject:
                return(Tags.EncodeBytes((CreateObjectRequest)request));

            case ConfirmedServiceChoice.DeleteObject:
                return(Tags.EncodeBytes((DeleteObjectRequest)request));

            case ConfirmedServiceChoice.DeviceCommunicationControl:
                return(Tags.EncodeBytes((DeviceCommunicationControlRequest)request));

            case ConfirmedServiceChoice.GetAlarmSummary:
                return(Tags.EncodeBytes((GetAlarmSummaryRequest)request));

            case ConfirmedServiceChoice.GetEnrollmentSummary:
                return(Tags.EncodeBytes((GetEnrollmentSummaryRequest)request));

            case ConfirmedServiceChoice.GetEventInformation:
                return(Tags.EncodeBytes((GetEventInformationRequest)request));

            case ConfirmedServiceChoice.LifeSafetyOperation:
                return(Tags.EncodeBytes((LifeSafetyOperationRequest)request));

            case ConfirmedServiceChoice.ReadProperty:
                return(Tags.EncodeBytes((ReadPropertyRequest)request));

            case ConfirmedServiceChoice.ReadPropertyConditional:
                return(Tags.EncodeBytes((ReadPropertyConditionalRequest)request));

            case ConfirmedServiceChoice.ReadPropertyMultiple:
                return(Tags.EncodeBytes((ReadPropertyMultipleRequest)request));

            case ConfirmedServiceChoice.ReadRange:
                return(Tags.EncodeBytes((ReadRangeRequest)request));

            case ConfirmedServiceChoice.ReinitializeDevice:
                return(Tags.EncodeBytes((ReinitializeDeviceRequest)request));

            case ConfirmedServiceChoice.RemoveListElement:
                return(Tags.EncodeBytes((RemoveListElementRequest)request));

            case ConfirmedServiceChoice.RequestKey:
                return(Tags.EncodeBytes((RequestKeyRequest)request));

            case ConfirmedServiceChoice.SubscribeCOV:
                return(Tags.EncodeBytes((SubscribeCOVRequest)request));

            case ConfirmedServiceChoice.SubscribeCOVProperty:
                return(Tags.EncodeBytes((SubscribeCOVPropertyRequest)request));

            case ConfirmedServiceChoice.VtClose:
                return(Tags.EncodeBytes((VtCloseRequest)request));

            case ConfirmedServiceChoice.VtData:
                return(Tags.EncodeBytes((VtDataRequest)request));

            case ConfirmedServiceChoice.VtOpen:
                return(Tags.EncodeBytes((VtOpenRequest)request));

            case ConfirmedServiceChoice.WriteProperty:
                return(Tags.EncodeBytes((WritePropertyRequest)request));

            case ConfirmedServiceChoice.WritePropertyMultiple:
                return(Tags.EncodeBytes((WritePropertyMultipleRequest)request));

            default:
                throw new RejectException(RejectReason.UnrecognizedService);
            }
        }