Exemple #1
0
        /// <summary>
        ///     耐奇数据
        /// </summary>
        private void OneDeal_NQ(M_MT_TagDefine info)
        {
            DataTable dtStore = null;

            //var dtTags = dsTags.Tables["T_BS_TagDefine"];


            DataTableHelper.CreateDataTable(ref dtStore, "T_BS_Realdata");
            try
            {
                if (BasePublic.mySqlConnection == null)
                {
                }
                var lst = BLLFactory <B_NQ_Monitordata> .Instance.GetNewList(null, BasePublic.mySqlConnection);//string.Format(" DeviceID='{0}'", info.ID), BasePublic.mySqlConnection);

                dtStore = DataConvert.FormateNQ2BS(lst, info.lstTags);
                if (dtStore != null && dtStore.Rows != null)
                {
                    Console.WriteLine(string.Format("{0}  获取到耐奇数据,共{1}条", DateTime.Now.ToString(BasePublic.strTimeFormat), dtStore.Rows.Count));
                }
                InsertToServer(dtStore, "T_BS_Realdata");
            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("{0}获取耐奇数据出错", DateTime.Now.ToString(BasePublic.strTimeFormat)));
                return;
            }
            lock (BasePublic.lockerConfig)
            {
                var dtSpt = dsRealdata_Spt.Tables["T_BS_Realdata_Spt"];
                try
                {
                    foreach (DataRow item in dtStore.Rows)
                    {
                        var drSpt = dtSpt.Select(string.Format("TagID='{0}'", item["TagID"])).FirstOrDefault();
                        if (drSpt != null)
                        {
                            drSpt["RealTime"]  = item["RealTime"];
                            drSpt["RealValue"] = item["RealValue"];
                            //drSpt.AcceptChanges();
                        }
                    }
                    UpdateToServer();
                }
                catch (Exception ex)
                {
                    Console.WriteLine(string.Format("{0}  更新耐奇数据出错 ", DateTime.Now.ToString(BasePublic.strTimeFormat)));
                    return;
                }
            }
        }
