示例#1
0
        private IdpResponseCode OnEnumerateNodesCommand(UInt16 source, UInt16 address, OutgoingTransaction outgoing)
        {
            if (_unenumeratedNodes.Count != 0)
            {
                var node = _unenumeratedNodes.First();

                node.Address = address;
                //node.SetEnumerated();

                if (MarkEnumerated(node))
                {
                    outgoing.Write(true);
                    outgoing.WithResponseCode(IdpResponseCode.OK);

                    SendRequest(address, source, outgoing);

                    return(IdpResponseCode.Deferred);
                }
                else
                {
                    node.Address = UnassignedAddress;

                    outgoing.Write(false);

                    return(IdpResponseCode.InvalidParameters);
                }
            }
            else
            {
                outgoing.Write(false);
            }

            return(IdpResponseCode.OK);
        }
示例#2
0
        private IdpResponseCode OnEnumerateAdaptorCommand(UInt16 source, UInt16 address, UInt32 transactionId, OutgoingTransaction outgoing)
        {
            var adaptor = GetNextUnenumeratedAdaptor();

            if (adaptor == null)
            {
                outgoing.Write(false);

                return(IdpResponseCode.OK);
            }
            else
            {
                adaptor.IsRenumerated = true;

                bool adaptorProbed = false;

                if (!adaptor.IsEnumerated)
                {
                    var request = new OutgoingTransaction((UInt16)NodeCommand.RouterDetect, transactionId, IdpCommandFlags.None).Write(address);

                    adaptorProbed = SendRequest(adaptor, source, 0xFFFF, request);

                    if (adaptorProbed)
                    {
                        _currentlyEnumeratingAdaptor = adaptor;
                    }
                }

                outgoing.Write(true).Write(adaptorProbed).WithResponseCode(IdpResponseCode.OK);

                SendRequest(source, outgoing);

                return(IdpResponseCode.Deferred);
            }
        }
示例#3
0
        public IdpPacket ProcessPayload(UInt16 nodeAddress, IdpPacket packet)
        {
            var incoming = new IncomingTransaction(packet);
            var outgoing = new OutgoingTransaction(0xA000, incoming.TransactionId, IdpCommandFlags.None);

            if (_commandHandlers.ContainsKey(incoming.CommandId))
            {
                outgoing.Write((byte)IdpResponseCode.OK);
                outgoing.Write(incoming.CommandId);

                var responseCode = _commandHandlers[incoming.CommandId](incoming, outgoing);

                if (incoming.Flags.HasFlag(IdpCommandFlags.ResponseExpected))
                {
                    outgoing.WithResponseCode(responseCode);

                    return(outgoing.ToPacket(nodeAddress, packet.Source));
                }
            }
            else
            {
                outgoing.Write((byte)IdpResponseCode.UnknownCommand);
                outgoing.Write(incoming.CommandId);

                return(outgoing.ToPacket(nodeAddress, packet.Source));
            }

            return(null);
        }