jisco_winform_wzjl/RailLocalMeter/frmMain.cs

using com.hnshituo.core.webapp.vo;
using Infragistics.Win.UltraWinGrid;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.IO;
using System.Linq;
using System.Net;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace RailLocalMeter
{
    public partial class frmMain : Form
    {
        public frmMain()
        {
            InitializeComponent();
        }

        string ip = "";
        Log lg = Log.GetInstance();

        private LED_Control led_controler;

        /// <summary>
        /// 硬盘录像机图片抓拍通道
        /// </summary>
        List<int> lc = new List<int>();

        /// <summary>
        /// 服务端委托获取
        /// </summary>
        private PreRailwayScaleService preService = new PreRailwayScaleService();
        RESTfulResult<List<PreRailwayScale>> rmRailwayScaleList = new RESTfulResult<List<PreRailwayScale>>();
        private MeterWorkRailwayActFirstService firstService = new MeterWorkRailwayActFirstService(); 
        RESTfulResult<List<MeterWorkRailwayActFirst>> rmRailwayFirstList = new RESTfulResult<List<MeterWorkRailwayActFirst>>();//一次计量数据
        RESTfulResult<List<MeterWorkRailwayActFirst>> rmWaitFirstList = new RESTfulResult<List<MeterWorkRailwayActFirst>>();//一次待提交数据
        private MeterWorkRailwayActualService netService = new MeterWorkRailwayActualService();
        RESTfulResult<List<MeterWorkRailwayActual>> rmWaitNetList = new RESTfulResult<List<MeterWorkRailwayActual>>();//结净待提交数据

        PlcCls plc = new PlcCls();

        /// <summary>
        /// 图片操作类
        /// </summary>
        ImageOption imgControl = new ImageOption();

        /// <summary>
        /// 重量采集类
        /// </summary>
        MoxaCls mx = new MoxaCls();

        /// <summary>
        /// 语音播放
        /// </summary>
        VoicePlay vicPlayClass = new VoicePlay();

        /// <summary>
        /// rfid车号识别
        /// </summary>
        RfIdCarNo rfid = new RfIdCarNo();

        /// <summary>
        /// Ping服务器服务是否通
        /// </summary>
        PingNetwork ping = new PingNetwork();

        /// <summary>
        /// 以下是硬盘录像机的控制
        /// </summary>
        bool bVoice = false;
        CamerEs ce = new CamerEs(AppConfigCache.voicePlayIp, $"{AppConfigCache.voicePlayPort}", AppConfigCache.voicePlayUid, AppConfigCache.voicePlayPwd);
        List<int> voPlay = new List<int>();
        int iPic = 0;

        int lockWgtImg = 0;
        string strGuid = "";

        //导出代码，如果要用，则丢到按钮事件中即可
        //ClsControlPack.ExportDataWithSaveDialog2(ref ultraGridFirst, DateTime.Now.ToString("yyyyMMddHHmmss"));

        private void frmMain_Load(object sender, EventArgs e)
        {
            try
            {
                IPHostEntry ipHost = Dns.Resolve(Dns.GetHostName());
                IPAddress ipAddr = ipHost.AddressList[0];
                ip = ipAddr.ToString();
            }
            catch (Exception ex)
            {
                Random rd = new Random();
                lg.WriteLog(LogType.SystemLog, $"获取本地IP异常{ex.Message}");
                ip = $"{rd.Next(99999, 999999)}";
            }

            //CacleCls.isJg = true;
            CacleCls.updateRfidInfoTime = DateTime.Now;
            if (!string.IsNullOrEmpty(AppConfigCache.ledIp))
            {
                led_controler = new LED_Control(AppConfigCache.ledIp);
            }

            #region 读取音频文件名称
            List<string> ls = new List<string>();
            DirectoryInfo folder = new DirectoryInfo(AppConfigCache.path + "\\Sound");

            foreach (FileInfo file in folder.GetFiles("*.wav"))
            {
                ls.Add(file.Name.Replace(".wav", ""));
            }
            CacleCls.voiceInfo = ls;
            #endregion

            string[] strTd1 = AppConfigCache.channelOther.Split(',');
            string[] strTd2 = AppConfigCache.channelVis.Split(',');
            string[] strAll = new string[strTd1.Length + strTd2.Length];
            strTd1.CopyTo(strAll, 0);
            strTd2.CopyTo(strAll, strTd1.Length);
            List<string> lcs = strAll.Distinct().OrderBy(s => s).ToList(); //

            lc.Add(AppConfigCache.channelCarNo);
            foreach (string str in lcs)
            {
                if ($"{AppConfigCache.channel}" != str && $"{AppConfigCache.channelCarNo}" != str)
                {
                    lc.Add(Convert.ToInt32(str)); //抓拍通道与数组中不相同的时候写入，因为我们仪表抓拍的通道需单独进行处理
                }
            }

            plImgShow.Visible = false;
            lbPointName.Text = AppConfigCache.pointName;

            foreach (string str in AppConfigCache.channelVis.Split(','))
            {
                voPlay.Add(Convert.ToInt32(str));
            }

            ce.Connection();
            foreach (int i in voPlay)
            {
                PictureBox pb = new PictureBox();
                pb.Dock = DockStyle.Top;
                pb.DoubleClick += new EventHandler(PictureBoxDoubleClick);
                pb.Height = AppConfigCache.channelVisHeight;
                pb.Name = $"pb{i}";
                panel1.Controls.Add(pb);
                ce.RealPlay(pb, i);
            }

            if (AppConfigCache.plcStart == "1") plc.Start();

            //*
            ping.start();
            mx.start();
            rfid.Start();
            imgControl.Start();


            blThreadFlag = true;
            DataCollectThread = new Thread(new ThreadStart(DataCollect));
            start();

            BindTable<MeterWorkRailwayActFirst>(ultraGridLocalFirst, dataTableWaitFirst, "localFirst");
            BindTable<MeterWorkRailwayActual>(ultraGridLocalNet, dataTableWaitNet, "localNet");
        }

        #region 语音控制
        /// <summary>
        ///  必须先打开视频，然后再打开语音
        /// </summary>
        private void VoiceOpen()
        {
            try
            {
                if (ce.StartTalk())
                {
                    btnOpenVoice.Text = "关闭对讲";
                    bVoice = true;
                }
            }
            catch (Exception ex)
            {
                txtMsgInfo.Text = "打开对讲失败：" + ex.Message;
            }
        }

        /// <summary>
        /// 关闭语音对讲
        /// </summary>
        private void VoiceClose()
        {
            try
            {
                if (ce.StopTalk())
                {
                    btnOpenVoice.Text = "打开对讲";
                    bVoice = false;
                }
            }
            catch (Exception ex)
            {
                txtMsgInfo.Text = "关闭对讲失败：" + ex.Message;
            }
        }
        #endregion

        #region 本地主逻辑判断线程
        bool blThreadFlag;//数据采集线程开关
        Thread DataCollectThread = null;//采集进程

        bool flagCaption = false, isVoiceDownCar = false;
        string strOldCarNo = "";
        bool isMeasureSuccess = false;
        int voiceNum = 0;
        int iImgCnt = 0;

        private void start() => DataCollectThread.Start();

        private void stop() => blThreadFlag = false;

        bool flagQuery = false;
        private void DataCollect()
        {
            if (!blThreadFlag) return;
            int iError = 0;
            while (blThreadFlag)
            {
                try
                {
                    this.plMain.Invoke(new Action(() => {
                        ucWeightT1.setWgt(Math.Round((double)CacleCls.weight / 1000, 2)); //2021年5月10日界面显示单位，调整为T
                        ucWeightT1.setStable(CacleCls.isWd != 1 ? true : false);
                        ucWeightT1.setExceed(CacleCls.weight > AppConfigCache.maxRange * 1000 ? false : true);

                        if (txtCarNo.Text.Trim() != "" && !txtCarNo.Focused)
                        {
                            CacleCls.lockCarNo = txtCarNo.Text.Trim();
                        }
                        else if (!string.IsNullOrEmpty(CacleCls.rfidCarNo))
                        {
                            if (CacleCls.rfidCarNo.Length > 14) 
                            {
                                CacleCls.lockCarNo = CacleCls.rfidCarNo.Substring(7, 7);
                                CacleCls.carType = CacleCls.rfidCarNo.Substring(1, 5).Trim().ToUpper();
                            }
                        }

                        if (!string.IsNullOrEmpty(CacleCls.lockCarNo) && txtCarNo.Text.Trim() == "")
                        {
                            txtCarNo.Text = CacleCls.lockCarNo;
                        }
                        if (strOldCarNo != CacleCls.lockCarNo)
                        {
                            isUseLabelTare = false;
                            strOldCarNo = CacleCls.lockCarNo;
                            flagQuery = false;
                            CacleCls.isLock = false;//车号不同了则不锁定
                        }

                        #region 获取一次数据跟车号
                        if (!string.IsNullOrEmpty(CacleCls.lockCarNo) && !flagQuery && CacleCls.serverFlag)
                        {
                            //查询一次计量数据
                            BindTable<MeterWorkRailwayActFirst>(ultraGridFirst, dataTableFirst, "first");

                            //查询预报数据
                            BindTable<PreRailwayScale>(ultraGridPre, dataTablePre, "pre");
                            flagQuery = true;
                        }
                        #endregion

                        iError = 1;
                        //是否能连上远程服务器，这里只是服务器，不是服务器上的服务端
                        pbLineOn.Load(CacleCls.serverFlag ? (AppConfigCache.path + "\\image\\icon\\green.gif") : (AppConfigCache.path + "\\image\\icon\\red.gif"));

                        iError = 2;
                        if (CacleCls.weight > 1000)
                        {
                            iError = 21;
                            iImgCnt = 0;
                            CacleCls.isClear = false;

                            #region 如果是自动计量
                            if (!CacleCls.isLock && !CacleCls.isJg && CacleCls.btnState == "1" && CacleCls.isWd == 0)
                            {
                                if (string.IsNullOrEmpty(CacleCls.lockCarNo)) 
                                {
                                    txtMsgInfo.Text = "车号未识别";
                                    vicPlayClass.GetVoicePlay(VoiceEnum.车号未识别, "");
                                    led_controler.setStaticLineMsg(AppConfigCache.ledIp, "车号未识别");
                                    return;
                                }

                                //重量最后一位不为0也是超量程
                                if ((AppConfigCache.maxRange * 1000 < CacleCls.weight) || CacleCls.weight.ToString().Substring(CacleCls.weight.ToString().Length - 1, 1) != "0")
                                {
                                    //超量程
                                    vicPlayClass.GetVoicePlay(VoiceEnum.车辆超重, CacleCls.lockCarNo);
                                    txtMsgInfo.Text = "当前重量已超量程，秤体量程为【" + AppConfigCache.maxRange + "】T";
                                    led_controler.setStaticLineMsg(AppConfigCache.ledIp, "当前重量已超量程，秤体量程为【" + AppConfigCache.maxRange + "】T");
                                    CacleCls.isLock = false;
                                    return;
                                }
                                iError = 22;
                                if ((CacleCls.topJg == "1" || CacleCls.bottomJg == "1"))
                                {
                                    //重量稳定，且对射验证不合格
                                    vicPlayClass.GetVoicePlay(VoiceEnum.车辆未停到位, CacleCls.lockCarNo);
                                    txtMsgInfo.Text = "车辆超出秤台，请调整车位";
                                    led_controler.setStaticLineMsg(AppConfigCache.ledIp, "车辆超出秤台，请调整车位");
                                    CacleCls.isLock = false;
                                    return;
                                }
                                iError = 23;

                                if (!isVoiceDownCar)
                                {
                                    txtMsgInfo.Text = "";
                                    isVoiceDownCar = true;
                                    vicPlayClass.GetVoicePlay(VoiceEnum.开始计量, CacleCls.lockCarNo);//只播放一次

                                    lg.WriteLog(LogType.SystemLog, CacleCls.lockCarNo + "开始保存：" + DateTime.Now.ToLongTimeString());
                                }
                            }
                            #endregion

                            //计量完成后进行语音播报，提示离开秤台，播报5次
                            if (isMeasureSuccess)
                            {
                                if (voiceNum < AppConfigCache.voiceNum)
                                {
                                    if (CacleCls.voiceOver)
                                    {
                                        vicPlayClass.GetVoicePlay(VoiceEnum.计量完成, CacleCls.lockCarNo);
                                        voiceNum++;
                                    }
                                }
                                return;
                            }
                            iError = 13;
                        }
                        else
                        {
                            iError = 31;
                            voiceNum = 0;
                            isMeasureSuccess = false;
                            lockWgtImg = CacleCls.weight;
                            flagCaption = false;
                            isVoiceDownCar = false;
                            strGuid = "";

                            if (!CacleCls.isClear)
                            {
                                iError = 32;
                                CacleCls.Clear(); //清理一次数据
                                btnSave.Enabled = false;
                                txtCarNo.Text = "";
                                txtMATTER_NAME.Text = "";
                                txtFORWARDING_UNIT_NAME.Text = "";
                                txtRECEIVING_UINT_NAME.Text = "";
                                txtMETER_TYPE.Text = "";
                                txtCarNo.Enabled = true;
                                txtMsgInfo.Text = "";
                                txtGroess.Text = "";
                                txtTare.Text = "";
                                txtNet.Text = "";

                                iError = 33;
                                //释放一次内存
                                FlushMemory();
                                iError = 34;

                                //
                                imgControl.ZipFiles();
                                iError = 35;
                            }
                        }
                    }));
                }
                catch (Exception ex)
                {
                    //在关闭程序后，由于线程还会跑一下，所以会有一个错误“调用方法时发生错误。  目标线程不再存在” 这个不影响
                    lg.WriteLog(LogType.SystemLog, $"主逻辑判断线程，其i值为：{iError}，异常信息为：{ex.Message}");
                }
                Thread.Sleep(AppConfigCache.sleepTime);
            }
        }
        #endregion

        #region 事件部分
        private void PictureBoxDoubleClick(object sender, EventArgs e)
        {
            if (iPic != 0)
            {
                ce.StopRealPlay(iPic);
            }
            PictureBox picture = (PictureBox)sender;
            iPic = Convert.ToInt32(picture.Name.Substring(picture.Name.Length - 1, 1));
            plImgShow.Visible = true;
            ce.RealPlay(pictureShow, iPic);
        }

        private void pictureShow_DoubleClick(object sender, EventArgs e)
        {
            plImgShow.Visible = false;
            ce.StopRealPlay(iPic);
            iPic = 0;
        }

        private void cbJg_CheckedChanged(object sender, EventArgs e)
        {
            CacleCls.isJg = cbJg.Checked;
            btnSave.Enabled = cbJg.Checked;
        }

        private void frmMain_FormClosing(object sender, FormClosingEventArgs e)
        {
            stop();
            try { mx?.ClosingCollect(); } catch { }
            try { rfid?.ClosingCollect(); } catch { }
            try { if (bVoice) ce?.StopTalk(); } catch { }

            foreach (int i in voPlay)
            {
                try { ce?.StopRealPlay(i); } catch { }
            }

            try { plc?.Stop(); } catch { }
            try { ping?.stop(); } catch { }
            try { imgControl?.Stop(); } catch { }
        }

        private void btnOpenVoice_Click(object sender, EventArgs e)
        {
            if (btnOpenVoice.Text == "打开对讲")
            {
                VoiceOpen();
            }
            else
            {
                VoiceClose();
            }
        }

        private void btnSave_Click(object sender, EventArgs e)
        {
            try
            {
                #region 下面是业务逻辑代码
                string msgInfo = "";
                if (txtCarNo.Focused) return; //如果正在修改车号，就必须等光标离开后再保存，否则容易导致车号输入了一半保存了

                if (CacleCls.isWd != 0) return;

                ucWeightT1.setStable(true);    // 重量稳定
                ucWeightT1.setWgt(Math.Round((double)CacleCls.weight / 1000, 2));    // 最新重量
                CacleCls.lockWgt = CacleCls.weight;

                if (!CacleCls.lockWgt.ToString().EndsWith("0")) //个位不是0则说明超量程了
                {
                    //txtMsgInfo.Text = "仪表重量[" + CacleCls.lockWgt + "]不是以0结尾，禁止计量操作！";
                    vicPlayClass.GetVoicePlay(VoiceEnum.车辆超重, CacleCls.lockCarNo);
                    txtMsgInfo.Text = "当前重量已超量程，秤体量程为【" + AppConfigCache.maxRange + "】T";
                    return;
                }

                //接管状态点的保存
                if (!isUseLabelTare && MessageBox.Show("是否确认保存当前计量数据？", "提示", MessageBoxButtons.OKCancel) != DialogResult.OK)
                {
                    return;
                }

                if (string.IsNullOrEmpty(CacleCls.lockCarNo))
                {
                    txtMsgInfo.Text = "没有车号，无法保存";
                    return;
                }
                else if (CacleCls.lockWgt < 1000)
                {
                    txtMsgInfo.Text = "重量过小，无法保存";
                    return;
                }
                else if (CacleCls.isWd != 0)
                {
                    DialogResult dr = MessageBox.Show($"[{CacleCls.lockCarNo}]重量不稳定，请确认是否保存当前计量数据？", "提示", MessageBoxButtons.OKCancel);
                    if (dr == DialogResult.Cancel)
                    {
                        return;
                    }
                }
                else if (CacleCls.topJg == "1" || CacleCls.bottomJg == "1")
                {
                    DialogResult dr = MessageBox.Show($"[{CacleCls.lockCarNo}]未停到位，请确认是否保存当前计量数据？", "提示", MessageBoxButtons.OKCancel);
                    if (dr == DialogResult.Cancel)
                    {
                        return;
                    }
                }
                else
                {
                    lg.WriteLog(LogType.SystemLog, CacleCls.lockCarNo + "接管状态下进行的保存：" + DateTime.Now.ToLongTimeString());
                }

                /*
                //存在零点，且不为接管状态则禁止计量
                if (CacleCls.isZeroState)
                {
                    vicPlayClass.GetVoicePlay(VoiceEnum.仪表未归零, CacleCls.lockCarNo);
                    txtMsgInfo.Text = "仪表未归零，无法计量"; //btnSave_Click
                    led_controler.setStaticLineMsg(AppConfigCache.ledIp, "仪表未归零，无法计量");
                    return;
                }
                //*/

                //车号不是7位，请确认
                if (CacleCls.lockCarNo.Length != 7)
                {
                    DialogResult dr = MessageBox.Show("车号不是7位，请确认是否保存当前计量数据？", "提示", MessageBoxButtons.OKCancel);
                    if (dr == DialogResult.Cancel)
                    {
                        return;
                    }
                }


                CacleCls.firstDb = null;
                ultraGridFirst.UpdateData();
                foreach (UltraGridRow ugr in ultraGridFirst.Rows)
                {
                    if (ugr.Cells["UNCK"].Text.ToUpper() == "TRUE")
                    {
                        CacleCls.firstDb = dataTableFirst.TableToDataList<MeterWorkRailwayActFirst>().Where(s => s.actualFirstNo == ugr.Cells["actualFirstNo"].Text.Trim()).FirstOrDefault();
                        break;
                    }
                }

                ultraGridPre.UpdateData();
                foreach (UltraGridRow ugr in ultraGridPre.Rows)
                {
                    if (ugr.Cells["UNCK"].Text.ToUpper() == "TRUE")
                    {
                        CacleCls.preTrackScale = dataTablePre.TableToDataList<PreRailwayScale>().Where(s => s.predictionNo == ugr.Cells["predictionNo"].Text.Trim()).FirstOrDefault();
                        break;
                    }
                }

                if (CacleCls.firstDb != null && !isUseLabelTare)
                {
                    if (Math.Abs(CacleCls.firstDb.meterWeight.Value - CacleCls.lockWgt) < AppConfigCache.differenceWgt)
                    {
                        DialogResult dr = MessageBox.Show("净重小于" + AppConfigCache.differenceWgt / 1000 + "吨，请确认是否保存当前计量数据？", "提示", MessageBoxButtons.OKCancel);
                        if (dr == DialogResult.Cancel)
                        {
                            return;
                        }
                    }
                }

                lg.WriteLog(LogType.SystemLog, $"锁定车号：{CacleCls.lockCarNo},锁定重量：{CacleCls.lockWgt},rfid编号：{CacleCls.rfidEpc},rfid车号：{CacleCls.rfidCarNo}");

                txtMsgInfo.Text = "称重保存中......";

                CacleCls.isLock = true;
                txtCarNo.Enabled = false;

                strGuid = strGuid == "" ? Guid.NewGuid().ToString() : strGuid;
                #region 截图
                if (!flagCaption)
                {
                    for (int i = 0; i < lc.Count(); i++)
                    {
                        //从_2开始，因为_1是仪表图片  2是车号快照抓拍
                        ce.CapPic((uint)lc[i], $"{AppConfigCache.path}/imgShort/formalImg/{AppConfigCache.pointNo}_C{strGuid}_tempImg_{i + 2}.jpg");
                    }
                    flagCaption = true;
                }

                if (lockWgtImg != CacleCls.lockWgt)
                {
                    lockWgtImg = CacleCls.lockWgt;

                    foreach (Control cn in panel1.Controls)
                    {
                        if (cn.Name.Substring(cn.Name.Length - 1) == $"{AppConfigCache.channel}")
                        {
                            if (cn is PictureBox)
                            {
                                Bitmap bit = new Bitmap(cn.Width, cn.Height);//实例化一个和窗体一样大的bitmap
                                Graphics g = Graphics.FromImage(bit);
                                g.CompositingQuality = CompositingQuality.HighQuality;//质量设为最高 HighQuality
                                g.CopyFromScreen(panel1.Left, panel1.Top + 25, 0, 0, new Size(cn.Width, cn.Height));//保存整个窗体为图片       
                                bit.Save($"{AppConfigCache.path}/imgShort/formalImg/{AppConfigCache.pointNo}_C{strGuid}_tempImg_1.jpg");//默认保存格式为PNG，保存成jpg格式质量不是很好
                                bit.Dispose();
                                break;
                            }
                        }
                    }
                }
                #endregion

                

                if (isUseLabelTare) //如果是用期限皮结净
                {
                    if (CacleCls.serverFlag)
                    {
                        MeterWorkRailwayActFirst firstDb = new MeterWorkRailwayActFirst();
                        CreateFirst(ref firstDb);
                        
                        if (CacleCls.preTrackScale != null)
                        {
                            CacleCls.preTrackScale.format(firstDb);
                        }
                        
                        firstDb.weightType = "0";
                        firstDb.railwayFactoryWeight = Convert.ToDouble((txtTare.Value * 1000).ToString());
                        firstDb.valueFlag = "2";

                        if (firstService.doIdentifyWeight(firstDb).Succeed)
                        {
                            //保存成功
                            isMeasureSuccess = true;
                        }
                        else
                        {
                            vicPlayClass.GetVoicePlay(VoiceEnum.程序处理异常, CacleCls.lockCarNo);
                            led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                            txtMsgInfo.Text = "计量失败写入，本地文件异常：" + msgInfo;
                            lg.WriteLog(LogType.serverLog, "计量失败，写入本地文件异常：" + msgInfo);
                            CacleCls.isLock = false;
                            return;
                        }
                    }
                    else
                    {
                        //断网只有一种结净，就是标识皮结净
                        MeterWorkRailwayActual netDb = new MeterWorkRailwayActual();
                        netDb.baseSpot1No = AppConfigCache.pointNo;
                        netDb.baseSpot1Name = AppConfigCache.pointName;
                        netDb.baseSpot2No = AppConfigCache.pointNo;
                        netDb.baseSpot2Name = AppConfigCache.pointName;
                        netDb.createManNo = "system";
                        netDb.createManName = "system";

                        netDb.railwayTypeNo = AppConfigCache.railwayTypeNo;
                        netDb.railwayTypeName = AppConfigCache.railwayTypeName;
                        netDb.conveyanceType = CacleCls.carType;
                        netDb.railwayNo = CacleCls.lockCarNo;
                        netDb.lcNo = "无列次";
                        netDb.tareWeight = Convert.ToDouble(txtTare.Value);
                        netDb.tareManNo = "system";
                        netDb.tareManName = "system";
                        netDb.tareTime = DateTime.Now;

                        netDb.grossWeight = CacleCls.lockWgt;
                        netDb.grossManNo = "system";
                        netDb.grossManName = "system";
                        netDb.grossTime = DateTime.Now;

                        netDb.netManNo = "system";
                        netDb.netManName = "system";
                        netDb.netTime = DateTime.Now;
                        netDb.netWeight = Convert.ToDouble(CacleCls.lockWgt - txtTare.Value);

                        netDb.dataSource = "3";
                        netDb.noticeNo = $"{ip},{Thread.CurrentThread.Name}";

                        if (FileOption.WriterDb(netDb, FileTypeEnum.结净数据, out string msg))
                        {
                            //保存成功
                            isMeasureSuccess = true;
                        }
                        else 
                        {
                            vicPlayClass.GetVoicePlay(VoiceEnum.程序处理异常, CacleCls.lockCarNo);
                            lg.WriteLog(LogType.SystemLog, "计量失败1：" + msg);
                            CacleCls.isLock = false;
                        }
                    }
                }
                else //非期限皮结净
                {
                    if (CacleCls.serverFlag)
                    {
                        if (cbSetFirst.Checked) //保存一次计量数据
                        {
                            MeterWorkRailwayActFirst firstDb = new MeterWorkRailwayActFirst();
                            CreateFirst(ref firstDb);

                            if (CacleCls.preTrackScale != null)
                            {
                                CacleCls.preTrackScale.format(firstDb);
                            }

                            if (firstService.add(firstDb).Succeed)
                            {
                                //保存成功
                                isMeasureSuccess = true;
                            }
                            else
                            {
                                vicPlayClass.GetVoicePlay(VoiceEnum.程序处理异常, CacleCls.lockCarNo);
                                led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                                txtMsgInfo.Text = "计量失败写入，本地文件异常：" + msgInfo;
                                lg.WriteLog(LogType.serverLog, "计量失败，写入本地文件异常：" + msgInfo);
                                CacleCls.isLock = false;
                                return;
                            }
                        }
                        else
                        {
                            //勾选了一次计量数据，勾选了预报数据

                            //勾选了一次计量数据，未勾选预报数据

                            //未勾选一次计量数据，未勾选预报数据，勾选自动结净

                            //未勾选一次计量数据，未勾选预报数据，未勾选自动结净
                        }
                    }
                    else //没网络统一写一次数据
                    {
                        MeterWorkRailwayActFirst firstDb = new MeterWorkRailwayActFirst();
                        CreateFirst(ref firstDb);

                        if (FileOption.WriterDb(firstDb, FileTypeEnum.一次数据, out string msg))
                        {
                            isMeasureSuccess = true;
                        }
                        else
                        {
                            vicPlayClass.GetVoicePlay(VoiceEnum.程序处理异常, CacleCls.lockCarNo);
                            led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                            txtMsgInfo.Text = "计量失败写入，本地文件异常：" + msgInfo;
                            lg.WriteLog(LogType.serverLog, "计量失败，写入本地文件异常：" + msgInfo);
                            CacleCls.isLock = false;
                            return;
                        }
                    }
                }








                //计量成功
                if (isMeasureSuccess)
                {
                    txtMsgInfo.Text = "计量完成";
                    #region 毛皮净赋值
                    if (CacleCls.firstDb != null && CacleCls.firstDb.meterWeight > 0 && CacleCls.lockWgt > 0)
                    {
                        if (CacleCls.firstDb.meterWeight > CacleCls.lockWgt)
                        {
                            txtGroess.Text = $"{CacleCls.firstDb.meterWeight / 1000}";
                            txtTare.Text = $"{CacleCls.lockWgt / 1000}";
                            txtNet.Text = $"{(CacleCls.firstDb.meterWeight - CacleCls.lockWgt) / 1000}";
                        }
                        else
                        {
                            txtGroess.Text = $"{CacleCls.lockWgt / 1000}";
                            txtTare.Text = $"{CacleCls.firstDb.meterWeight / 1000}";
                            txtNet.Text = $"{(CacleCls.lockWgt - CacleCls.firstDb.meterWeight) / 1000}";
                        }
                    }

                    if (!string.IsNullOrEmpty(CacleCls.LEDResultMessage))
                    {
                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, CacleCls.LEDResultMessage);
                    }
                    #endregion

                    //屏幕截图操作
                    _ = BeginInvoke(new Action(() => { shotImageScreen(strGuid); }));


                    BindTable<PreRailwayScale>(ultraGridWaitFirst, dataTableWaitFirst, "firstWait");
                    BindTable<MeterWorkRailwayActual>(ultraGridWaitNet, dataTableWaitNet, "netWait");
                    BindTable<MeterWorkRailwayActFirst>(ultraGridLocalFirst, dataTableWaitFirst, "localFirst");
                    BindTable<MeterWorkRailwayActual>(ultraGridLocalNet, dataTableWaitNet, "localNet");
                }
                #endregion
            }
            catch (Exception ex)
            {
                vicPlayClass.GetVoicePlay(VoiceEnum.程序处理异常, CacleCls.lockCarNo);
                lg.WriteLog(LogType.SystemLog, "计量失败1：" + ex.Message);
                CacleCls.isLock = false;
            }
        }

        bool isUseLabelTare = false;
        private void btnTareSaveOver_Click(object sender, EventArgs e)
        {
            if (txtTare.Value < 1)
            {
                MessageBox.Show("请输入皮重");
                txtTare.Focus();
                return;
            }

            if (CacleCls.weight - txtTare.Value <= 0)
            {
                MessageBox.Show("结净重量过小无法结净");
                txtTare.Focus();
                return;
            }

            if (MessageBox.Show("是否确认保存当前计量数据？", "提示", MessageBoxButtons.OKCancel) != DialogResult.OK)
            {
                return;
            }

            if (CacleCls.weight - txtTare.Value < AppConfigCache.differenceWgt)
            {
                DialogResult dr = MessageBox.Show("净重小于" + AppConfigCache.differenceWgt / 1000 + "吨，请确认是否保存当前计量数据？", "提示", MessageBoxButtons.OKCancel);
                if (dr == DialogResult.Cancel)
                {
                    return;
                }
            }

            txtMsgInfo.Text = "";
            isUseLabelTare = true;
            btnSave.PerformClick();
        }
        
        #endregion

        #region 绑定数据
        private void BindTable<T>(UltraGrid ug, DataTable dtDatabase, string sType)
        {
            bool bReadFlag = false;
            string strRtMsgInfo = "";
            List<T> lm = null;
            DataTable dtV = dtDatabase.Clone();
            
            switch (sType)
            {
                case "first":
                    if (CacleCls.serverFlag)
                    {
                        rmRailwayFirstList = firstService.doQueryWf(new MeterWorkRailwayActFirst { railwayTypeNo = "001019001", railwayNo = CacleCls.lockCarNo, valueFlag = "1", pageNum = 1, pageSize = 50 });
                        if (rmRailwayFirstList.Succeed)
                        {
                            lm = rmRailwayFirstList.Data as List<T>;
                            flagQF = true;
                        }
                        else
                        {
                            txtMsgInfo.Text = $"获取一次计量数据异常：{rmRailwayFirstList.ResultMessage}";
                        }
                    };
                    break;
                case "pre":
                    if (CacleCls.serverFlag)
                    {
                        rmRailwayScaleList = preService.doQueryTenWf(new PreRailwayScale { railwayNo = CacleCls.lockCarNo });
                        if (rmRailwayScaleList.Succeed)
                        {
                            lm = rmRailwayScaleList.Data as List<T>;
                            flagQP = true;
                        }
                        else
                        {
                            txtMsgInfo.Text = $"获取预报数据异常：{rmRailwayScaleList.ResultMessage}";
                        }
                    };
                    break;
                case "localFirst":
                    lm = FileOption.ReadDb<T>(FileTypeEnum.一次数据, ref bReadFlag, ref strRtMsgInfo);
                    break;
                case "localNet":
                    lm = FileOption.ReadDb<T>(FileTypeEnum.结净数据, ref bReadFlag, ref strRtMsgInfo);
                    break;
                case "firstWait":
                    if (CacleCls.serverFlag)
                    {
                        rmWaitFirstList = firstService.getWaitSubmitBySpotNo(new MeterWorkRailwayActFirst { baseSpotNo = AppConfigCache.pointNo, flag = "1", createTime1 = DateTime.Now.AddDays(-1).ToString("yyyy-MM-dd HH:mm:ss"), createTime2 = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") });
                        if (rmWaitFirstList.Succeed)
                        {
                            lm = rmWaitFirstList.Data as List<T>;
                            flagQP = true;
                        }
                        else
                        {
                            txtMsgInfo.Text = $"获取待提交一次计量数据异常：{rmWaitFirstList.ResultMessage}";
                        }
                    };
                    break;
                case "netWait":
                    if (CacleCls.serverFlag)
                    {
                        rmWaitNetList = netService.getWaitSubmitBySpotNo(new MeterWorkRailwayActual { netSpot3No = AppConfigCache.pointNo, flag = "1", startTime = DateTime.Now.AddDays(-1).ToString("yyyy-MM-dd HH:mm:ss"), endTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") });
                        if (rmWaitNetList.Succeed)
                        {
                            lm = rmWaitNetList.Data as List<T>;
                            flagQP = true;
                        }
                        else
                        {
                            txtMsgInfo.Text = $"获取待提交结净计量数据异常：{rmWaitNetList.ResultMessage}";
                        }
                    };
                    break;
            }
            

            if (lm != null && lm.Count > 0)
            {
                dtV = lm.ListToDataTable<T>();
            }
            ClsControlPack.CopyDataToDatatable(ref dtV, ref dtDatabase, true);
            ClsControlPack.RefreshAndAutoSize(ug);
        }

        bool flagQF = true, flagQP = true;
        private void ultraGridPre_AfterRowActivate(object sender, EventArgs e)
        {
            if (!flagQP) 
            {
                UltraGridRow ugr = ultraGridPre.ActiveRow;
                if (ugr != null)
                {
                    try
                    {
                        foreach (UltraGridRow ugrc in ultraGridPre.Rows)
                        {
                            ugrc.Cells["UNCK"].Value = false;
                        }
                        ugr.Cells["UNCK"].Value = !(bool)ugr.Cells["UNCK"].Value; //选择筛选栏的时候，这里会报错，所以捕获下异常
                    }
                    catch { }
                }
            }
            flagQP = false;
        }

        private void ultraGridFirst_AfterRowActivate(object sender, EventArgs e)
        {
            if (!flagQF) 
            {
                UltraGridRow ugr = ultraGridFirst.ActiveRow;
                if (ugr != null)
                {
                    try
                    {
                        foreach (UltraGridRow ugrc in ultraGridFirst.Rows)
                        {
                            ugrc.Cells["UNCK"].Value = false;
                        }
                        ugr.Cells["UNCK"].Value = !(bool)ugr.Cells["UNCK"].Value; //选择筛选栏的时候，这里会报错，所以捕获下异常

                    }
                    catch { }
                }
            }
            flagQF=false;
        }

        private void ultraGridWaitFirst_AfterRowActivate(object sender, EventArgs e)
        {
            UltraGridRow ugr = ultraGridWaitFirst.ActiveRow;
            if (ugr != null)
            {
                try
                {
                    ugr.Cells["UNCK"].Value = !(bool)ugr.Cells["UNCK"].Value; //选择筛选栏的时候，这里会报错，所以捕获下异常
                }
                catch { }
            }
        }

        private void cbFirstWait_CheckedChanged(object sender, EventArgs e)
        {
            foreach (UltraGridRow ugrc in ultraGridWaitFirst.Rows)
            {
                ugrc.Cells["UNCK"].Value = cbFirstWait.Checked;
            }
        }

        private void ultraGridWaitNet_AfterRowActivate(object sender, EventArgs e)
        {
            UltraGridRow ugr = ultraGridWaitNet.ActiveRow;
            if (ugr != null)
            {
                try
                {
                    ugr.Cells["UNCK"].Value = !(bool)ugr.Cells["UNCK"].Value; //选择筛选栏的时候，这里会报错，所以捕获下异常
                }
                catch { }
            }
        }

        private void cbNetWait_CheckedChanged(object sender, EventArgs e)
        {
            foreach (UltraGridRow ugrc in ultraGridWaitNet.Rows)
            {
                ugrc.Cells["UNCK"].Value = cbNetWait.Checked;
            }
        }

        private void btnSubmitFirstWait_Click(object sender, EventArgs e)
        {
            ultraGridWaitFirst.UpdateData();


        }

        private void btnNetSubmit_Click(object sender, EventArgs e)
        {
            ultraGridWaitNet.UpdateData();


        }

        private void txtCarNo_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter) label3.Focus();
        }
        #endregion

        #region 截图
        /// <summary>
        /// 终端截图(临时截图，使用临时ID存储)
        /// </summary>
        public void shotImageScreen(string strActualFirstNo)
        {
            try
            {
                #region 截取图片信息
                //截取屏幕信息
                Point screenPoint = plCaptionMain.PointToScreen(new Point());
                Rectangle rect = new Rectangle(screenPoint, plCaptionMain.Size);
                Image img = new Bitmap(plCaptionMain.Width, plCaptionMain.Height);
                Graphics g = Graphics.FromImage(img);
                g.CopyFromScreen(rect.X - 1, rect.Y - 1, 0, 0, rect.Size);//"D://file/1.jpg"
                img.Save(string.Format("{0}imgShort\\formalImg\\{1}_{2}_tempImg_{3}.jpg",
                    AppDomain.CurrentDomain.SetupInformation.ApplicationBase,
                    AppConfigCache.pointNo, "C" + strActualFirstNo, 7), System.Drawing.Imaging.ImageFormat.Jpeg);

                //lg.WriteLog(35, "完成截图    成功标识：" + PbCache.shotSuccess.ToString() + "车号：" + PbCache.lockCarNo + "；重量：" + PbCache.lockWgt + "；时间：" + DateTime.Now.ToLongTimeString());
                #endregion 截取图片信息
            }
            catch (Exception ex)
            {
                lg.WriteLog(LogType.SystemLog, "计量完成，但图片截取失败，编号：" + strActualFirstNo);
            }
        }
        #endregion

        #region 释放内存
        [DllImport("kernel32.dll")]
        private static extern bool SetProcessWorkingSetSize(IntPtr process, int minSize, int maxSize);

        private void cbSetFirst_CheckedChanged(object sender, EventArgs e)
        {

        }

        //刷新存储器
        private static void FlushMemory()
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
            {
                SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle, -1, -1);
            }
        }
        #endregion


        #region
        private void CreateFirst(ref MeterWorkRailwayActFirst mwraf)
        {
            mwraf.meterWeight = CacleCls.lockWgt;
            mwraf.railwayNo = CacleCls.lockCarNo;
            mwraf.conveyanceType = CacleCls.carType;
            mwraf.lcNo = "无列次";
            mwraf.createManNo = "system";
            mwraf.createManName = "system";
            mwraf.createTime = DateTime.Now;
            mwraf.baseSpotNo = AppConfigCache.pointNo;
            mwraf.baseSpotName = AppConfigCache.pointName;
            mwraf.railwayTypeNo = AppConfigCache.railwayTypeNo;
            mwraf.railwayTypeName = AppConfigCache.railwayTypeName;
            mwraf.meterMode = "1";
            mwraf.dataSource = "1";
            mwraf.checkFlag = "0";
            mwraf.noticeNo = $"{ip},{Thread.CurrentThread.Name}";
            if (isUseLabelTare)
            {
                mwraf.railwayFactoryWeight = Convert.ToDouble(txtTare.Value.ToString());
            }
        }
        #endregion
    }
}