예제 #1
0
        myTreeNode findTreeNodeDevice(BACnetManager bnm, BACnetPacket pkt)
        {
            // Remember, a device is defined by a Network Number and a MAC address. Nothing else!

            for (int i = 0; i < this.TreeViewOnUI.Nodes.Count; i++)
            {
                myTreeNode tnNetwork = (myTreeNode)this.TreeViewOnUI.Nodes[i];

                if (tnNetwork.networkNumber == pkt.srcDevice.adr.networkNumber)
                {
                    // found Network.. now check if node exists

                    for (int j = 0; j < tnNetwork.Nodes.Count; j++)
                    {
                        myTreeNode tnDevice = (myTreeNode)tnNetwork.Nodes[j];

                        if (tnDevice != null && tnDevice.device != null && tnDevice.device.Equals(pkt.srcDevice))
                        {
                            // found
                            tnDevice.lastHeardFromTime = _apm._stopWatch.ElapsedMilliseconds;
                            return(tnDevice);
                        }
                    }
                }
            }
            return(null);
        }
예제 #2
0
        // Returns reference to a network node, creating one if necessary

        myTreeNode EstablishTreeNodeNet(BACnetManager bnm, BACnetPacket pkt)
        {
            // return reference if it is found.

            for (int i = 0; i < this.TreeViewOnUI.Nodes.Count; i++)
            {
                myTreeNode tnNetwork = (myTreeNode)this.TreeViewOnUI.Nodes[i];

                if (tnNetwork.networkNumber == pkt.srcDevice.adr.networkNumber)
                {
                    tnNetwork.lastHeardFromTime = _apm._stopWatch.ElapsedMilliseconds;
                    return(tnNetwork);
                }
            }

            // not found, so create it

            myTreeNode newNode = new myTreeNode();

            if (pkt.srcDevice.adr.directlyConnected == true)
            {
                newNode.Text = "Directly Connected Network ( " + pkt.srcDevice.adr.networkNumber + " )";
            }
            else
            {
                newNode.Text = "Network " + pkt.srcDevice.adr.networkNumber;
            }

            newNode.networkNumber     = pkt.srcDevice.adr.networkNumber;
            newNode.lastHeardFromTime = _apm._stopWatch.ElapsedMilliseconds;

            this.TreeViewOnUI.Nodes.Add(newNode);
            return(newNode);
        }
예제 #3
0
        // Returns reference to device node, creating one if necessary.

        myTreeNode EstablishTreeNodeDevice(BACnetManager bnm, BACnetPacket pkt)
        {
            // does one exist?
            myTreeNode mtnd = findTreeNodeDevice(bnm, pkt);

            if (mtnd != null)
            {
                return(mtnd);
            }

            // no, time to create it

            // establish the network

            myTreeNode mtnn = EstablishTreeNodeNet(bnm, pkt);

            myTreeNode newNode = new myTreeNode();

            newNode.Text = "Device " + pkt.srcDevice.deviceObjectID.objectInstance;

            newNode.device.adr = pkt.srcDevice.adr;

            newNode.AddMyTreeNodeObject(myTreeNode.TREENODE_OBJ_TYPE.LastAccessTime, "Seconds since msg 0");

            newNode.lastHeardFromTime = _apm._stopWatch.ElapsedMilliseconds;

            mtnn.Nodes.Add(newNode);

            // todo, add a few other parameters.

            mtnn.Expand();

            return(newNode);
        }
예제 #4
0
        // Returns reference to device node, creating one if necessary.

        myTreeNode EstablishTreeNodeDevice(BACnetManager bnm, BACnetPacket pkt)
        {
            // does one exist?
            myTreeNode mtnd = findTreeNodeDevice(bnm, pkt);

            if (mtnd != null)
            {
                return(mtnd);
            }

            // no, time to create it

            // establish the network

            myTreeNode mtnn = EstablishTreeNodeNet(bnm, pkt);

            myTreeNode newNode = new myTreeNode();

            // If this is an I-Am-Router-To-Network message, then there is no deviceObject...
            if (pkt.messageType == BACnetPacket.MESSAGE_TYPE.NETWORK_LAYER)
            {
                if (pkt.npdu.function == BACnetEnums.BACNET_NETWORK_MESSAGE_TYPE.NETWORK_MESSAGE_I_AM_ROUTER_TO_NETWORK ||
                    pkt.npdu.function == BACnetEnums.BACNET_NETWORK_MESSAGE_TYPE.NETWORK_MESSAGE_INIT_RT_TABLE_ACK)
                {
                    // ignore
                    newNode.Text        = "Router";
                    newNode.device.type = BACnetEnums.DEVICE_TYPE.Router;
                    newNode.UpdatemyTreeNodeLeaf(myTreeNode.TREENODE_OBJ_TYPE.DeviceInstance, "");
                    newNode.UpdatemyTreeNodeLeaf(myTreeNode.TREENODE_OBJ_TYPE.MACaddress, "");
                    newNode.UpdatemyTreeNodeLeaf(myTreeNode.TREENODE_OBJ_TYPE.VendorID, "");
                }
                else
                {
                    _apm.MessageTodo("m0140 - What other NPDU only messages could we receive that would want us to create a device?");
                }
            }
            else
            {
                newNode.Text = "Device " + pkt.srcDevice.deviceObjectID.objectInstance;
            }

            newNode.device.adr = pkt.srcDevice.adr;
            //newNode.AddMyTreeNodeObject(myTreeNode.TREENODE_OBJ_TYPE.LastAccessTime, "Seconds since msg 0");

            newNode.lastHeardFromTime = _apm._stopWatch.ElapsedMilliseconds;

            mtnn.Nodes.Add(newNode);

            // todo, add a few other parameters.

            newNode.UpdatemyTreeNodeLeaf(myTreeNode.TREENODE_OBJ_TYPE.BACnetADR, pkt.srcDevice.adr.ToString());


            mtnn.Expand();

            return(newNode);
        }
예제 #5
0
        private static void SendOffPacket(AppManager apm, BACnetPacket pkt, byte[] outbuf, int optr)
        {
            // store NPDU length.

            InsertUint16(outbuf, ref pkt.npduLengthOffset, (uint)optr);

            apm.bnm.bacnet_listen_socket.SendTo(outbuf, optr, SocketFlags.None, pkt.directlyConnectedIPEndPointOfDevice);

            PacketLog pktlog = new PacketLog(true, pkt);

            apm.bnm.BACnetMessageLog.Enqueue(pktlog);
        }
예제 #6
0
        private static void RespondReadPropertyWithUint(AppManager apm, BACnetPacket bacpkt, BACnetPacket outpkt, byte[] outbuf, uint val)
        {
            int optr;

            // supply the first (and only) (device) object
            optr = InsertReadPropertyResponse(apm, bacpkt, outpkt, outbuf, bacpkt.propertyID);
            // Device Object ID
            InsertContextOpeningTag(outbuf, ref optr, 3);
            InsertApplicationTag(outbuf, ref optr, BACnetEnums.BACNET_APPLICATION_TAG.BACNET_APPLICATION_TAG_UNSIGNED_INT, val);
            InsertContextClosingTag(outbuf, ref optr, 3);
            // Send it off
            SendOffPacket(apm, bacpkt, outbuf, optr);
        }
