WTScda HTML5 V3.9 接口开发包

WTScda HTML5 V3.9.9  接口开发包

Interface_SQLServer 3.9.9(最新版本)

SQL表创建代码

MYSQL创建表代码

使用MYSQL需要安装  mysql-connector-net-6.9.8.msi 驱动程序


注意:引用的Common库在 WTScada 软件bin目录下

表结构参考:

Interface_SQLServer接口使用的数据库表结构和内容如下:

列说明:
tagname:变量名称 -- 必须
tagvalue:当前值,该字段可以使用varchar类型  - 必须
tagtype:变量的数据类型 -- 必须
digcount:小数点个数 -- 必须
unit:单位 -- 必须
description:描述 -- 必须
time:更新时间 (当前接口代码未使用)
rangemax,rangemin:量程上下限 -- 必须
status:变量状态 (当前接口代码未使用)

**如果表格式不符合要求,可以自行下载接口代码修改.


接口代码如下:
using System;
using System.Collections.Generic;
using System.Data;
using System.Threading;
using System.Data.Common;
using Common;

namespace Interface_SQLServer
{    
    /// <summary>
    /// 数据库驱动接口
    /// </summary>
    public class Database:IDatabase
    {
        #region 变量        
        /// <summary>
        /// 数据库连接字符串
        /// </summary>
        private string sqlconn = "";
        private string m_name = "";
        /// <summary>
        /// 内部变量存储
        /// </summary>
        private Dictionary<string, BaseTag> Tags = new Dictionary<string, BaseTag>(StringComparer.OrdinalIgnoreCase);
        /// <summary>
        /// 运行标志
        /// </summary>
        private volatile bool running = false;
        /// <summary>
        /// 数据库更新线程
        /// </summary>
        private Thread updateThread = null;
        /// <summary>
        /// 数据库类工厂
        /// </summary>
        private DbProviderFactory dbProviderFactory = null;
        /// <summary>
        /// 数据库连接字符串
        /// </summary>
        private string sqlconnection_provider = "";
        private string sqlcmd = "select * from datatable";
        #endregion

        /// <summary>
        /// 系统设置的变量会通过键值传递过来,无法修改内容,读取需要的配置参数
        /// </summary>
        /// <param name="settings"></param>
        public void Init(Dictionary<string, string> settings)
        {
            if (settings != null)
            {
                //DbProvider
                if (settings.ContainsKey("sqlconnection"))
                    sqlconn = settings["sqlconnection"].Trim();

                if (settings.ContainsKey("sqlcmd"))
                    sqlcmd = settings["sqlcmd"].Trim();

                if (settings.ContainsKey("name"))
                    m_name = settings["name"].Trim();

                if (settings.ContainsKey("sqlconnection_provider"))
                {
                    sqlconnection_provider = settings["sqlconnection_provider"].Trim(); ;
                    dbProviderFactory = DatabaseFactory.Get(sqlconnection_provider);
                }
                //sqlconnection_provider
                //创建标签
                CreateTags();
            }
        }

        /// <summary>
        /// 析构函数
        /// </summary>
        ~Database()
        {
            if (running)
               Stop();
        }