Exemple #2
0
        /// <summary>
        ///     单个PLC取数据
        /// </summary>
        /// <param name="item"></param>
        private void OneDeal(M_MT_TagDefine info)
        {
            dtS = DateTime.Now;
            Thread.Sleep(1);
            if (info == null)
            {
                return;
            }

            #region 创建socket连接

            var socketIP = info.TagAddr;
            if (string.IsNullOrEmpty(socketIP))
            {
                return;
            }
            var arrSendOrder   = info.SendOrder.Split(',');
            var barrySendOrder = new byte[arrSendOrder.Length];
            for (var i = 0; i < arrSendOrder.Length; i++)
            {
                barrySendOrder[i] = Convert.ToByte(arrSendOrder[i], 16);
                var a = string.Format("0x{0:X}", barrySendOrder[i]);
            }
            var       threadID = Thread.CurrentThread.ManagedThreadId; //获取当前线程的ID标识
            var       dt       = DateTime.Now;
            var       Port     = 502;                                  //访问的端口号
            IPAddress IP       = null;
            try
            {
                IP = IPAddress.Parse(socketIP);
            }
            catch (Exception e)
            {
                var msg = string.Format("{0}  {1} {2}  {3}", dt, info.ID + "转换地址时出错", threadID,
                                        e.Message);
                Console.WriteLine(string.Format(msg));
                BasePublic.ExceptionDeal(BaseEnum.Collect, msg);
                return;
            }
            var ipe    = new IPEndPoint(IP, Port);                                                    //把ip和端口转化为IPEndPoint的实例
            var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); //创建socket实例
            socket.SendTimeout    = 1000;
            socket.ReceiveTimeout = 1000;
            socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.AcceptConnection, true);

            #endregion

            //socket连接建立及连接异常处理
            try
            {
                if (!socket.Connected)
                {
                    socket.Connect(ipe);
                }
            }
            catch (Exception e)
            {
                var msg = string.Format("{0}  模块<{1}>连接失败,{2},{3}", dt, info.ID, threadID,
                                        e.Message);
                Console.WriteLine(string.Format(msg));
                BasePublic.ExceptionDeal(BaseEnum.Collect, msg);
                socket.Close();
                socket.Dispose();
                return;
            }
            //Console.WriteLine(string.Format("{0}  模块<{1}({2})>连接成功,{3}", dt, info.TagName, info.ID, threadID));
            try
            {
                socket.Send(barrySendOrder, barrySendOrder.Length, 0); //modbusTCP套接字命令发送
            }
            catch (Exception e)
            {
                var msg = string.Format("{0}  模块<{1}>通讯失败,{2},{3}", dt, info.ID, threadID,
                                        e.Message);
                Console.WriteLine(string.Format(msg));
                BasePublic.ExceptionDeal(BaseEnum.Collect, msg);
                socket.Close();
                socket.Dispose();
                return;
            }
            // Console.WriteLine(string.Format("{0}  模块<{1}({2})>通讯成功,{3}", dt, info.TagName, info.ID, threadID));
            int n       = barrySendOrder[11];
            var m       = 10 + 2 * n - 1;
            var recData = new byte[m];
            try
            {
                socket.Receive(recData, recData.Length, 0); //套接字读取
                //校验前缀 / 地址和数据长度
                var result_tag = true;
                for (var i = 6; i < 8; i++)
                {
                    result_tag = result_tag && (recData[i] == Convert.ToByte(arrSendOrder[i], 16));
                }
                if (result_tag && n == recData[8] / 2)
                {
                    recData = recData.Skip(9).ToArray();
                }
                else
                {
                    var msg = string.Format("{0}   模块<{1}>校验失败,{2}", dt, info.ID, threadID);
                    Console.WriteLine(string.Format(msg));
                    BasePublic.ExceptionDeal(BaseEnum.Collect, msg);
                    return;
                }
            }
            catch (Exception e)
            {
                var msg = string.Format("{0}   模块<{1}>接收失败,{2},{3}", dt, info.ID, threadID,
                                        e.Message);
                Console.WriteLine(string.Format(msg));
                BasePublic.ExceptionDeal(BaseEnum.Collect, msg);
                socket.Close();
                socket.Dispose();
                return;
            }
            //Console.WriteLine(string.Format("{0}  模块<{1}({2})>接收成功,{3}", dt, info.TagName, info.ID, threadID));
            //string tttt = String.Join(",", recData);
            //string st = DataConvert.ByteArrayToHexStr(recData);
            var dtStore = new DataTable();
            lock (BasePublic.lockerConfig)
            {
                #region 数据转化到datatable

                var dtTags = dsTags.Tables["T_BS_TagDefine"];


                DataTableHelper.CreateDataTable(ref dtStore, "T_BS_Realdata");
                var dtSpt = dsRealdata_Spt.Tables["T_BS_Realdata_Spt"];
                //CreateDataTable(ref dtSpt);
                var dtAlarm = new DataTable();
                DataTableHelper.CreateDataTable(ref dtAlarm, "T_EP_EquipWarning");
                var fs             = new object[n / 2];
                var analysis_index = 0; //recData第一个数据的0索引位置
                for (var i = 0; i < info.lstTags.Count; i++)
                {
                    var current_analysis = info.lstTags.Find(delegate(M_BS_TagDefine temp) { return(temp.DataIndex == i); });

                    #region 数据解析

                    /*0orNull default(float)
                     * 1 char
                     * 2 int16
                     * 3 int32
                     * 4 int64
                     * 5 uint16
                     * 6 uint32
                     * 7 uint64
                     * 8 float
                     * 9 double
                     * */

                    #region 数据解析(过期)

                    //switch (current_analysis.DataType)
                    //{
                    //    case 1://char
                    //        {
                    //            byte[] aa = new byte[sizeof(char)];
                    //            Array.Copy(recData, analysis_index, aa, 0, sizeof(char));
                    //            aa=aa.Reverse().ToArray();
                    //            fs[i] = BitConverter.ToChar(aa, 0);
                    //            analysis_index += sizeof(char);
                    //        }
                    //        break;
                    //    case 2://int16
                    //        {
                    //            byte[] aa = new byte[sizeof(Int16)];
                    //            Array.Copy(recData, analysis_index, aa, 0, sizeof(Int16));
                    //            aa = aa.Reverse().ToArray();
                    //            fs[i] = BitConverter.ToInt16(aa, 0);
                    //            analysis_index += sizeof(Int16);
                    //        }
                    //        break;
                    //    case 3://int32
                    //        {
                    //            byte[] aa = new byte[sizeof(Int32)];
                    //            Array.Copy(recData, analysis_index, aa, 0, sizeof(Int32));
                    //            aa = aa.Reverse().ToArray();
                    //            fs[i] = BitConverter.ToInt32(aa, 0);
                    //            analysis_index += sizeof(Int32);
                    //        }
                    //        break;
                    //    case 4://int64
                    //        {
                    //            byte[] aa = new byte[sizeof(Int64)];
                    //            Array.Copy(recData, analysis_index, aa, 0, sizeof(Int64));
                    //            aa = aa.Reverse().ToArray();
                    //            fs[i] = BitConverter.ToInt64(aa, 0);
                    //            analysis_index += sizeof(Int64);
                    //        }
                    //        break;
                    //    case 5://uint16
                    //        {
                    //            byte[] aa = new byte[sizeof( UInt16)];
                    //            Array.Copy(recData, analysis_index, aa, 0, sizeof(UInt16));
                    //            aa = aa.Reverse().ToArray();
                    //            fs[i] = BitConverter.ToUInt16(aa, 0);
                    //            analysis_index += sizeof(UInt16);
                    //        }
                    //        break;
                    //    case 6://uint32
                    //        {
                    //            byte[] aa = new byte[sizeof(UInt32)];
                    //            Array.Copy(recData, analysis_index, aa, 0, sizeof(UInt32));
                    //            aa = aa.Reverse().ToArray();
                    //            fs[i] = BitConverter.ToUInt32(aa, 0);
                    //            analysis_index += sizeof(UInt32);
                    //        }
                    //        break;
                    //    case 7://uint64
                    //        {
                    //            byte[] aa = new byte[sizeof(Int64)];
                    //            Array.Copy(recData, analysis_index, aa, 0, sizeof(Int64));
                    //            aa = aa.Reverse().ToArray();
                    //            fs[i] = BitConverter.ToUInt64(aa, 0);
                    //            analysis_index += sizeof(Int64);
                    //        }
                    //        break;
                    //    case 8://float
                    //        {
                    //            byte[] aa = new byte[sizeof(float)];
                    //            Array.Copy(recData, analysis_index, aa, 0, sizeof(float));
                    //            aa = aa.Reverse().ToArray();
                    //            fs[i] = BitConverter.ToSingle(aa, 0);
                    //            analysis_index += sizeof(float);
                    //        }
                    //        break;
                    //    case 9:
                    //        {
                    //            byte[] aa = new byte[sizeof(double)];
                    //            Array.Copy(recData, analysis_index, aa, 0, sizeof(double));
                    //            aa = aa.Reverse().ToArray();
                    //            fs[i] = BitConverter.ToDouble(aa, 0);
                    //            analysis_index += sizeof(double);
                    //        }
                    //        break;
                    //    default://float
                    //        {
                    //            byte[] aa = new byte[sizeof(float)];
                    //            Array.Copy(recData, analysis_index, aa, 0, sizeof(float));
                    //            aa = aa.Reverse().ToArray();
                    //            fs[i] = BitConverter.ToSingle(aa, 0);
                    //            analysis_index += sizeof(float);
                    //        }
                    //        break;
                    //}

                    #endregion

                    //正确的转换顺序

                    #region 数据解析

                    switch (current_analysis.DataType)
                    {
                    case 1:     //char
                    {
                        var aa = new byte[sizeof(char)];
                        Array.Copy(recData, analysis_index, aa, 0, sizeof(char));
                        aa              = aa.Reverse().ToArray();
                        fs[i]           = BitConverter.ToChar(aa, 0);
                        analysis_index += sizeof(char);
                    }
                    break;

                    case 2:     //int16
                    {
                        var aa = new byte[sizeof(Int16)];
                        Array.Copy(recData, analysis_index, aa, 0, sizeof(Int16));
                        aa              = aa.Reverse().ToArray();
                        fs[i]           = BitConverter.ToInt16(aa, 0);
                        analysis_index += sizeof(Int16);
                    }
                    break;

                    case 3:     //int32
                    {
                        var aa = new byte[sizeof(Int32)];
                        Array.Copy(recData, analysis_index, aa, 0, sizeof(Int32));
                        aa              = aa.Reverse().ToArray();
                        fs[i]           = BitConverter.ToInt32(new[] { aa[2], aa[3], aa[0], aa[1] }, 0);
                        analysis_index += sizeof(Int32);
                    }
                    break;

                    case 4:     //int64
                    {
                        var aa = new byte[sizeof(Int64)];
                        Array.Copy(recData, analysis_index, aa, 0, sizeof(Int64));
                        aa              = aa.Reverse().ToArray();
                        fs[i]           = BitConverter.ToInt64(new[] { aa[4], aa[5], aa[2], aa[3], aa[0], aa[1] }, 0);
                        analysis_index += sizeof(Int64);
                    }
                    break;

                    case 5:     //uint16
                    {
                        var aa = new byte[sizeof(UInt16)];
                        Array.Copy(recData, analysis_index, aa, 0, sizeof(UInt16));
                        aa              = aa.Reverse().ToArray();
                        fs[i]           = BitConverter.ToUInt16(aa, 0);
                        analysis_index += sizeof(UInt16);
                    }
                    break;

                    case 6:     //uint32
                    {
                        var aa = new byte[sizeof(UInt32)];
                        Array.Copy(recData, analysis_index, aa, 0, sizeof(UInt32));
                        aa              = aa.Reverse().ToArray();
                        fs[i]           = BitConverter.ToUInt32(new[] { aa[2], aa[3], aa[0], aa[1] }, 0);
                        analysis_index += sizeof(UInt32);
                    }
                    break;

                    case 7:     //uint64
                    {
                        var aa = new byte[sizeof(Int64)];
                        Array.Copy(recData, analysis_index, aa, 0, sizeof(Int64));
                        aa              = aa.Reverse().ToArray();
                        fs[i]           = BitConverter.ToUInt64(new[] { aa[4], aa[5], aa[2], aa[3], aa[0], aa[1] }, 0);
                        analysis_index += sizeof(Int64);
                    }
                    break;

                    case 8:     //float
                    {
                        var aa = new byte[sizeof(float)];
                        Array.Copy(recData, analysis_index, aa, 0, sizeof(float));
                        aa              = aa.Reverse().ToArray();
                        fs[i]           = BitConverter.ToSingle(new[] { aa[2], aa[3], aa[0], aa[1] }, 0);
                        analysis_index += sizeof(float);
                    }
                    break;

                    case 9:
                    {
                        //byte[] aa = new byte[sizeof(double)];
                        //Array.Copy(recData, analysis_index, aa, 0, sizeof(double));
                        //aa = aa.Reverse().ToArray();
                        //fs[i] = BitConverter.ToDouble(new byte[] { aa[6],aa[7],aa[4],aa[5],aa[2], aa[3], aa[0], aa[1] }, 0);
                        //analysis_index += sizeof(double);

                        var aa = new byte[sizeof(UInt32)];
                        Array.Copy(recData, analysis_index, aa, 0, sizeof(UInt32));
                        aa = aa.Reverse().ToArray();
                        double dd = BitConverter.ToUInt32(new[] { aa[2], aa[3], aa[0], aa[1] }, 0);
                        analysis_index += sizeof(UInt32);

                        var bb = new byte[sizeof(UInt32)];
                        Array.Copy(recData, analysis_index, bb, 0, sizeof(UInt32));
                        bb = bb.Reverse().ToArray();
                        double de = BitConverter.ToUInt32(new[] { bb[2], bb[3], bb[0], bb[1] }, 0);
                        analysis_index += sizeof(UInt32);
                        var df = (dd * Math.Pow(10, 6) + de / 100) / 100;
                        fs[i] = df;
                    }
                    break;

                    case 10:
                    {
                        //byte[] aa = new byte[sizeof(double)];
                        //Array.Copy(recData, analysis_index, aa, 0, sizeof(double));
                        //aa = aa.Reverse().ToArray();
                        //fs[i] = BitConverter.ToDouble(new byte[] { aa[6],aa[7],aa[4],aa[5],aa[2], aa[3], aa[0], aa[1] }, 0);
                        //analysis_index += sizeof(double);

                        var aa = new byte[sizeof(UInt32)];
                        Array.Copy(recData, analysis_index, aa, 0, sizeof(UInt32));
                        aa = aa.Reverse().ToArray();
                        double dd = BitConverter.ToSingle(new[] { aa[2], aa[3], aa[0], aa[1] }, 0);
                        analysis_index += sizeof(UInt32);

                        var bb = new byte[sizeof(UInt32)];
                        Array.Copy(recData, analysis_index, bb, 0, sizeof(UInt32));
                        bb = bb.Reverse().ToArray();
                        double de = BitConverter.ToSingle(new[] { bb[2], bb[3], bb[0], bb[1] }, 0);
                        analysis_index += sizeof(UInt32);
                        var df = (dd * Math.Pow(10, 2) + de);
                        fs[i] = df;
                    }
                    break;

                    default:     //float
                    {
                        var aa = new byte[sizeof(float)];
                        Array.Copy(recData, analysis_index, aa, 0, sizeof(float));
                        aa              = aa.Reverse().ToArray();
                        fs[i]           = BitConverter.ToSingle(new[] { aa[2], aa[3], aa[0], aa[1] }, 0);
                        analysis_index += sizeof(float);
                    }
                    break;
                    }

                    #endregion
                }

                #endregion

                #region 数据操作
                foreach (var model in info.lstTags)
                {
                    var drTag = dtTags.Select(string.Format("ID='{0}'", model.ID)).FirstOrDefault();
                    if (drTag != null)
                    {
                        var drSpt   = dtSpt.Select(string.Format("TagID='{0}'", model.ID)).FirstOrDefault();
                        var drStore = dtStore.NewRow();
                        var dValue  = Convert.ToDouble(fs[model.DataIndex]);
                        drStore["TagID"] = model.ID;
                        decimal dValue3 = 0;
                        decimal.TryParse(dValue.ToString("#.000"), out dValue3);
                        if (model.CompensateRatio > 0)
                        {
                            dValue3 = dValue3 * model.CompensateRatio;
                        }
                        dValue3 = (Math.Abs(dValue3) > (decimal)(Math.Pow(10, 15) - 1)) ? 0 : dValue3;
                        lock (BasePublic.lockerConfig)
                        {
                            drStore["RealValue"]  = dValue3;
                            drStore["RealTime"]   = dtS.ToString(BasePublic.strTimeFormat);
                            drStore["RecordTime"] = dtS.ToString(BasePublic.strTimeFormat);
                        }


                        //dtSpt.Rows.Add(drSpt);
                        var period = 0;
                        if (drTag["StorePeriod"] != null)
                        {
                            int.TryParse(drTag["StorePeriod"].ToString(), out period);
                        }
                        DateTime dt00;
                        if (!DateTime.TryParse(drTag["LastTime"].ToString(), out dt00))
                        {
                            dt00 = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd 00:00"));
                        }
                        var dt11 = dtS.AddSeconds(-period);
                        if (dt00 <= dt11)
                        {
                            dtStore.Rows.Add(drStore);
                            lock (BasePublic.lockerConfig)
                            {
                                drTag["LastTime"] = dtS;
                                drTag.AcceptChanges();
                            }
                        }
                        try
                        {
                            drSpt["RealTime"]  = dtS.ToString(BasePublic.strTimeFormat);
                            drSpt["RealValue"] = dValue3;
                        }
                        catch (Exception ex)
                        {
                        }
                    }


                    #endregion
                }
                //VerfyAlarm(BasePublic.lstTagsAll, dtStore, mtTemp, ref dtAlarm);

                #endregion
            }

            UpdateToServer();
            InsertToServer(dtStore, "T_BS_Realdata");


            //manualReset_Config.Set();
        }