예제 #7
0
        private static void RespondReadPropertyWithString(AppManager apm, BACnetPacket bacpkt, BACnetPacket outpkt, byte[] outbuf, string resp)
        {
            int optr;

            // supply the first (and only) (device) object
            optr = InsertReadPropertyResponse(apm, bacpkt, outpkt, outbuf, bacpkt.propertyID);
            // Device Object ID
            InsertContextOpeningTag(outbuf, ref optr, 3);
            InsertApplicationTagString(outbuf, ref optr, resp);
            InsertContextClosingTag(outbuf, ref optr, 3);
            // Send it off
            SendOffPacket(apm, outpkt, outbuf, optr);
        }
예제 #8
0
        public void ServerApplication()
        {
            while (true)
            {
                // check to see if we have any live Incoming messages..

                while (_apm.pktQueueToApplication.Count > 0)
                {
                    try
                    {
                        // process the incoming queue

                        BACnetPacket bacpkt = _apm.pktQueueToApplication.Dequeue();

                        if (bacpkt.npdu.isNPDUmessage)
                        {
                            switch (bacpkt.npdu.function)
                            {
                            case BACnetEnums.BACNET_NETWORK_MESSAGE_TYPE.NETWORK_MESSAGE_I_AM_ROUTER_TO_NETWORK:
                                // find the site, establish the device, make sure that it is marked as a router, save the information
                                _apm.MessageTodo("I am router received");
                                break;

                            case BACnetEnums.BACNET_NETWORK_MESSAGE_TYPE.NETWORK_MESSAGE_INIT_RT_TABLE_ACK:
                                // find the site, establish the device, make sure that it is marked as a router, save the information
                                _apm.MessageTodo("Init rt table ack received");
                                break;

                            case BACnetEnums.BACNET_NETWORK_MESSAGE_TYPE.NETWORK_MESSAGE_WHO_IS_ROUTER_TO_NETWORK:
                                _apm.MessageTodo("m0053 - ----- Implementing  " + bacpkt.npdu.function.ToString());
                                break;
                            }
                        }
                        else
                        {
                            // todo - a certain amount of redundancy exists below, resolve.
                            BACnetLibraryCL.RespondToAPDU(_apm, _bnm, bacpkt);
                        }
                    }
                    catch (Exception ex)
                    {
                        _apm.MessagePanic("m0052 - Router application layer fault" + ex.ToString());
                    }
                }

                System.Threading.Thread.Sleep(10);
            }
        }
예제 #9
0
        // Build the 'header' part of the BACnet Packet
        private static int InsertReadPropertyResponse(AppManager apm, BACnetPacket requestBACpkt, BACnetPacket responseCRP, byte[] outbuf, BACnetEnums.BACNET_PROPERTY_ID pID)
        {
            int optr;

            optr = responseCRP.apdu_offset;

            // build APDU to provide services supported.

            responseCRP.EncodeNPDU(outbuf, ref optr);

            BACnetLibraryCL.InsertPDU(outbuf, ref optr, BACnetEnums.BACNET_PDU_TYPE.PDU_TYPE_COMPLEX_ACK, requestBACpkt.invokeID, requestBACpkt.confirmedServiceChoice);

            requestBACpkt.objectID.EncodeContextTag(outbuf, ref optr, 0);

            BACnetLibraryCL.InsertContextTag(outbuf, ref optr, 1, (int)pID);

            return(optr);
        }
예제 #10
0
        public bool detect_echo_packet(BACnetManager bnm, BACnetPacket packet)
        {
            foreach (IPAddress ipa in bnm.OurIPAddressList)
            {
                if (packet.directlyConnectedIPEndPointOfDevice.Address.Equals(ipa))
                {
                    // when the sent IP address matches one of ours, check the contents of the packet against the packets stored in the outbound copy queue

                    //    // remove all expired packets
                    //    foreach (BACnetPacket pkt in outgoing_buffer_copy_queue)
                    //    {
                    //        if (pkt.timestamp + 5000 < bnm._stopWatch.ElapsedMilliseconds)
                    //        {
                    //            // drop it
                    //            outgoing_buffer_copy_queue.Remove(pkt);
                    //            // and quit from this loop, since foreach may fail...
                    //            // todo, find a better way to remove all > 5000 ms items
                    //            break;
                    //        }
                    //    }

                    //    if (outgoing_buffer_copy_queue.Count > 100)
                    //    {
                    //        // time to panic
                    //        // todo Console.WriteLine("Outbound copy queue overflow");
                    //        outgoing_buffer_copy_queue.Clear();
                    //        return false;
                    //    }

                    //    if (outgoing_buffer_copy_queue.Contains(packet))
                    //    {
                    //        // Console.WriteLine("This message is from ourselves");

                    //        // inform that the packet was a match
                    //        return true;
                    //    }
                    //}

                    // todo - drop a warning...
                    return(true);
                }
            }
            return(false);
        }
예제 #11
0
 public PacketLog(bool sending, BACnetPacket packet)
 {
     this.sending      = sending;
     this.BACnetPacket = packet;
 }