        /// <summary>
        /// 
        /// </summary>
        public bool IsExtendTag
        {
            get
            {
                return false;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public BaseTag[] GetTags()
        {
            BaseTag[] res = new BaseTag[Tags.Count];
            Tags.Values.CopyTo(res, 0);
            return res;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool ReLoad()
        {
            bool result = true;
            //创建标签
            lock (Tags)
            {
                Env.Current.RemoveTags(Name);
                CreateTags();
            }
            return result;
        }

        /// <summary>
        /// 配置变更通知
        /// </summary>
        public void UpdateConfig(Dictionary<string, string> settings)
        {
            if (settings != null)
            {
                if (running)
                    Stop();

                //DbProvider
                if (settings.ContainsKey("sqlconnection"))
                    sqlconn = settings["sqlconnection"].Trim();

                if (settings.ContainsKey("sqlcmd"))
                    sqlcmd = settings["sqlcmd"].Trim();

                if (settings.ContainsKey("name"))
                    m_name = settings["name"].Trim();

                if (settings.ContainsKey("sqlconnection_provider"))
                {
                    sqlconnection_provider = settings["sqlconnection_provider"].Trim(); ;
                    dbProviderFactory = DatabaseFactory.Get(sqlconnection_provider);
                }

                //sqlconnection_provider
                //创建标签
                Env.Current.RemoveTags(Name);
                CreateTags();
            }
        }

        /// <summary>
        /// 更新线程
        /// </summary>
        private void UpdateTags()
        {
            DbConnection conn = dbProviderFactory.CreateConnection();            
            if (conn == null)
            {
                return;
            }
            DbCommand cmd = conn.CreateCommand();
            cmd.CommandText = sqlcmd;
            conn.ConnectionString = sqlconn;
            while (running)
            {
                if (conn.State != ConnectionState.Open)
                {
                    try
                    {
                        conn.Open();                        
                    }
                    catch (Exception ex)
                    {
                        Env.Current.Logger.Log(Severity.Error,"SQL接口UpdateTags,连接数据库发生错误", ex.Message,false);
                        Thread.Sleep(5000);
                        continue;
                    }
                }
                else
                {
                    //tagname tagvalue tagtype digcount unit description time
                    //Single Int32 Boolean Double
                    try
                    {
                        lock (Tags)
                        {
                            #region 
                            DbDataReader reader = cmd.ExecuteReader();
                            object val = null;
                            string tagtype = "";
                            string tagname = "";
                            string strval = "";
                            while (reader.Read())
                            {
                                try
                                {
                                    tagname = reader["tagname"].ToString();
                                    if (Tags.ContainsKey(tagname))
                                    {
                                        #region
                                        tagtype = reader["tagtype"].ToString();
                                        BaseTag ch = Tags[tagname];
                                        if (tagtype == "Int32")
                                        {
                                            val = Convert.ChangeType(reader["tagvalue"], typeof(Int32));
                                        }
                                        else if (tagtype == "Boolean")
                                        {
                                            strval = reader["tagvalue"].ToString();
                                            strval = strval.ToLower();
                                            val = (strval=="1" || strval=="true" || strval=="on");
                                        }
                                        else if (tagtype == "Single")
                                        {
                                            val = Convert.ChangeType(reader["tagvalue"], typeof(Single));
                                        }
                                        else if (tagtype == "Double")
                                        {
                                            val = Convert.ChangeType(reader["tagvalue"], typeof(Double));
                                        }
                                        if (val != null)
                                        {
                                            ch.DoUpdate(val);
                                            //可以更新标签状态和报警状态
                                            //ch.DoUpdate(val, DateTime.Now, TagStatusFlags.Good, 0);
                                        }
                                        #endregion
                                    }
                                }
                                catch (Exception ex)
                                {
                                    Env.Current.Logger.LogError("SQL接口UpdateTags发生错误", ex.Message);
                                }
                            }
                            reader.Close();
                            reader.Dispose();
                            reader = null;
                            #endregion
                        }
                        Thread.Sleep(2000);
                    }
                    catch (Exception ex)
                    {
                        Env.Current.Logger.LogError("SQL接口UpdateTags发生错误", ex.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 创建标签
        /// </summary>
        private int CreateTags()
        {            
            if (sqlconn == "")
                return 0;
            int result = 0;
            Tags.Clear();
            using (DbConnection conn = dbProviderFactory.CreateConnection())
            {
                conn.ConnectionString = sqlconn;
                //tagname tagvalue tagtype digcount unit description time rangemax rangemin status
                //Single Int32 Boolean Double
                try
                {
                    conn.Open();
                    DbCommand cmd = conn.CreateCommand();
                    cmd.CommandText = sqlcmd;
                    DbDataReader reader = cmd.ExecuteReader();
                    Type type = typeof(double);
                    string tagtype = "";
                    string tagname = "";                     
                    while (reader.Read())
                    {
                        try
                        {
                            #region
                            tagname = reader["tagname"].ToString().ToLower();
                            if (tagname!="")
                            {
                                #region
                                tagtype = reader["tagtype"].ToString().ToLower();
                                if (tagtype == "int32")
                                {
                                    type = typeof(Int32);
                                    tagtype = "Int32";
                                }
                                else if (tagtype == "boolean")
                                {
                                    type = typeof(Boolean);
                                    tagtype = "Boolean";
                                }
                                else if (tagtype == "single")
                                {
                                    type = typeof(Single);
                                    tagtype = "Single";
                                }
                                else if (tagtype == "float")
                                {
                                    type = typeof(Single);
                                    tagtype = "Single";
                                }
                                else if (tagtype == "double")
                                {
                                    type = typeof(double);
                                    tagtype = "Double";
                                }
                                else
                                {
                                    type = typeof(String);
                                    tagtype = "String";
                                }
                                #endregion
                                if (tagtype != "")
                                {
                                    BaseTagInfo info = new BaseTagInfo();
                                    info.name = tagname;
                                    info.plugid = Properties.Resources.PlugName;
                                    info.rangeMax = (double)reader["rangemax"];
                                    info.rangeMin = (double)reader["rangemin"];
                                    info.readOnly = false;
                                    info.description = reader["description"].ToString();
                                    info.dataType = type;
                                    info.unit = reader["unit"].ToString();
                                    info.digCount = (int)reader["digcount"];
                                    info.enableStore = false;

                                    //可以加入报警设置
                                    BaseTag ch = new BaseTag(this,info);
                                    ch.StatusFlags = TagStatusFlags.Unknown;
                                    Tags[tagname]=ch;
                                    Env.Current.AddTag(ch);
                                    result++;
                                }
                            }
                            #endregion
                        }
                        catch (Exception ex)
                        {
                            Env.Current.Logger.LogError("SQLServer接口CreateTags发生错误", ex.Message);
                        }
                    }
                    reader.Close();
                    cmd.Dispose();
                }
                catch (Exception ex)
                {
                    Env.Current.Logger.LogError("SQLServer接口CreateTags发生错误", ex.Message);
                }
            }
            return result;
        
        }

        /// <summary>
        /// 启动函数
        /// </summary>
        /// <returns></returns>
        public bool Start()
        {
            if (sqlconn != "")
            {
                //创建循环更新线程                    
                updateThread = new Thread(new ThreadStart(UpdateTags));
                running = true;
                updateThread.Start();
            }
            else
            {
                running = false;
            }
            return running;
        }

        /// <summary>
        /// 停止函数
        /// </summary>
        /// <returns></returns>
        public bool Stop()
        {
            if (updateThread != null)
            {
                running = false;
                if (!updateThread.Join(5000))
                    updateThread.Abort();
                updateThread = null;
            }
            return true;
        }

        /// <summary>
        /// 标签数量
        /// </summary>
        public int TagsCount
        {
            get
            {
                return Tags.Count;
            }
        }

        /// <summary>
        /// 驱动名称
        /// </summary>
        public string Name
        {
            get
            {
                if (string.IsNullOrEmpty(m_name))
                    return Properties.Resources.PlugName;
                else
                    return m_name;
            }
        }

        /// <summary>
        /// 查询实时值,如果没有找到BaseTag变量调用该函数
        /// </summary>
        /// <param name="tags"></param>
        /// <returns></returns>
        public BaseTag[] GetValues(string[] tags)
        {
            List<BaseTag> result = new List<BaseTag>();           
            return result.ToArray();
        }

        /// <summary>
        /// 设置标签值,如果没有找到BaseTag变量调用该函数
        /// </summary>
        /// <param name="tagname"></param>
        /// <param name="tagvalue"></param>
        public bool SetTagValue(string tagname, string tagvalue, ref string info)
        {
            info = "不支持的操作";
            return false;
        }

        /// <summary>
        /// 新的设置标签值函数
        /// </summary>
        /// <param name="tag"></param>
        /// <param name="tagvalue"></param>
        public bool SetTagValue(BaseTag tag, string tagvalue, ref string info)
        {
            info = "不支持的操作";
            return false;
        }
        /// <summary>
        /// 标签值操作,如果没有找到BaseTag变量调用该函数
        /// </summary>
        /// <param name="tagname"></param>
        /// <param name="tagvalue"></param>
        public bool AddTagValue(string tagname, string tagvalue, ref string info)
        {
            info = "不支持的操作";
            return false;
        }

        /// <summary>
        /// 新的标签值操作
        /// </summary>
        /// <param name="tagname"></param>
        /// <param name="tagvalue"></param>
        public bool AddTagValue(BaseTag tag, string tagvalue, ref string info)
        {
            info = "不支持的操作";
            return false;
        }

        /// <summary>
        /// 切换标签值,如果没有找到BaseTag变量调用该函数
        /// </summary>
        /// <param name="tagname"></param>
        public bool ToggleTagValue(string tagname, ref string info)
        {
            info = "不支持的操作";
            return false;
        }

        /// <summary>
        /// 新的切换标签值
        /// </summary>
        /// <param name="tagname"></param>
        public bool ToggleTagValue(BaseTag tag, ref string info)
        {
            info = "不支持的操作";
            return false;
        }

        /// <summary>
        /// 批量写值,如果没有找到BaseTag变量调用该函数
        /// </summary>
        /// <param name="tagnames"></param>
        /// <param name="values"></param>
        /// <returns></returns>
        public bool WriteTags(string[] tagnames, object[] values,ref string info)
        {
            info = "不支持的操作";
            return false;
        }


        /// <summary>
        /// 查询最大或者最小或者平均值
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <param name="type">max min avg</param>
        /// <param name="max"></param>
        /// <param name="min"></param>
        /// <param name="avg"></param>
        /// <returns></returns>
        public bool QueryHist_Value(DateTime start, DateTime end, string tag, string type, ref double max, ref double min, ref double avg)
        {
            if (type == "max")
            {
                max = 100;
            }
            else if (type == "min")
            {
                min = 0;
            }
            else if (type == "avg")
            {
                avg = 50;
            }
            else
            {
                max = 100;
                min = 0;
                avg = 50;
            }
            return true;
        }

        /// <summary>
        /// 报表查询
        /// </summary>
        /// <param name="start">开始时间</param>
        /// <param name="end">结束时间</param>
        /// <param name="tags">逗号分割</param>
        /// <param name="type"></param>
        /// <returns></returns>
        public List<Dictionary<string, object>> QueryReport(string table, DateTime start, DateTime end, string tags,string type="")
        {
            if (sqlconn == "")
                return null;
            else
            {
                List<Dictionary<string, object>> result = new List<Dictionary<string, object>>();
                using (DbConnection conn = dbProviderFactory.CreateConnection())
                {
                    try
                    {
                        conn.ConnectionString = sqlconn;
                        string sql = "select time," + tags + " from hisdata where time>'" + start.ToString("yyyy-M-d HH:m:s") + "' and time<'" + end.ToString("yyyy-M-d HH:m:s") + "' order by time asc";
                    }
                    catch (Exception ex)
                    {
                        Env.Current.Logger.LogError("SQL接口QueryReport发生错误", ex.Message);
                    }
                }
                return result;
            }
        }

        /// <summary>
        /// 批量查询历史数据
        /// </summary>
        /// <param name="start"></param>
        /// <param name="end"></param>
        /// <param name="tags"></param>
        /// <param name="second"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public List<HistData> QueryHists(DateTime start, DateTime end, string[] tags, int second, string type = "")
        {
            List<HistData> result = new List<HistData>();
            return result;
        }

        /// <summary>
        /// 批量查询指定时间的历史值
        /// </summary>
        /// <param name="start"></param>
        /// <param name="tags"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public List<HistData> QueryHist_Values(DateTime start, string[] tags, string type = "")
        {
            List<HistData> result = new List<HistData>();
            return result;
        }

        /// <summary>
        /// 变量检查
        /// </summary>
        /// <param name="tagname"></param>
        /// <returns></returns>
        public bool ContainsTag(string tagname)
        {
            if (!string.IsNullOrEmpty(tagname))
                return Tags.ContainsKey(tagname);
            else
                return false;
        }

        /// <summary>
        /// 保留
        /// </summary>
        /// <param name="tagname"></param>
        /// <returns></returns>
        public BaseTag GetTag(string tagname)
        {
            return null;
        }

        /// <summary>
        /// 用户自定义命令
        /// </summary>
        /// <param name="cmd"></param>
        /// <returns></returns>
        public string DoCommand(string cmd)
        {
            return "不支持的操作";
        }

        /// <summary>
        /// 修改报警类型
        /// </summary>
        /// <param name="tagname"></param>
        /// <param name="atype"></param>
        /// <returns></returns>
        public bool ChangeAlarmType(string tagname, AlarmType atype)
        {
            bool result = false;
            return result;
        }

        /// <summary>
        /// 更新报警定值
        /// </summary>
        /// <param name="tagname"></param>
        /// <param name="ll"></param>
        /// <param name="l"></param>
        /// <param name="h"></param>
        /// <param name="hh"></param>
        /// <returns></returns>
        public bool UpdateAlarmSetting(string tagname, double ll, double l, double h, double hh)
        {
            bool result = false;
            return result;
        }
    }
}