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>
        RfidRailWayNo rfid = new RfidRailWayNo();

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

        /// <summary>
        /// 本地离线计量的数据上传
        /// </summary>
        DbUpload upload = new DbUpload();

        /// <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;


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

        private void frmMain_Load(object sender, EventArgs e)
        {
            BindTable<MeterWorkRailwayActFirst>(ultraGridFirst, dataTableFirst, "firstx");
            BindTable<PreRailwayScale>(ultraGridPre, dataTablePre, "prex");

            CacleCls.Clear(); //清理一次数据
            btnSave.Enabled = false;
            txtCarNo.Text = "";
            txtMATTER_NAME.Text = "";
            txtFORWARDING_UNIT_NAME.Text = "";
            txtRECEIVING_UINT_NAME.Text = "";
            txtMETER_TYPE.Text = "";
            txtMsgInfo.Text = "";
            txtGroess.Text = "";
            txtTare.Text = "";
            txtNet.Text = "";
            txtMsgInfo.Focus();



            txtMsgInfo.Focus();
            if (AppConfigCache.openCom == "0")
            {
                rfid.StartThreadSweep(out string msg);
                if (!string.IsNullOrEmpty(msg))
                {
                    MessageBox.Show(msg);
                    return;
                }
            }

            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) && AppConfigCache.ledStart == "0")
            {
                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();
            imgControl.Start();
            upload.start();

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

            BindTable<MeterWorkRailwayActFirst>(ultraGridLocalFirst, dataTableLocalFirst, "localFirst");
            BindTable<MeterWorkRailwayActual>(ultraGridLocalNet, dataTableLocalNet, "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 isVoiceDownCar = false;
        string strOldCarNo = "";
        bool isMeasureSuccess = false;
        string strFinishCarNo = "";//计量成功的车号
        int voiceNum = 0;


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

        private void stop() => blThreadFlag = false;

        bool flagQuery = false;
        private void DataCollect()
        {
            if (!blThreadFlag) return;
            int iError = 0;

            bool bClear = false;
            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 (CacleCls.isWd == 0)
                        {
                            bClear = false;
                            //bCl = false;
                            if (!string.IsNullOrEmpty(CacleCls.rfidCarNo))
                            {
                                if (CacleCls.rfidCarNo.Length > 14)
                                {
                                    string strRailNo = CacleCls.rfidCarNo.Substring(7, 7);
                                    if (strRailNo.Trim().Length == 7)
                                    {
                                        if (strFinishCarNo != strRailNo || CacleCls.isJg && !isEditRailwayNo)
                                        {
                                            CacleCls.lockCarNo = strRailNo;
                                            CacleCls.carType = CacleCls.rfidCarNo.Substring(1, 5).Trim().ToUpper();
                                        }
                                    }
                                }
                            }
                        }
                        else if (CacleCls.lockWgt > 1000) //有计量过的重量
                        {
                            if (Math.Abs(CacleCls.lockWgt - CacleCls.weight) > AppConfigCache.changeWgt) 
                            {
                                isEditRailwayNo = false;
                                isMeasureSuccess = false;
                                CacleCls.lockCarNo = ""; //清理下数据
                                CacleCls.carType = "";
                                txtCarNo.Text = "";
                                txtMsgInfo.Focus();

                                BindTable<MeterWorkRailwayActFirst>(ultraGridFirst, dataTableFirst, "firstx");

                                //查询预报数据
                                BindTable<PreRailwayScale>(ultraGridPre, dataTablePre, "prex");
                            }
                        }
                        else //从未计量过，假如有车号不需要管
                        {
                            if (!CacleCls.isJg&& !bClear) 
                            {
                                bClear = true;
                                txtCarNo.Text = "";

                                BindTable<MeterWorkRailwayActFirst>(ultraGridFirst, dataTableFirst, "firstx");

                                //查询预报数据
                                BindTable<PreRailwayScale>(ultraGridPre, dataTablePre, "prex");
                                txtMsgInfo.Focus();
                            }
                        }

                        if (!string.IsNullOrEmpty(CacleCls.lockCarNo))
                        {
                            txtCarNo.Text = CacleCls.lockCarNo;
                        }

                        

                        if (strOldCarNo != CacleCls.lockCarNo)
                        {
                            txtMsgInfo.Text = "";//车号不同的情况下清理下保存按钮
                            isUseLabelTare = false;
                            strOldCarNo = CacleCls.lockCarNo;
                            flagQuery = false;
                            CacleCls.isLock = false;//车号不同了则不锁定
                            voiceNum = 0;
                            isMeasureSuccess = 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;
                            CacleCls.isClear = false;

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


                                    if (CacleCls.lockCarNo.Length != 7)
                                    {
                                        txtMsgInfo.Text = "车号不为7位";
                                        vicPlayClass.GetVoicePlay(VoiceEnum.车号未识别, "");
                                        led_controler?.setStaticLineMsg(AppConfigCache.ledIp, "车号不为7位");
                                        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());
                                }
                                if (CacleCls.lockCarNo == strFinishCarNo && isMeasureSuccess)
                                {
                                    return; //如果车号相同，且计量成功了，那么此时不应该触发自动计量
                                }
                                btnSave_Click(null, null);
                            }
                            #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;
                            isVoiceDownCar = false;

                            if (!CacleCls.isClear)
                            {
                                BindTable<MeterWorkRailwayActFirst>(ultraGridFirst, dataTableFirst, "firstx");
                                BindTable<PreRailwayScale>(ultraGridPre, dataTablePre, "prex");
                                
                                iError = 32;
                                CacleCls.Clear(); //清理一次数据
                                btnSave.Enabled = false;
                                txtCarNo.Text = "";
                                txtMATTER_NAME.Text = "";
                                txtFORWARDING_UNIT_NAME.Text = "";
                                txtRECEIVING_UINT_NAME.Text = "";
                                txtMETER_TYPE.Text = "";
                                txtMsgInfo.Text = "";
                                txtGroess.Text = "";
                                txtTare.Text = "";
                                txtNet.Text = "";
                                txtMsgInfo.Focus();

                                iError = 33;
                                //释放一次内存
                                FlushMemory();
                                iError = 34;
                            }
                        }
                    }));
                }
                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?.CloseThread(); } catch { }
            try { if (bVoice) ce?.StopTalk(); } catch { }
            try { upload?.stop(); } 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
            {
                isMeasureSuccess = false;

                #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 (CacleCls.isJg)
                {
                    //接管状态点的保存
                    if (!isUseLabelTare && MessageBox.Show("是否确认保存当前计量数据？", "提示", MessageBoxButtons.OKCancel) != DialogResult.OK)
                    {
                        return;
                    }

                    if (string.IsNullOrEmpty(CacleCls.lockCarNo))
                    {
                        txtMsgInfo.Text = "没有车号，无法保存";
                        return;
                    }

                    if (CacleCls.lockWgt < 1000)
                    {
                        txtMsgInfo.Text = "重量过小，无法保存";
                        return;
                    }

                    if (CacleCls.isWd != 0)
                    {
                        DialogResult dr = MessageBox.Show($"[{CacleCls.lockCarNo}]重量不稳定，请确认是否保存当前计量数据？", "提示", MessageBoxButtons.OKCancel);
                        if (dr == DialogResult.Cancel)
                        {
                            return;
                        }
                    }

                    if (CacleCls.topJg == "1" || CacleCls.bottomJg == "1")
                    {
                        DialogResult dr = MessageBox.Show($"[{CacleCls.lockCarNo}]未停到位，请确认是否保存当前计量数据？", "提示", MessageBoxButtons.OKCancel);
                        if (dr == DialogResult.Cancel)
                        {
                            return;
                        }
                    }

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


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


                CacleCls.firstDb = null;
                CacleCls.preTrackScale = null;
                //如果是自动计量的，只保存一次数据，且不匹配预报
                if (CacleCls.isJg)
                {
                    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;

                string strGuid = Guid.NewGuid().ToString();

                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);
                        firstDb.valueFlag = "2";
                        if (string.IsNullOrEmpty(firstDb.railwayNo)) 
                        {
                            firstDb.railwayNo = "车号未识别";
                        }

                        RESTfulResult<ResponseData> rt = firstService.doIdentifyWeight(firstDb, out msgInfo);
                        if (rt.Succeed)
                        {
                            //保存成功
                            isMeasureSuccess = true;
                            CaptionImg(rt.Data.actuals[0].actualFirst1No);
                        }
                        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.actualNo = strGuid;
                        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 * 1000);
                        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 * 1000);

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

                        if (FileOption.WriterDb(netDb, FileTypeEnum.结净数据, out string msg))
                        {
                            //保存成功
                            isMeasureSuccess = true;
                            CaptionImg(strGuid);
                        }
                        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 (string.IsNullOrEmpty(firstDb.railwayNo))
                            {
                                firstDb.railwayNo = "车号未识别";
                            }

                            RESTfulResult<ResponseData> rt = firstService.add(firstDb, out msgInfo);
                            if (rt.Succeed)
                            {
                                //保存成功
                                isMeasureSuccess = true;
                                CaptionImg(rt.Data.firsts[0].actualFirstNo);
                            }
                            else
                            {
                                vicPlayClass.GetVoicePlay(VoiceEnum.程序处理异常, CacleCls.lockCarNo);
                                led_controler?.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                                txtMsgInfo.Text = "计量失败写入，本地文件异常：" + msgInfo;
                                lg.WriteLog(LogType.serverLog, "计量失败，写入本地文件异常：" + msgInfo);
                                CacleCls.isLock = false;
                                return;
                            }
                        }
                        else
                        {
                            //上面对是否勾选接自助计量做了判断，如果勾选了这个CacleCls.firstDb就不会赋值，所以一定为null
                            if (CacleCls.firstDb != null)
                            {
                                //存结净数据

                                MeterWorkRailwayActFirst mwraf = new MeterWorkRailwayActFirst();
                                CreateFirst(ref mwraf);

                                if (string.IsNullOrEmpty(mwraf.railwayNo))
                                {
                                    mwraf.railwayNo = "车号未识别";
                                }

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

                                CacleCls.firstDb.valueFlag = "2";
                                CacleCls.firstDb.dataSource = "3";
                                CacleCls.firstDb.checkFlag = "0";

                                MeterWorkRailwayActFirst gross = null;
                                MeterWorkRailwayActFirst tare = null;

                                if (mwraf.meterWeight > CacleCls.firstDb.meterWeight)
                                {
                                    mwraf.weightType = "0";
                                    CacleCls.firstDb.weightType = "1";
                                    gross = mwraf;
                                    tare = CacleCls.firstDb;
                                }
                                else
                                {
                                    mwraf.weightType = "1";
                                    CacleCls.firstDb.weightType = "0";
                                    tare = mwraf;
                                    gross = CacleCls.firstDb;
                                }

                                RESTfulResult<ResponseData> rt = firstService.doAddWfStaticTwo(CacleCls.preTrackScale, gross, tare, out msgInfo);
                                if (rt.Succeed)
                                {
                                    isMeasureSuccess = true; //保存成功
                                    CaptionImg(rt.Data.firsts[0].actualFirstNo);
                                }
                                else
                                {
                                    vicPlayClass.GetVoicePlay(VoiceEnum.程序处理异常, CacleCls.lockCarNo);
                                    led_controler?.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                                    txtMsgInfo.Text = "计量失败写入，本地文件异常：" + msgInfo;
                                    lg.WriteLog(LogType.serverLog, "计量失败，写入本地文件异常：" + msgInfo);
                                    CacleCls.isLock = false;
                                    return;
                                }
                            }
                            else
                            {
                                //存一次计量数据
                                MeterWorkRailwayActFirst firstDb = new MeterWorkRailwayActFirst();
                                CreateFirst(ref firstDb);
                                if (CacleCls.preTrackScale != null)
                                {
                                    CacleCls.preTrackScale.format(firstDb);
                                }

                                RESTfulResult<ResponseData> rt = firstService.add(firstDb, out msgInfo);
                                if (rt.Succeed)
                                {
                                    //保存成功
                                    isMeasureSuccess = true;
                                    CaptionImg(rt.Data.firsts[0].actualFirstNo);
                                }
                                else
                                {
                                    vicPlayClass.GetVoicePlay(VoiceEnum.程序处理异常, CacleCls.lockCarNo);
                                    led_controler?.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                                    txtMsgInfo.Text = "计量失败写入，本地文件异常：" + msgInfo;
                                    lg.WriteLog(LogType.serverLog, "计量失败，写入本地文件异常：" + msgInfo);
                                    CacleCls.isLock = false;
                                    return;
                                }

                            }
                        }
                    }
                    else //没网络统一写一次数据
                    {
                        MeterWorkRailwayActFirst firstDb = new MeterWorkRailwayActFirst();
                        CreateFirst(ref firstDb);
                        firstDb.actualFirstNo = strGuid;
                        if (FileOption.WriterDb(firstDb, FileTypeEnum.一次数据, out string msg))
                        {
                            isMeasureSuccess = true;
                            CaptionImg(strGuid);
                        }
                        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)
                {
                    strFinishCarNo = txtCarNo.Text.Trim();
                    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

                    txtMsgInfo.Focus();


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


        private void CaptionImg(string actNo) 
        {
            #region 截图
            //屏幕截图操作
            //_ = BeginInvoke(new Action(() => { shotImageScreen(actNo); }));

            for (int i = 0; i < lc.Count(); i++)
            {
                //从_2开始，因为_1是仪表图片  2是车号快照抓拍
                ce.CapPic((uint)lc[i], $"{AppConfigCache.path}/imgShort/formalImg/{AppConfigCache.pointNo}_R{actNo}{(CacleCls.serverFlag?"":"_tempImg")}_{i + 2}.jpg");
            }

            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}_R{actNo}{(CacleCls.serverFlag ? "" : "_tempImg")}_1.jpg");//默认保存格式为PNG，保存成jpg格式质量不是很好
                        bit.Dispose();
                        break;
                    }
                }
            }
            #endregion
        }



        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 * 1000 <= 0)
            {
                MessageBox.Show("结净重量过小无法结净");
                txtTare.Focus();
                return;
            }

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

            if (CacleCls.weight - txtTare.Value * 1000 < AppConfigCache.differenceWgt)
            {
                DialogResult dr = MessageBox.Show("净重小于" + AppConfigCache.differenceWgt / 1000 + "吨，请确认是否保存当前计量数据？", "提示", MessageBoxButtons.OKCancel);
                if (dr == DialogResult.Cancel)
                {
                    return;
                }
            }
            voiceNum = 0;
            isMeasureSuccess = false;
            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", startTime = DateTime.Now.AddDays(-1).ToString("yyyy-MM-dd HH:mm:ss"), endTime = 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>();

                List<string> ls = new List<string>();
                foreach (DataColumn dc in dtV.Columns) 
                {
                    if (dc.ColumnName == "meterWeight"|| dc.ColumnName == "grossWeight" || dc.ColumnName == "tareWeight" || dc.ColumnName == "netWeight") 
                    {
                        ls.Add(dc.ColumnName);
                    }
                }

                foreach (DataRow dr in dtV.Rows) 
                {
                    foreach (string str in ls) 
                    {
                        if (!string.IsNullOrEmpty(dr[str]?.ToString())) 
                        {
                            dr[str] = Convert.ToDouble(dr[str]) / 1000;
                        }
                    }
                }
            }
            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();
            if (dataTableWaitFirst != null && dataTableWaitFirst.Rows.Count > 0) 
            {
                List<MeterWorkRailwayActFirst> ltAdd = new List<MeterWorkRailwayActFirst>();
                List<MeterWorkRailwayActFirst> lt = dataTableWaitFirst.TableToDataList<MeterWorkRailwayActFirst>();
                foreach (UltraGridRow ugr in ultraGridWaitFirst.Rows)
                {
                    if (ugr.Cells["UNCK"].Value.ToString().ToUpper() == "TRUE") 
                    {
                        MeterWorkRailwayActFirst first = lt.Where(s=>s.actualFirstNo== ugr.Cells["actualFirstNo"].Text.Trim()).FirstOrDefault();
                        if (first != null) ltAdd.Add(first);
                    }
                }

                if (ltAdd.Count > 0) 
                {
                    if (firstService.BatchUpdateLcNo(ltAdd,out string msgInfo).Succeed)
                    {
                        isMeasureSuccess = true; //保存成功
                        MessageBox.Show("操作成功");
                    }
                    else
                    {
                        MessageBox.Show("操作失败：" + msgInfo);
                        lg.WriteLog(LogType.serverLog, "操作失败：" + msgInfo);
                    }
                }
            }
        }

        private void btnNetSubmit_Click(object sender, EventArgs e)
        {
            //先提交一次，然后再提交结净。按目前的搞法是如此
            btnSubmitFirstWait_Click(null, null);

            ultraGridWaitNet.UpdateData();
            if (dataTableWaitNet != null && dataTableWaitNet.Rows.Count > 0)
            {
                List<MeterWorkRailwayActual> ltAdd = new List<MeterWorkRailwayActual>();
                List<MeterWorkRailwayActual> lt = dataTableWaitNet.TableToDataList<MeterWorkRailwayActual>();
                foreach (UltraGridRow ugr in ultraGridWaitNet.Rows)
                {
                    if (ugr.Cells["UNCK"].Value.ToString().ToUpper() == "TRUE")
                    {
                        MeterWorkRailwayActual net = lt.Where(s => s.actualNo == ugr.Cells["actualNo"].Text.Trim()).FirstOrDefault();
                        if (net != null) ltAdd.Add(net);
                    }
                }

                if (ltAdd.Count > 0)
                {
                    if (netService.BatchUpdateLcNo(ltAdd, out string msgInfo).Succeed)
                    {
                        isMeasureSuccess = true; //保存成功
                        MessageBox.Show("操作成功");
                    }
                    else
                    {
                        MessageBox.Show("操作失败：" + msgInfo);
                        lg.WriteLog(LogType.serverLog, "操作失败：" + msgInfo);
                    }
                }
            }

        }

        bool isEditRailwayNo = false;
        private void txtCarNo_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                if (txtCarNo.Text.Trim().Length > 0)
                {
                    CacleCls.lockCarNo = txtCarNo.Text.Trim();
                    isEditRailwayNo = true;
                    txtMsgInfo.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);
            }
        }

        private void txtCarNo_TextChanged(object sender, EventArgs e)
        {

        }
        #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 = "3";
            mwraf.checkFlag = "0";
            mwraf.noticeNo = $"{ip},{Thread.CurrentThread.Name}";
            if (isUseLabelTare)
            {
                mwraf.railwayFactoryWeight = Convert.ToDouble(txtTare.Value * 1000);
            }
        }
        #endregion
    }
}