예제 #12
0
        public void UpdateDeviceTreeView(BACnetManager bnm, BACnetPacket pkt)
        {
            if (!pkt.apdu_present)
            {
                // means that this packet must be a NPDU message. Treat it differently

                switch (pkt.npdu.function)
                {
                case BACnetEnums.BACNET_NETWORK_MESSAGE_TYPE.NETWORK_MESSAGE_I_AM_ROUTER_TO_NETWORK:
                case BACnetEnums.BACNET_NETWORK_MESSAGE_TYPE.NETWORK_MESSAGE_INIT_RT_TABLE_ACK:

                    // means we had a response from a router - establish the router in our tree.
                    myTreeNode mtnd = EstablishTreeNodeDevice(bnm, pkt);

                    if (mtnd != null)
                    {
                        // found, or established, the treenode matching the device,
                        // now add the objects to it.

                        // update the type of device - we now know it is a router (even if we did not know before).
                        if (mtnd.device != null)
                        {
                            if (mtnd.device.GetType() == typeof(Device))
                            {
                                // it is still a simple device type, upgrade it
                                _apm.MessageConfigChange(String.Format("m0139 - Device changing from a {0} to a Router", mtnd.Text));
                                //if (mtnd.router == null) mtnd.router = new Router(mtnd.device);
                                //mtnd.device = null;
                                mtnd.device = new Router(mtnd.device);
                                mtnd.type   = myTreeNode.TREENODE_OBJ_TYPE.Router;
                                mtnd.Text   = "Router";
                            }
                        }

                        ((Router)mtnd.device).AddRoutingTableEntries(pkt.routerTableList);

                        // now go through the Router's routing table and display each entry appropriately

                        foreach (RoutingTableEntry rte in ((Router)mtnd.device).routingTableEntries)
                        {
                            bool found = false;

                            for (int i = 0; i < mtnd.Nodes.Count; i++)
                            {
                                if (mtnd.Nodes[i].GetType() == typeof(myTreeNode))
                                {
                                    myTreeNode mtnObj = (myTreeNode)mtnd.Nodes[i];
                                    if (mtnObj.type == myTreeNode.TREENODE_OBJ_TYPE.RouterTableEntry && mtnObj.rte.networkNumber == rte.networkNumber)
                                    {
                                        // if we get here, the object already exists in the display list and we must not add it again.
                                        // but let us check farSide flag for consistency
                                        if (mtnObj.rte.farSide != true)
                                        {
                                            _apm.MessageTodo("m0143-Farside error");
                                        }
                                        mtnObj.rte.farSide = true;
                                        found = true;
                                        // Redo the text, something (like portID) may have been updated
                                        mtnObj.Text = rte.ToString();
                                        break;
                                    }
                                }
                            }

                            if (!found)
                            {
                                // not found, so add
                                myTreeNode ntn = mtnd.AddMyTreeNodeObject(myTreeNode.TREENODE_OBJ_TYPE.RouterTableEntry, rte.ToString());
                                ntn.rte         = rte;
                                ntn.ToolTipText = "Do not right click on this item, it has no effect";
                                mtnd.Expand();
                            }
                        }
                    }
                    mtnd.Expand();
                    break;

                    //case BACnetEnums.BACNET_NETWORK_MESSAGE_TYPE.NETWORK_MESSAGE_INIT_RT_TABLE_ACK:

                    //    myTreeNode mtnrt = EstablishTreeNodeDevice(bnm, pkt);

                    //    if (mtnrt != null)
                    //    {
                    //        // found, or established, the treenode matching the device,
                    //        // now add the objects to it.
                    //        // update the type of device - we now know it is a router (even if we did not know before).

                    //        mtnrt.device.type = BACnetEnums.DEVICE_TYPE.Router;
                    //        mtnrt.Text = "Router";

                    //        foreach (RoutingTableEntry rp in pkt.routerPortList)
                    //        {
                    //            bool found = false;

                    //            for (int i = 0; i < mtnrt.Nodes.Count; i++)
                    //            {
                    //                if (mtnrt.Nodes[i].GetType() == typeof(myTreeNode))
                    //                {
                    //                    myTreeNode mtnObj = (myTreeNode)mtnrt.Nodes[i];
                    //                    if (mtnObj.type == myTreeNode.TREENODE_OBJ_TYPE.RouterPort && mtnObj.rp.networkNumber == rp.networkNumber)
                    //                    {
                    //                        // if we get here, the object already exists in the list and we must not add it again.
                    //                        found = true;
                    //                        // farside nearside stuff mtnObj.networkNumberFromInitRouterTable = true;

                    //                        // Let us update it though, may be new information
                    //                        // mtnObj.Text = rp.ToString() ;
                    //                        break;
                    //                    }
                    //                }
                    //            }

                    //            if (!found)
                    //            {
                    //                //// not found, so add
                    //                myTreeNode ntn = mtnrt.AddMyTreeNodeObject(myTreeNode.TREENODE_OBJ_TYPE.RouterPort, rp.ToString());
                    //                ntn.rp = rp;
                    //                // nearside farside stuff ntn.networkNumberFromInitRouterTable = true;
                    //                // ntn.ToolTipText = "Do not right click on this item, it has no effect";
                    //                mtnrt.Expand();
                    //            }
                    //        }
                    //    }
                    //    break;
                }
                return;
            }
            else
            {
                // If we reach here, means APDU is present

                switch (pkt.pduType)
                {
                case BACnetEnums.BACNET_PDU_TYPE.PDU_TYPE_UNCONFIRMED_SERVICE_REQUEST:
                    switch (pkt.unconfirmedServiceChoice)
                    {
                    case BACnetEnums.BACNET_UNCONFIRMED_SERVICE.SERVICE_UNCONFIRMED_I_AM:
                        pkt.srcDevice.directlyConnectedIPEndPointOfDevice = pkt.directlyConnectedIPEndPointOfDevice;          // was fromBIP

                        // todo, not sure where I use this - check
                        // bnm.deviceList.Add(pkt.srcDevice);

                        AddDeviceToTreeNode(bnm, pkt);
                        // bnm.newPacketQueue.myEnqueue(packet);
                        break;

                    case BACnetEnums.BACNET_UNCONFIRMED_SERVICE.SERVICE_UNCONFIRMED_WHO_IS:
                        // ignore reflected who-is messages
                        break;

                    default:
                        throw new Exception("m0178-Todo");
                    }
                    break;

                case BACnetEnums.BACNET_PDU_TYPE.PDU_TYPE_COMPLEX_ACK:
                    switch (pkt.confirmedServiceChoice)
                    {
                    case BACnetEnums.BACNET_CONFIRMED_SERVICE.SERVICE_CONFIRMED_READ_PROPERTY:
                        myTreeNode mtn;
                        switch (pkt.propertyID)
                        {
                        case BACnetEnums.BACNET_PROPERTY_ID.PROP_OBJECT_LIST:
                            // what we need to do here is list the objects on the treeview...
                            // first find the device in the tree
                            mtn = findTreeNodeDevice(bnm, pkt);

                            // add the objects to it
                            if (mtn != null)
                            {
                                // found the treenode matching the device, add the objects to it.

                                foreach (BACnetObjectIdentifier bno in pkt.objectList)
                                {
                                    // does it exist? if so, ignore
                                    if (findTreeNodeObject(mtn, bno) == null)
                                    {
                                        // not found, so add
                                        myTreeNode ntn = new myTreeNode();
                                        ntn.oID         = bno;
                                        ntn.type        = myTreeNode.TREENODE_OBJ_TYPE.BACnetObject;
                                        ntn.Text        = bno.objectType.ToString() + "   Instance: " + bno.objectInstance.ToString();
                                        ntn.ToolTipText = "Right-click to read more data";
                                        mtn.Nodes.Add(ntn);
                                    }
                                }
                            }

                            break;

                        case BACnetEnums.BACNET_PROPERTY_ID.PROP_OBJECT_TYPE:
                            // these properties are of academic interest only. We already have this data from the object list.
                            _apm.MessageTodo("m0080 - Perhaps we need to confirm we have the object on our list already and panic if not");
                            break;

                        case BACnetEnums.BACNET_PROPERTY_ID.PROP_OBJECT_NAME:

                            // Leave these for when we implement stuff on the Browser.

                            // find the device, then the object, then append the name.
                            //mtn = findTreeNodeDevice(bnm, pkt);
                            //myTreeNode mtn2 = findTreeNodeObject(mtn, pkt.objectID);
                            //if (mtn2 == null)
                            //{
                            //    _apm.MessageTodo("m0081 - this is a surprise");
                            //}
                            //else
                            //{
                            //    mtn2.AddMyTreeNodeObject(myTreeNode.TREENODE_OBJ_TYPE.GenericText, "Name");
                            //}
                            break;

                        default:
                            mtn = findTreeNodeDevice(bnm, pkt);
                            if (mtn != null)
                            {
                                // for now, just add the object.
                                // _apm.MessageTodo("m0524");
                                //myTreeNode ntn = new myTreeNode();
                                //ntn.type = myTreeNode.TREENODE_OBJ_TYPE.BACnetObject;
                                //ntn.Text = pkt.propertyID.ToString();
                                //ntn.ToolTipText = "Do not right click on this item, it has no effect";
                                //mtn.Nodes.Add(ntn);
                            }
                            break;
                        }
                        break;

                    default:
                        throw new Exception("m0179-Todo");
                    }
                    break;

                case BACnetEnums.BACNET_PDU_TYPE.PDU_TYPE_CONFIRMED_SERVICE_REQUEST:
                case BACnetEnums.BACNET_PDU_TYPE.PDU_TYPE_REJECT:
                case BACnetEnums.BACNET_PDU_TYPE.PDU_TYPE_ERROR:
                    // These messages do not affect the Device TreeView, so we will ignore them..
                    break;

                default:
                    _apm.MessageTodo("m0027 - Device Treeview needs to parse this message still: " + pkt.pduType.ToString());
                    break;
                }
            }
        }
