コード例 #1
0
        private void AddItems(List <string> p_ItemIds)
        {
            int l_ItemClientHandle = 0;

            OPCItemDef[]    l_ItemDef = new OPCItemDef[p_ItemIds.Count];
            OPCItemResult[] l_AddRes;

            foreach (string l_ItemName in p_ItemIds)
            {
                l_ItemDef[l_ItemClientHandle] = new OPCItemDef(l_ItemName, false, l_ItemClientHandle, VarEnum.VT_BSTR);
                l_ItemClientHandle++;
            }

            m_Group.AddItems(l_ItemDef, out l_AddRes);

            l_ItemClientHandle = 0;
            foreach (string l_ItemName in p_ItemIds)
            {
                if (l_AddRes[l_ItemClientHandle].Error == HResults.S_OK)
                {
                    Dictionary <string, string> l_ItemProps = new Dictionary <string, string>();
                    l_ItemProps.Add(ServerModel.ITEM_PROP_ID_KEY, m_Server.GetItemID(l_ItemName));
                    l_ItemProps.Add(ServerModel.ITEM_PROP_TYPE_KEY, OPCUtility.TypeToString((int)l_AddRes[l_ItemClientHandle].CanonicalDataType));

                    m_ServerModel.AddItem(l_ItemClientHandle, l_AddRes[l_ItemClientHandle].HandleServer, l_ItemProps);
                }

                l_ItemClientHandle++;
            }
        }
コード例 #2
0
        public void WriteItems(List <string> p_ItemsId, string p_Value)
        {
            m_ItemAccessMutex.WaitOne();

            try
            {
                int l_ItemsToWriteCount = p_ItemsId.Count;

                int[]    l_ServerHandleArray = new int[l_ItemsToWriteCount];
                object[] l_ValueArray        = new object[l_ItemsToWriteCount];
                int[]    l_ErrorArray;

                for (int i = 0; i < l_ItemsToWriteCount; ++i)
                {
                    l_ServerHandleArray[i] = m_ServerModel.GetServerHandleFromItemId(p_ItemsId[i]);

                    int      l_ClientHandle = m_ServerModel.GetClientHandleFromServerHandle(l_ServerHandleArray[i]);
                    IOPCItem l_Item         = m_ServerModel.GetItemFromClientHandle(l_ClientHandle);
                    l_ValueArray[i] = OPCUtility.StringToValue(l_Item.Type, p_Value);
                }
                m_Group.Write(l_ServerHandleArray, l_ValueArray, out l_ErrorArray);

                // TODO Check the error
            }
            catch (Exception l_Ex)
            {
                throw l_Ex;
            }
            finally
            {
                m_ItemAccessMutex.ReleaseMutex();
            }
        }
コード例 #3
0
        private void Group_DataChange(object p_Sender, DataChangeEventArgs p_EvArgs)
        {
            m_ItemAccessMutex.WaitOne();

            for (int i = 0; i < p_EvArgs.Status.Length; ++i)
            {
                try
                {
                    Dictionary <string, string> l_ItemProps = new Dictionary <string, string>();
                    IOPCItem l_Item = m_ServerModel.GetItemFromClientHandle(p_EvArgs.Status[i].HandleClient);

                    l_ItemProps.Add(ServerModel.ITEM_PROP_VALUE_KEY, OPCUtility.ValueToString(l_Item.Type, p_EvArgs.Status[i].DataValue));
                    l_ItemProps.Add(ServerModel.ITEM_PROP_QUALITY_KEY, OPCUtility.QualityToString(p_EvArgs.Status[i].Quality));
                    l_ItemProps.Add(ServerModel.ITEM_PROP_TIMESTAMP_KEY, OPCUtility.TimeStampToString(p_EvArgs.Status[i].Timestamp));

                    m_ServerModel.UpdateItem(p_EvArgs.Status[i].HandleClient, l_ItemProps);

                    if (this.VeriteqOPCServer)
                    {
                        WriteToDatabase(l_Item);
                    }
                }
                catch (Exception l_Ex)
                {
                    ErrorLog l_ErrorLog = ErrorLog.GetInstance();
                    l_ErrorLog.WriteToErrorLog(l_Ex.Message, l_Ex.StackTrace, "Error during OPC group update");
                }
            }

            m_ItemAccessMutex.ReleaseMutex();
        }
コード例 #4
0
        public void ReadItems()
        {
            m_ItemAccessMutex.WaitOne();

            try
            {
                int            l_Index = 0;
                OPCItemState[] l_ItemStateArray;
                List <int>     l_ServerHandleList = m_ServerModel.GetServerHandleList();

                m_Group.Read(OPCDataSource.OPC_DS_DEVICE, l_ServerHandleList.ToArray(), out l_ItemStateArray);

                foreach (int l_ServerHandle in l_ServerHandleList)
                {
                    if (l_ItemStateArray[l_Index].Error == HResults.S_OK)
                    {
                        int l_ClientHandle = m_ServerModel.GetClientHandleFromServerHandle(l_ServerHandle);
                        Dictionary <string, string> l_ItemProps = new Dictionary <string, string>();
                        IOPCItem l_Item = m_ServerModel.GetItemFromClientHandle(l_ClientHandle);

                        l_ItemProps.Add(ServerModel.ITEM_PROP_VALUE_KEY, OPCUtility.ValueToString(l_Item.Type, l_ItemStateArray[l_Index].DataValue));
                        l_ItemProps.Add(ServerModel.ITEM_PROP_QUALITY_KEY, OPCUtility.QualityToString(l_ItemStateArray[l_Index].Quality));
                        l_ItemProps.Add(ServerModel.ITEM_PROP_TIMESTAMP_KEY, OPCUtility.TimeStampToString(l_ItemStateArray[l_Index].Timestamp));

                        m_ServerModel.UpdateItem(l_ClientHandle, l_ItemProps);

                        if (this.VeriteqOPCServer)
                        {
                            WriteToDatabase(l_Item);
                        }
                    }

                    l_Index++;
                }
            }
            catch (Exception l_Ex)
            {
                Disconnect();

                throw l_Ex;
            }
            finally
            {
                m_ItemAccessMutex.ReleaseMutex();
            }
        }