예제 #13
0
        void AddDeviceToTreeNode(BACnetManager bnm, BACnetPacket pkt)
        {
            // find the network display node, or else add a new one

            myTreeNode tni = EstablishTreeNodeNet(bnm, pkt);
            // found Network..
            // check if node already exists

            bool founddeviceflag = false;

            for (int j = 0; j < tni.Nodes.Count; j++)
            {
                myTreeNode tnj = (myTreeNode)tni.Nodes[j];

                if (tnj != null && tnj.device.Equals(pkt.srcDevice))
                {
                    // found, so quit
                    tnj.lastHeardFromTime = _apm._stopWatch.ElapsedMilliseconds;
                    founddeviceflag       = true;
                    tnj.device            = pkt.srcDevice;

                    // right here we can update some parameters... (eg. update i-am details from a router...) todonow

//                    newNode.UpdatemyTreeNodeLeaf(myTreeNode.TREENODE_OBJ_TYPE.BACnetADR, pkt.srcDevice.adr.ToString());
                    tnj.UpdatemyTreeNodeLeaf(myTreeNode.TREENODE_OBJ_TYPE.DeviceInstance, pkt.srcDevice.deviceObjectID.objectInstance.ToString());
                    tnj.UpdatemyTreeNodeLeaf(myTreeNode.TREENODE_OBJ_TYPE.MACaddress, pkt.srcDevice.adr.MACaddress.ToString());
                    tnj.UpdatemyTreeNodeLeaf(myTreeNode.TREENODE_OBJ_TYPE.VendorID, pkt.srcDevice.vendorID.ToString());
                    tnj.Expand();
                    break;
                }
            }

            // add a device node to the network node

            if (founddeviceflag == false)
            {
                myTreeNode newNode = new myTreeNode();

                newNode.device = pkt.srcDevice;
                newNode.type   = myTreeNode.TREENODE_OBJ_TYPE.Device;

                newNode.Name = "NewNode";

                // todonetxt - add back devicetype
                //NewNode.Text = "Device " + devUpdate.deviceObjectID.objectInstance + " " + devUpdate.deviceType.ToString();
                newNode.Text        = "Device ";
                newNode.ToolTipText = "Right Click on Device Objects for further functionality";

                newNode.UpdatemyTreeNodeLeaf(myTreeNode.TREENODE_OBJ_TYPE.DeviceInstance, pkt.srcDevice.deviceObjectID.objectInstance.ToString());
                newNode.UpdatemyTreeNodeLeaf(myTreeNode.TREENODE_OBJ_TYPE.MACaddress, pkt.srcDevice.adr.MACaddress.ToString());
                newNode.UpdatemyTreeNodeLeaf(myTreeNode.TREENODE_OBJ_TYPE.VendorID, pkt.srcDevice.vendorID.ToString());

                newNode.Tag = pkt.srcDevice.deviceObjectID.objectInstance;

                // add other paramters to our new node

                newNode.lastHeardFromTime = _apm._stopWatch.ElapsedMilliseconds;

                // todo, need to fix this, since we are adding TreeNodes here, not myTreeNodes...

                // newNode.AddMyTreeNodeObject(myTreeNode.TREENODE_OBJ_TYPE.LastAccessTime, "Seconds since msg 0");
                // newNode.Nodes.Add("Seconds since msg 0");

                if (pkt.srcDevice.adr.directlyConnected != true)
                {
                    newNode.AddMyTreeNodeObject(myTreeNode.TREENODE_OBJ_TYPE.GenericText, "Router IP Addr    " + pkt.srcDevice.directlyConnectedIPEndPointOfDevice);
                }

                newNode.AddMyTreeNodeObject(myTreeNode.TREENODE_OBJ_TYPE.BACnetADR, "BACnet ADR        " + pkt.srcDevice.adr.ToString());

                newNode.AddMyTreeNodeObject(myTreeNode.TREENODE_OBJ_TYPE.GenericText, "Segmentation      " + (int)pkt.srcDevice.SegmentationSupported);

                // migrated away NewNode.isDevice = true;

                newNode.Expand();
                tni.Nodes.Add(newNode);

//                tni.ExpandAll();
                tni.Expand();
            }
        }
예제 #14
0
        public static void RespondToAPDU(AppManager apm, BACnetManager bnm, BACnetPacket incomingPacket)
        {
            byte[]    outbuf = new byte[2000];
            int       optr;
            PacketLog pktlog;

            BACnetPacket outgoingBACpacket = new BACnetPacket(apm, bnm);

            // fill in some CRP parameters for packet log display
            outgoingBACpacket.confirmedServiceChoice       = incomingPacket.confirmedServiceChoice;
            outgoingBACpacket.apduConfirmedServiceTypeFlag = incomingPacket.apduConfirmedServiceTypeFlag;
            outgoingBACpacket.propertyID = incomingPacket.propertyID;
            outgoingBACpacket.apduUnconfirmedServiceFlag = incomingPacket.apduUnconfirmedServiceFlag;
            outgoingBACpacket.pduType = incomingPacket.pduType;
            outgoingBACpacket.unconfirmedServiceChoice            = incomingPacket.unconfirmedServiceChoice;
            outgoingBACpacket.directlyConnectedIPEndPointOfDevice = incomingPacket.directlyConnectedIPEndPointOfDevice;

            BACnetPacket incomingBACpacket = (BACnetPacket)incomingPacket;

            if (incomingBACpacket.apduConfirmedServiceTypeFlag == true)
            {
                switch (incomingBACpacket.confirmedServiceChoice)
                {
                case BACnetEnums.BACNET_CONFIRMED_SERVICE.SERVICE_CONFIRMED_READ_PROPERTY:

                    switch (incomingBACpacket.propertyID)
                    {
                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_OBJECT_NAME:
                        // supply the first (and only) (device) object
                        optr = InsertReadPropertyResponse(apm, incomingBACpacket, outgoingBACpacket, outbuf, incomingBACpacket.propertyID);
                        // Device Object ID
                        InsertContextOpeningTag(outbuf, ref optr, 3);
                        InsertApplicationTagString(outbuf, ref optr, apm.ourDeviceName);
                        InsertContextClosingTag(outbuf, ref optr, 3);
                        // Send it off
                        SendOffPacket(apm, outgoingBACpacket, outbuf, optr);
                        break;

                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_PROTOCOL_OBJECT_TYPES_SUPPORTED:
                        optr = InsertReadPropertyResponse(apm, incomingBACpacket, outgoingBACpacket, outbuf, incomingBACpacket.propertyID);
                        BACnetLibraryCL.InsertContextOpeningTag(outbuf, ref optr, 3);

                        // hardcode the bitstring until we see where else it can be used, then generalized.

                        outbuf[optr++] = 0x83;          // Assume length = 3, including unused bits byte
                        // outbuf[optr++] = 0x03;
                        outbuf[optr++] = 0x06;          // trailing bits not used

                        InsertBitString(outbuf, optr, 2, (int)BACnetEnums.BACNET_OBJECT_TYPE.OBJECT_DEVICE);
                        optr += 2;

                        BACnetLibraryCL.InsertContextClosingTag(outbuf, ref optr, 3);

                        SendOffPacket(apm, outgoingBACpacket, outbuf, optr);
                        break;

                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_PROTOCOL_SERVICES_SUPPORTED:

                        optr = InsertReadPropertyResponse(apm, incomingBACpacket, outgoingBACpacket, outbuf, incomingBACpacket.propertyID);

                        BACnetLibraryCL.InsertContextOpeningTag(outbuf, ref optr, 3);


                        //List<BACnetEnums.BACNET_SERVICES_SUPPORTED> servicesList = new List<BACnetEnums.BACNET_SERVICES_SUPPORTED>();

                        //servicesList.Add(BACnetEnums.BACNET_SERVICES_SUPPORTED.SERVICE_SUPPORTED_READ_PROPERTY);
                        //// servicesList.Add(BACnetEnums.BACNET_SERVICES_SUPPORTED.SERVICE_SUPPORTED_WRITE_PROPERTY);
                        //servicesList.Add(BACnetEnums.BACNET_SERVICES_SUPPORTED.SERVICE_SUPPORTED_DEVICE_COMMUNICATION_CONTROL);
                        ////servicesList.Add(BACnetEnums.BACNET_SERVICES_SUPPORTED.SERVICE_SUPPORTED_REINITIALIZE_DEVICE);
                        //servicesList.Add(BACnetEnums.BACNET_SERVICES_SUPPORTED.SERVICE_SUPPORTED_TIME_SYNCHRONIZATION);
                        //servicesList.Add(BACnetEnums.BACNET_SERVICES_SUPPORTED.SERVICE_SUPPORTED_WHO_IS);
                        //// todo, what about i-am ?
                        //BACnetLibraryCL.InsertApplicationTagString(outbuf, ref optr, servicesList );

                        // hardcode the bitstring until we see where else it can be used, then generalized.

                        outbuf[optr++] = 0x85;          // Assume length = 6
                        outbuf[optr++] = 0x06;          // Length, including the next byte
                        outbuf[optr++] = 0x05;          // 5 trailing bits not used

                        InsertBitString(outbuf, optr, 5, (int)BACnetEnums.BACNET_SERVICES_SUPPORTED.SERVICE_SUPPORTED_READ_PROPERTY);
                        InsertBitString(outbuf, optr, 5, (int)BACnetEnums.BACNET_SERVICES_SUPPORTED.SERVICE_SUPPORTED_DEVICE_COMMUNICATION_CONTROL);
                        InsertBitString(outbuf, optr, 5, (int)BACnetEnums.BACNET_SERVICES_SUPPORTED.SERVICE_SUPPORTED_TIME_SYNCHRONIZATION);
                        InsertBitString(outbuf, optr, 5, (int)BACnetEnums.BACNET_SERVICES_SUPPORTED.SERVICE_SUPPORTED_WHO_IS);

                        InsertBitString(outbuf, optr, 5, (int)BACnetEnums.BACNET_SERVICES_SUPPORTED.SERVICE_SUPPORTED_WRITE_PROPERTY);
                        InsertBitString(outbuf, optr, 5, (int)BACnetEnums.BACNET_SERVICES_SUPPORTED.SERVICE_SUPPORTED_REINITIALIZE_DEVICE);

                        optr += 5;

                        BACnetLibraryCL.InsertContextClosingTag(outbuf, ref optr, 3);

                        SendOffPacket(apm, outgoingBACpacket, outbuf, optr);
                        break;

                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_OBJECT_LIST:
                        // Only respond if array index specified
                        if (!incomingPacket.arrayIndexDecoded)
                        {
                            throw new Exception("m0058 - Not expecting open object list");
                        }

                        if (incomingPacket.arrayIndex == 0)
                        {
                            optr = InsertReadPropertyResponse(apm, incomingBACpacket, outgoingBACpacket, outbuf, incomingBACpacket.propertyID);

                            // arrayIndex 0
                            InsertContextTag(outbuf, ref optr, 2, 0);

                            // Object count
                            InsertContextOpeningTag(outbuf, ref optr, 3);
                            InsertApplicationTag(outbuf, ref optr, BACnetEnums.BACNET_APPLICATION_TAG.BACNET_APPLICATION_TAG_UNSIGNED_INT, 1);
                            InsertContextClosingTag(outbuf, ref optr, 3);

                            // Send it off
                            SendOffPacket(apm, outgoingBACpacket, outbuf, optr);
                            break;

                            // supply the number of objects
                        }
                        else if (incomingPacket.arrayIndex == 1)
                        {
                            // supply the first (and only) (device) object
                            optr = InsertReadPropertyResponse(apm, incomingBACpacket, outgoingBACpacket, outbuf, incomingBACpacket.propertyID);

                            // arrayIndex 1
                            InsertContextTag(outbuf, ref optr, 2, 1);

                            // Device Object ID
                            InsertContextOpeningTag(outbuf, ref optr, 3);
                            incomingPacket.objectID.EncodeApplicationTag(outbuf, ref optr);
                            InsertContextClosingTag(outbuf, ref optr, 3);

                            // Send it off
                            SendOffPacket(apm, outgoingBACpacket, outbuf, optr);
                        }
                        else
                        {
                            throw new Exception("m0059 - Illegal object list index");
                        }
                        break;

                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_OBJECT_TYPE:
                        // supply the first (and only) (device) object
                        optr = InsertReadPropertyResponse(apm, incomingBACpacket, outgoingBACpacket, outbuf, incomingBACpacket.propertyID);
                        // Device Object ID
                        InsertContextOpeningTag(outbuf, ref optr, 3);
                        InsertApplicationTag(outbuf, ref optr, BACnetEnums.BACNET_APPLICATION_TAG.BACNET_APPLICATION_TAG_ENUMERATED, (uint)BACnetEnums.BACNET_OBJECT_TYPE.OBJECT_DEVICE);
                        InsertContextClosingTag(outbuf, ref optr, 3);
                        // Send it off
                        SendOffPacket(apm, outgoingBACpacket, outbuf, optr);
                        break;

                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_SYSTEM_STATUS:
                        // supply the first (and only) (device) object
                        optr = InsertReadPropertyResponse(apm, incomingBACpacket, outgoingBACpacket, outbuf, incomingBACpacket.propertyID);
                        // Device Object ID
                        InsertContextOpeningTag(outbuf, ref optr, 3);
                        InsertApplicationTag(outbuf, ref optr, BACnetEnums.BACNET_APPLICATION_TAG.BACNET_APPLICATION_TAG_ENUMERATED, (uint)BACnetEnums.BACNET_DEVICE_STATUS.STATUS_OPERATIONAL);
                        InsertContextClosingTag(outbuf, ref optr, 3);
                        // Send it off
                        SendOffPacket(apm, outgoingBACpacket, outbuf, optr);
                        break;

                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_OBJECT_IDENTIFIER:
                        // supply the first (and only) (device) object
                        optr = InsertReadPropertyResponse(apm, incomingBACpacket, outgoingBACpacket, outbuf, incomingBACpacket.propertyID);
                        // Device Object ID
                        InsertContextOpeningTag(outbuf, ref optr, 3);
                        incomingPacket.objectID.EncodeApplicationTag(outbuf, ref optr);
                        InsertContextClosingTag(outbuf, ref optr, 3);
                        // Send it off
                        SendOffPacket(apm, outgoingBACpacket, outbuf, optr);
                        break;

                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_VENDOR_NAME:
                        // supply the first (and only) (device) object
                        optr = InsertReadPropertyResponse(apm, incomingBACpacket, outgoingBACpacket, outbuf, incomingBACpacket.propertyID);
                        // Device Object ID
                        InsertContextOpeningTag(outbuf, ref optr, 3);
                        InsertApplicationTagString(outbuf, ref optr, apm.ourVendorName);
                        InsertContextClosingTag(outbuf, ref optr, 3);
                        // Send it off
                        SendOffPacket(apm, outgoingBACpacket, outbuf, optr);
                        break;

                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_MODEL_NAME:
                        // supply the first (and only) (device) object
                        optr = InsertReadPropertyResponse(apm, incomingBACpacket, outgoingBACpacket, outbuf, incomingBACpacket.propertyID);
                        // Device Object ID
                        InsertContextOpeningTag(outbuf, ref optr, 3);
                        InsertApplicationTagString(outbuf, ref optr, apm.ourModelName);
                        InsertContextClosingTag(outbuf, ref optr, 3);
                        // Send it off
                        SendOffPacket(apm, outgoingBACpacket, outbuf, optr);
                        break;

                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_FIRMWARE_REVISION:
                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_APPLICATION_SOFTWARE_VERSION:
                        RespondReadPropertyWithString(apm, incomingBACpacket, outgoingBACpacket, outbuf, apm.ourFirmwareRevision);
                        break;

                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_VENDOR_IDENTIFIER:
                        RespondReadPropertyWithUint(apm, incomingBACpacket, outgoingBACpacket, outbuf, apm.ourVendorID);
                        break;

                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_PROTOCOL_VERSION:
                        RespondReadPropertyWithUint(apm, incomingBACpacket, outgoingBACpacket, outbuf, 1);
                        break;

                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_PROTOCOL_REVISION:
                        RespondReadPropertyWithUint(apm, incomingBACpacket, outgoingBACpacket, outbuf, 4);
                        break;

                    default:
                        apm.MessageTodo("m0046 - Implement read property " + incomingBACpacket.propertyID.ToString());
                        break;
                    }
                    break;

                default:
                    apm.MessageTodo("m0044 - Implement confirmed service " + incomingBACpacket.confirmedServiceChoice.ToString());
                    break;
                }
            }

            if (incomingBACpacket.apduUnconfirmedServiceFlag == true)
            {
                switch (incomingBACpacket.pduType)
                {
                case BACnetEnums.BACNET_PDU_TYPE.PDU_TYPE_UNCONFIRMED_SERVICE_REQUEST:
                    switch (incomingBACpacket.unconfirmedServiceChoice)
                    {
                    case BACnetEnums.BACNET_UNCONFIRMED_SERVICE.SERVICE_UNCONFIRMED_WHO_IS:

                        // we need to respond

                        // ONLY if we are in the range, and if not, ignore.

                        if (incomingBACpacket.lowRange != 0 || incomingBACpacket.highRange != 0)
                        {
                            if (apm.ourDeviceId < incomingBACpacket.lowRange || apm.ourDeviceId > incomingBACpacket.highRange)
                            {
                                // This packet not for us
                                apm.MessageLog("m0034 - Ranged Who-Is not addressed to us, ignoring");
                                break;
                            }
                        }

                        // Compose the response (I-am)

                        outgoingBACpacket.BACnetPort = incomingPacket.BACnetPort;

                        outgoingBACpacket.npdu.isBroadcast = true;
                        outgoingBACpacket.hopcount         = 256;

                        // destination address of the BACnet packet. (Must either be b'cast or directlyConnectedIPEP

                        optr = 0;

                        outgoingBACpacket.npdu.isNPDUmessage       = false;   // makes it an APDU
                        outgoingBACpacket.pduType                  = BACnetEnums.BACNET_PDU_TYPE.PDU_TYPE_UNCONFIRMED_SERVICE_REQUEST;
                        outgoingBACpacket.unconfirmedServiceChoice = BACnetEnums.BACNET_UNCONFIRMED_SERVICE.SERVICE_UNCONFIRMED_I_AM;

                        outgoingBACpacket.EncodeBACnetNew(outbuf, ref optr);

                        // send the message

                        // if there is no available adapter, this try will throw
                        try
                        {
                            apm.bnm.bacnet_listen_socket.SendTo(outbuf, optr, SocketFlags.None, incomingPacket.directlyConnectedIPEndPointOfDevice);

                            pktlog = new PacketLog(true, incomingPacket.directlyConnectedIPEndPointOfDevice, outgoingBACpacket);
                            pktlog.BACnetPacket = (BACnetPacket)outgoingBACpacket;
                            apm.bnm.BACnetMessageLog.Enqueue(pktlog);
                        }
                        catch (SocketException)
                        {
                            apm.MessageTodo("Either the network cable is unplugged, or there is no configured Ethernet Port on this computer");
                        }
                        break;

                    case BACnetEnums.BACNET_UNCONFIRMED_SERVICE.SERVICE_UNCONFIRMED_I_AM:
                        break;

                    default:
                        apm.MessageTodo("Implement " + incomingBACpacket.unconfirmedServiceChoice.ToString());
                        break;
                    }
                    break;

                default:
                    apm.MessageTodo("Implement " + incomingBACpacket.pduType.ToString());
                    break;
                }
            }
        }
예제 #15
0
        // This method that will be called when the thread is started
        public void BACnetListenerMethod()
        {
            Console.WriteLine("Thread starting for port " + Convert.ToString(BACnet_port));

            while (true)
            {
                Byte[]       received          = new Byte[2000];
                BACnetPacket incomingCRPpacket = new BACnetPacket(_apm, _bnm);

                // Create an IPEndPoint to capture the identity of the sending host.
                IPEndPoint sender       = new IPEndPoint(IPAddress.Any, 0);
                EndPoint   senderRemote = (EndPoint)sender;

                try
                {
                    incomingCRPpacket.length = _bnm.bacnet_listen_socket.ReceiveFrom(received, ref senderRemote);

                    Console.WriteLine("This message was sent from " + ((IPEndPoint)senderRemote).Address.ToString() + "  Port " + ((IPEndPoint)senderRemote).Port.ToString());

                    incomingCRPpacket.directlyConnectedIPEndPointOfDevice = new myIPEndPoint(senderRemote);
                    incomingCRPpacket.buffer = received;

                    // Decode the packet
                    bool decodeOK = incomingCRPpacket.DecodeBACnet(received, incomingCRPpacket.length);

                    if (!decodeOK)
                    {
                        continue;
                    }

                    // log this data
                    PacketLog pkt = new PacketLog(false, (IPEndPoint)senderRemote, incomingCRPpacket);
                    pkt.BACnetPacket = (BACnetPacket)incomingCRPpacket;
                    _bnm.BACnetMessageLog.Enqueue(pkt);


                    // did packet Decode fail to create a device? If so, we are not interested. e.g. Who-Is.

                    if (incomingCRPpacket.srcDevice == null)
                    {
                        _apm.MessageTodo("m0039 - Device not created by packet decode");
                        continue;
                    }


                    _apm.pktQueueToApplication.Enqueue(incomingCRPpacket);
                }
                catch (SocketException)
                {
                    // we expect a socket exception when shutting down
                    System.Console.WriteLine("socket exception occurred");
                }
                catch (System.Threading.ThreadAbortException)
                {
                    System.Console.WriteLine("Thread abort exception occurred (shutting down)");
                }
                catch (Exception efe)
                {
                    // need to catch the inevitable exception when this blocking call is cancelled by the shutdown code
                    _apm.MessagePanic(efe.ToString());
                }
            }
        }
예제 #16
0
        // This method that will be called when the thread is started
        public void BACnetInsideListener()
        {
            while (true)
            {
                // Byte[] received = new Byte[2000];
                BACnetPacket packet = new BACnetPacket(_apm);

                // Create an IPEndPoint to capture the identity of the sending host.
                IPEndPoint sender       = new IPEndPoint(IPAddress.Any, 0);
                EndPoint   senderRemote = (EndPoint)sender;

                try
                {
                    // bacnet_listen_socket.Receive(received);
                    packet.length = listen_socket.ReceiveFrom(packet.buffer, ref senderRemote);

                    // Console.WriteLine("This message was sent from " + ((IPEndPoint)senderRemote).Address.ToString() + "  Port " + ((IPEndPoint)senderRemote).Port.ToString());
                    // packet.fromBIP = (IPEndPoint) senderRemote;
                    packet.directlyConnectedIPEndPointOfDevice         = new myIPEndPoint();
                    packet.directlyConnectedIPEndPointOfDevice.Port    = ((IPEndPoint)senderRemote).Port;
                    packet.directlyConnectedIPEndPointOfDevice.Address = ((IPEndPoint)senderRemote).Address;

                    // if the packet is from ourselves, discard
                    if (listen_socket.detect_echo_packet(bnm, packet) == true)
                    {
                        continue;
                    }

                    // todo - one day, we will be able to see if this packet was addressed to this host in a broadcast packet, and mark the dadr accordingly, that is, if we care.

                    // todo - remove directlyconnected
                    //packet.srcDevice.adr = new ADR ( packet.directlyConnectedIPEndPointOfDevice ) ;

                    // Make an undecoded copy of the packet for the application layer. This is to ease debugging in the asynch application layer.
                    BACnetPacket appPkt = (BACnetPacket)packet.Clone();

                    // packet.buffer = received;
                    packet.DecodeBACnet();

                    // extract some information from the packet for our caches

                    if (packet.sAdr != null)
                    {
                        lock (_apm.internalRouterInfo)
                        {
                            _apm.internalRouterInfo.AddRoutingTableEntry(packet.sAdr.networkNumber);
                        }
                    }
                    if (packet.routerTableList != null)
                    {
                        lock (_apm.internalRouterInfo)
                        {
                            foreach (RoutingTableEntry re in packet.routerTableList)
                            {
                                // surrounding this because we know of at least one router out there that has illegal network numbers
                                try
                                {
                                    _apm.internalRouterInfo.AddRoutingTableEntry(re.networkNumber);
                                }
                                catch (ProtocolException pe)
                                {
                                    pe.DumpException(_apm);
                                }
                            }
                        }
                    }


                    // display the decoded packet in the UI treeview
                    bnm.newPacketQueue.myEnqueue(packet);

                    // todo, if diagnostics are not running, then this queue will overflow.... hence the check.. find a cleaner method..
                    if (_apm.pktQueueToApplication.Count < 1000)
                    {
                        _apm.pktQueueToApplication.myEnqueue(appPkt);   // notice, this is not a copy of the packet, it is a pointer to the same packet.... kick me if there are problems one day
                    }
                }
                catch (ProtocolException pe)
                {
                    pe.DumpException(_apm);
                }
                catch (SocketException)
                {
                    // need to catch the inevitable exception when this blocking call is cancelled by the shutdown code
                    // ignore, they will happen on shutdown
                }
                catch (ThreadAbortException)
                {
                }
                catch (Exception efe)
                {
                    _apm.MessagePanic(efe.ToString());
                }
            }
        }
예제 #17
0
        public void UpdateDeviceTreeView(BACnetManager bnm, BACnetPacket pkt)
        {
            if (!pkt.apdu_present)
            {
                // means that this packet must be a NPDU message. Treat it differently

                switch (pkt.npdu.function)
                {
                case BACnetEnums.BACNET_NETWORK_MESSAGE_TYPE.NETWORK_MESSAGE_I_AM_ROUTER_TO_NETWORK:
                    //if (pkt.numberList.Count > 0)
                    //{
                    // means we had a response from a router - establish the router in our tree.
                    myTreeNode mtnd = EstablishTreeNodeDevice(bnm, pkt);

                    if (mtnd != null)
                    {
                        // found, or established, the treenode matching the device,
                        // now add the objects to it.

                        // update the type of device - we now know it is a router (even if we did not know before).

                        mtnd.device.type = BACnetEnums.DEVICE_TYPE.Router;
                        mtnd.Text        = "Router";

                        if (pkt.numberList != null)
                        {
                            foreach (int bno in pkt.numberList)
                            {
                                bool found = false;

                                for (int i = 0; i < mtnd.Nodes.Count; i++)
                                {
                                    if (mtnd.Nodes[i].GetType() == typeof(myTreeNode))
                                    {
                                        myTreeNode mtnObj = (myTreeNode)mtnd.Nodes[i];
                                        if (mtnObj.type == myTreeNode.TREENODE_OBJ_TYPE.NetworkNumber && mtnObj.networkNumber == bno)
                                        {
                                            // if we get here, the object already exists in the list and we must not add it again.
                                            mtnObj.networkNumberFromWhoIsRouter = true;
                                            found = true;
                                            break;
                                        }
                                    }
                                }

                                if (!found)
                                {
                                    //// not found, so add
                                    myTreeNode ntn = mtnd.AddMyTreeNodeObject(myTreeNode.TREENODE_OBJ_TYPE.NetworkNumber, "Network " + bno.ToString());
                                    ntn.networkNumber = (uint)bno;
                                    ntn.networkNumberFromWhoIsRouter = true;
                                    ntn.ToolTipText = "Do not right click on this item, it has no effect";
                                    mtnd.Expand();
                                }
                            }
                        }
                        else
                        {
                            _apm.MessageTodo("m0032");
                        }
                    }

                    //}
                    break;

                case BACnetEnums.BACNET_NETWORK_MESSAGE_TYPE.NETWORK_MESSAGE_INIT_RT_TABLE_ACK:

                    myTreeNode mtnrt = EstablishTreeNodeDevice(bnm, pkt);

                    if (mtnrt != null)
                    {
                        // found, or established, the treenode matching the device,
                        // now add the objects to it.
                        // update the type of device - we now know it is a router (even if we did not know before).

                        mtnrt.device.type = BACnetEnums.DEVICE_TYPE.Router;
                        mtnrt.Text        = "Router";

                        foreach (RouterPort rp in pkt.routerPortList)
                        {
                            bool found = false;

                            for (int i = 0; i < mtnrt.Nodes.Count; i++)
                            {
                                if (mtnrt.Nodes[i].GetType() == typeof(myTreeNode))
                                {
                                    myTreeNode mtnObj = (myTreeNode)mtnrt.Nodes[i];
                                    if (mtnObj.type == myTreeNode.TREENODE_OBJ_TYPE.NetworkNumber && mtnObj.networkNumber == rp.networkNumber)
                                    {
                                        // if we get here, the object already exists in the list and we must not add it again.
                                        found = true;
                                        mtnObj.networkNumberFromInitRouterTable = true;
                                        break;
                                    }
                                }
                            }

                            if (!found)
                            {
                                //// not found, so add
                                myTreeNode ntn = mtnrt.AddMyTreeNodeObject(myTreeNode.TREENODE_OBJ_TYPE.NetworkNumber, "Network " + rp.networkNumber.ToString());
                                ntn.networkNumber = rp.networkNumber;
                                ntn.networkNumberFromInitRouterTable = true;
                                // ntn.ToolTipText = "Do not right click on this item, it has no effect";
                                mtnrt.Expand();
                            }
                        }
                    }

                    break;
                }

                return;
            }

            switch (pkt.pduType)
            {
            case BACnetEnums.BACNET_PDU_TYPE.PDU_TYPE_UNCONFIRMED_SERVICE_REQUEST:
                switch (pkt.unconfirmedServiceChoice)
                {
                case BACnetEnums.BACNET_UNCONFIRMED_SERVICE.SERVICE_UNCONFIRMED_I_AM:
                    pkt.srcDevice.directlyConnectedIPEndPointOfDevice = pkt.directlyConnectedIPEndPointOfDevice;           // was fromBIP

                    // todo, not sure where I use this - check
                    bnm.deviceList.Add(pkt.srcDevice);

                    AddDeviceToTreeNode(bnm, pkt);
                    // bnm.newPacketQueue.Enqueue(packet);
                    break;

                case BACnetEnums.BACNET_UNCONFIRMED_SERVICE.SERVICE_UNCONFIRMED_WHO_IS:
                    // ignore reflected who-is messages
                    break;

                default:
                    BACnetLibraryCL.Panic("Todo");
                    break;
                }
                break;

            case BACnetEnums.BACNET_PDU_TYPE.PDU_TYPE_COMPLEX_ACK:
                switch (pkt.confirmedServiceChoice)
                {
                case BACnetEnums.BACNET_CONFIRMED_SERVICE.SERVICE_CONFIRMED_READ_PROPERTY:
                    switch (pkt.propertyID)
                    {
                    case BACnetEnums.BACNET_PROPERTY_ID.PROP_OBJECT_LIST:
                        // what we need to do here is list the objects on the treeview...

                        // find the device in the tree
                        // add the objects to it

                        myTreeNode mtn = findTreeNodeDevice(bnm, pkt);

                        if (mtn != null)
                        {
                            // found the treenode matching the device, add the objects to it.

                            if (pkt.objectList != null)
                            {
                                foreach (BACnetObjectIdentifier bno in pkt.objectList)
                                {
                                    // does it exist? if so, ignore
                                    if (findTreeNodeObject(mtn, bno) == null)
                                    {
                                        // not found, so add
                                        myTreeNode ntn = new myTreeNode();
                                        ntn.oID         = bno;
                                        ntn.type        = myTreeNode.TREENODE_OBJ_TYPE.BACnetObject;
                                        ntn.Text        = bno.objectType.ToString() + "   Instance: " + bno.objectInstance.ToString();
                                        ntn.ToolTipText = "Do not right click on this item, it has no effect";
                                        mtn.Nodes.Add(ntn);
                                    }
                                }
                            }

                            // now remove the object list??? (but it will be removed when packet is destroyed....
                        }

                        break;

                    default:
                        _apm.MessagePanic("m0030 " + pkt.propertyID.ToString());
                        break;
                    }
                    break;

                default:
                    _apm.MessagePanic("m0029");
                    break;
                }
                break;


            case BACnetEnums.BACNET_PDU_TYPE.PDU_TYPE_CONFIRMED_SERVICE_REQUEST:
            case BACnetEnums.BACNET_PDU_TYPE.PDU_TYPE_REJECT:
                // These messages do not affect the Device TreeView, so we will ignore them..
                break;

            default:
                _apm.MessageTodo("m0027 - Device Treeview needs to parse this message still: " + pkt.pduType.ToString());
                break;
            }
        }
예제 #18
0
 public PacketLog(bool sending, IPEndPoint ipep, BACnetPacket packet)
 {
     this.sending      = sending;
     this.ipep         = ipep;
     this.BACnetPacket = packet;
 }