jisco_winform_wzjl/CarLocalMeter/frmMain.cs

using com.hnshituo.core.webapp.vo;
using Newtonsoft.Json;
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.NetworkInformation;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

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

        Log lg = Log.GetInstance();

        private LED_Control led_controler;

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

        /// <summary>
        /// 服务端委托获取
        /// </summary>
        private PreTrackScaleService PreTrackScaleService = new PreTrackScaleService();
        RESTfulResult<List<PreTrackScale>> rmScaleListCarTimer = new RESTfulResult<List<PreTrackScale>>();
        private MeterWorkCarActualFirstService workCarActualFirstService = new MeterWorkCarActualFirstService(); //一次计量数据
        RESTfulResult<List<MeterWorkCarActualFirst>> RESTfulResultOutTimer = new RESTfulResult<List<MeterWorkCarActualFirst>>();
        

        PlcCls plc = new PlcCls();

        /// <summary>
        /// redis操作类
        /// </summary>
        RedisOption redis = new RedisOption();

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

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

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

        /// <summary>
        /// 摄像头车号识别枪机
        /// </summary>
        CarNoCls carCls = new CarNoCls();

        /// <summary>
        /// 摄像头识别球机
        /// </summary>
        CarNoCls carCls2 = new CarNoCls();

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

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


        private void frmMain_Load(object sender, EventArgs e)
        {
            CacleCls.updateRfidInfoTime = DateTime.Now;

            btnSave.Enabled = false;
            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();
            upload.start();
            mx.start();
            rfid.Start();
            imgControl.Start();
            carCls.Login(AppConfigCache.voiceCarNoIp, AppConfigCache.voiceCarNoPort, AppConfigCache.voiceCarNoUid, AppConfigCache.voiceCarNoPwd);
            //*/
            if (AppConfigCache.openVoice.Contains("2")) 
            {
                carCls2.Login(AppConfigCache.voiceCarNoIp2, AppConfigCache.voiceCarNoPort2, AppConfigCache.voiceCarNoUid2, AppConfigCache.voiceCarNoPwd2, false);
            }
            //

            blThreadFlag = true;
            DataCollectThread = new Thread(new ThreadStart(DataCollect));
            start();
            txtMsgInfo.Focus();
        }

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

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

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

        private void stop() => blThreadFlag = false;

        private void DataCollect()
        {
            if (!blThreadFlag) return;
            int iError = 0;
            while (blThreadFlag)
            {
                try 
                {
                    this.panel3.Invoke(new Action(() => {
                        if (!CacleCls.isLock)
                        {
                            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 (cbCarNo.Text.Trim() != "" && txtCarNo.Text.Trim() != "" && !txtCarNo.Focused)
                            {
                                CacleCls.lockCarNo = cbCarNo.Text.Trim() + txtCarNo.Text.Trim();
                            }
                            else if (!string.IsNullOrEmpty(CacleCls.rfidCarNo))
                            {
                                CacleCls.lockCarNo = CacleCls.rfidCarNo;
                            }
                            else if (!string.IsNullOrEmpty(CacleCls.voicCarNo))
                            {
                                CacleCls.lockCarNo = CacleCls.voicCarNo;
                            }
                            else if (!string.IsNullOrEmpty(CacleCls.voicCarNo2))
                            {
                                CacleCls.lockCarNo = CacleCls.voicCarNo2;
                            }

                            if (!string.IsNullOrEmpty(CacleCls.lockCarNo) && cbCarNo.Text.Trim() == "" && txtCarNo.Text.Trim() == "")
                            {
                                cbCarNo.Text = CacleCls.lockCarNo.Substring(0, 1);
                                if (CacleCls.lockCarNo.Length > 1)
                                {
                                    txtCarNo.Text = CacleCls.lockCarNo.Substring(1);
                                }
                            }
                            if (strOldCarNo != CacleCls.lockCarNo)
                            {
                                strOldCarNo = CacleCls.lockCarNo;
                                getPreInfo = false;
                                getFirst = false;
                            }
                        }

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

                        iError = 2;
                        if (CacleCls.weight > 500)
                        {
                            iError = 21;
                            CacleCls.isClear = false;

                            #region 一些必要验证及提醒
                            if (!CacleCls.isLock)
                            {
                                //重量最后一位不为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.isWd == 0 && !string.IsNullOrEmpty(CacleCls.lockCarNo))
                                {
                                    if ((CacleCls.topJg == "1" || CacleCls.bottomJg == "1"))
                                    {
                                        //重量稳定，且对射验证不合格
                                        vicPlayClass.GetVoicePlay(VoiceEnum.车辆未停到位, CacleCls.lockCarNo);
                                        txtMsgInfo.Text = "车辆超出秤台，请调整车位2";
                                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, "车辆超出秤台，请调整车位2");
                                        CacleCls.isLock = false;
                                        return;
                                    }
                                    else if (CacleCls.rightGs == "1")
                                    {
                                        //重量稳定，且右光栅不合格
                                        vicPlayClass.GetVoicePlay(VoiceEnum.车辆未停到位, CacleCls.lockCarNo);
                                        txtMsgInfo.Text = "车辆超出秤台，请调整车位3";
                                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, "车辆超出秤台，请调整车位3");
                                        CacleCls.isLock = false;
                                        return;
                                    }
                                    else if (CacleCls.leftGs == "1")
                                    {
                                        //重量稳定，且左光栅不合格
                                        vicPlayClass.GetVoicePlay(VoiceEnum.车辆未停到位, CacleCls.lockCarNo);
                                        txtMsgInfo.Text = "车辆超出秤台，请调整车位4";
                                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, "车辆超出秤台，请调整车位4");
                                        CacleCls.isLock = false;
                                        return;
                                    }
                                }
                                iError = 23;
                                /*
                                if (PbCache.isOvertimeAlarm)
                                {
                                    //停留超时提醒，不作为计量卡控的条件
                                    if (!isPlayOvertimeVoice && !PbCache.isLockFrm)
                                    {
                                        vicPlayClass.GetVoicePlay("停留超时", PbCache.collect.carno);
                                        led_controler.setStaticLineMsg(PbCache.sportInfo.ledIp, "停留超时");
                                        txtMsgInfo.Text = "停留超时";
                                        PbCache.ResultMessage = "停留超时";
                                        isPlayOvertimeVoice = true;
                                        return;
                                    }
                                }
                                //*/


                                //进行计量称重条件的判断  车号不为空、重量稳定、车辆已停到位
                                if (CacleCls.isWd == 0 && CacleCls.leftGs != "1" && CacleCls.rightGs != "1" && CacleCls.topJg != "1" && CacleCls.bottomJg != "1")
                                {
                                    iError = 11;
                                    if (!string.IsNullOrEmpty(CacleCls.lockCarNo))
                                    {
                                        if (!isVoiceDownCar)
                                        {
                                            txtMsgInfo.Text = "";
                                            isVoiceDownCar = true;
                                            vicPlayClass.GetVoicePlay(VoiceEnum.开始计量, CacleCls.lockCarNo);//只播放一次
                                        }

                                        //if(!btnSave.Enabled) btnSave.Enabled = true;

                                        if (!CacleCls.isJg)
                                        {
                                            lg.WriteLog(LogType.SystemLog, CacleCls.lockCarNo + "开始保存：" + DateTime.Now.ToLongTimeString());
                                            btnSave_Click(null, null);
                                        }
                                    }
                                    else
                                    {
                                        txtMsgInfo.Text = "车号未识别";
                                        vicPlayClass.GetVoicePlay(VoiceEnum.车号未识别, "");
                                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, "车号未识别");
                                    }
                                    iError = 12;
                                }
                            }
                            #endregion

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

                            if (!CacleCls.isClear)
                            {
                                
                                iError = 32;
                                CacleCls.Clear(); //清理一次数据
                                txtMsgInfo.Focus();
                                btnSave.Enabled = false;
                                cbCarNo.Text = "";
                                cbCarNo.SelectedIndex = -1;
                                txtCarNo.Text = "";
                                txtMATTER_NAME.Text = "";
                                txtFORWARDING_UNIT_NAME.Text = "";
                                txtRECEIVING_UINT_NAME.Text = "";
                                txtMETER_TYPE.Text = "";
                                cbCarNo.Enabled = true;
                                txtCarNo.Enabled = true;
                                txtMsgInfo.Text = "";
                                txtGroess.Text = "";
                                txtTare.Text = "";
                                txtNet.Text = "";
                                led_controler.setStaticLineMsg(AppConfigCache.ledIp, $"欢迎使用，智能计量");
                                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


        int lockWgtImg = 0;
        string strGuid = "";
        bool flagPre = true;
        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 (CacleCls.isJg)
                {
                    if (string.IsNullOrEmpty(CacleCls.lockCarNo))
                    {
                        txtMsgInfo.Text = "没有车号，无法保存";
                        return;
                    }
                    else if (CacleCls.lockWgt < 500)
                    {
                        txtMsgInfo.Text = "重量过小，无法保存";
                        return;
                    }
                    else if (CacleCls.isWd != 0)
                    {
                        txtMsgInfo.Text = "重量不稳定，无法保存";
                        return;
                    }
                    else if (CacleCls.leftGs == "1" || CacleCls.rightGs == "1" || CacleCls.topJg == "1" || CacleCls.bottomJg == "1")
                    {
                        txtMsgInfo.Text = "激光被遮挡，车辆未停到位，无法保存";
                        return;
                    }
                    else
                    {
                        lg.WriteLog(LogType.SystemLog, CacleCls.lockCarNo + "接管状态下进行的保存：" + DateTime.Now.ToLongTimeString());
                    }
                }


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

                if (!CacleCls.isJg && CacleCls.firstDb != null)
                {
                    //*
                    if (Math.Abs(CacleCls.firstDb.meterWeight.Value - CacleCls.lockWgt) < AppConfigCache.differenceWgt)
                    {
                        vicPlayClass.GetVoicePlay(VoiceEnum.结净重量过小, CacleCls.lockCarNo);
                        txtMsgInfo.Text = "计量失败，结净重量过小";
                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，结净重量过小");
                        return;
                    }
                    //*/
                }

                #region 获取一次数据跟车号
                if (!string.IsNullOrEmpty(CacleCls.lockCarNo) && CacleCls.serverFlag)
                {
                    //查询一次计量数据
                    if (!getFirst)
                    {
                        RESTfulResultOutTimer = workCarActualFirstService.doQueryWf(new MeterWorkCarActualFirst { valueFlag = "1", carNo = CacleCls.lockCarNo });

                        if (RESTfulResultOutTimer.Succeed)
                        {
                            if (RESTfulResultOutTimer.Data != null && RESTfulResultOutTimer.Data.Count > 0)
                            {
                                if (RESTfulResultOutTimer.Data.Count == 1) 
                                {
                                    CacleCls.firstDb = RESTfulResultOutTimer.Data[0];
                                    if (CacleCls.firstDb.predictionNo != null && !CacleCls.firstDb.predictionNo.Contains("_"))
                                    {
                                        txtMATTER_NAME.Text = CacleCls.firstDb.matterName;
                                        txtFORWARDING_UNIT_NAME.Text = CacleCls.firstDb.forwardingUnitName;
                                        txtRECEIVING_UINT_NAME.Text = CacleCls.firstDb.receivingUintName;
                                        txtMETER_TYPE.Text = CacleCls.firstDb.meterTypeName;
                                    }
                                }
                                else
                                {
                                    vicPlayClass.GetVoicePlay(VoiceEnum.程序处理异常, CacleCls.lockCarNo);
                                    led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                                    txtMsgInfo.Text = $"存在{RESTfulResultOutTimer.Data.Count}条未结净的一次计量数据";
                                    lg.WriteLog(LogType.serverLog, $"存在{RESTfulResultOutTimer.Data.Count}条未结净的一次计量数据");
                                    CacleCls.isLock = false;
                                    return;
                                }
                            }
                        }
                        else
                        {
                            vicPlayClass.GetVoicePlay(VoiceEnum.程序处理异常, CacleCls.lockCarNo);
                            led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                            txtMsgInfo.Text = "获取一次计量数据失败：" + RESTfulResultOutTimer.Message;
                            lg.WriteLog(LogType.serverLog, "获取一次计量数据失败：" + RESTfulResultOutTimer.Message);
                            CacleCls.isLock = false;
                            return;
                        }
                        getFirst = true;
                    }
                    //根据网络状态及车号以及是否存在一次计量数据，查询一次预报信息，然后将getPreInfo改为true
                    if (!getPreInfo)
                    {
                        if (CacleCls.firstDb != null)
                        {
                            //做结净的时候，才查询一次预报信息
                            rmScaleListCarTimer = PreTrackScaleService.doQueryByFlag(new PreTrackScale { lineDesc = "0", carNo = CacleCls.lockCarNo });
                            if (rmScaleListCarTimer.Succeed)
                            {
                                if (rmScaleListCarTimer.Data != null && rmScaleListCarTimer.Data.Count > 0)
                                {
                                    CacleCls.preTrackScale = null;
                                    if (!string.IsNullOrEmpty(CacleCls.firstDb.predictionNo)) 
                                    {
                                        CacleCls.preTrackScale = rmScaleListCarTimer.Data.Where(s => s.predictionNo == CacleCls.firstDb.predictionNo).FirstOrDefault();
                                    }
                                    else 
                                    {
                                        string strMat = "", strFor = "", strRec = "";
                                        foreach (PreTrackScale pr in rmScaleListCarTimer.Data)
                                        {
                                            if (strMat == "")
                                            {
                                                strMat = pr.matterNo;
                                                strFor = pr.forwardingUnitNo;
                                                strRec = pr.receivingUintNo;
                                            }
                                            else if (pr.matterNo != strMat || pr.forwardingUnitNo != strFor || pr.receivingUintNo != strRec)
                                            {
                                                flagPre = false;
                                                break;
                                            }

                                        }
                                    }

                                    if (flagPre && CacleCls.preTrackScale != null)
                                    {
                                        txtMATTER_NAME.Text = CacleCls.preTrackScale.matterName;
                                        txtFORWARDING_UNIT_NAME.Text = CacleCls.preTrackScale.forwardingUnitName;
                                        txtRECEIVING_UINT_NAME.Text = CacleCls.preTrackScale.receivingUintName;
                                        txtMETER_TYPE.Text = CacleCls.preTrackScale.meterTypeName;
                                    }
                                }
                            }
                        }
                        getPreInfo = true;
                    }
                }
                #endregion


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

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

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

                strGuid = strGuid == "" ? Guid.NewGuid().ToString() : strGuid;
                #region 截图
                if (!flagCaption)
                {
                    for (int i = 0; i < lc.Count(); i++)
                    {
                        if (i == 0)
                        {
                            carCls.CapturePictrue2($"{AppConfigCache.path}/imgShort/formalImg/{AppConfigCache.pointNo}_C{strGuid}_tempImg_{i + 2}.jpg");
                            continue;
                        }

                        //从_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 (CacleCls.serverFlag) //网络正常
                {
                    //没有接管的情况下
                    //* 2023-04-22测试时注释，实际应用时需要
                    if (!CacleCls.isJg && CacleCls.firstDb != null && Math.Abs(CacleCls.firstDb.meterWeight.Value - CacleCls.lockWgt) < AppConfigCache.differenceWgt)
                    {
                        string str = "第一次计量重量【" + Math.Round((decimal)CacleCls.firstDb.meterWeight.Value / 1000, 2) + "T】和第二次计量重量【" + Math.Round((decimal)CacleCls.lockWgt / 1000, 2) + "T】接近，小于结净最小值【" + Math.Round((decimal)AppConfigCache.differenceWgt / 1000, 2) + " T】";
                        vicPlayClass.GetVoicePlay(VoiceEnum.两次计量重量接近, CacleCls.lockCarNo);
                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, $"上次重量与当，前重量接近，需操作工确认");
                        txtMsgInfo.Text = str;
                        lg.WriteLog(LogType.serverLog, str);
                        CacleCls.isLock = false;
                        return;
                    }
                    //*/


                    //一次计量
                    if (CacleCls.firstDb == null)
                    {
                        //进行计量，不管有没有一次计量数据，都调用这个，如果服务端判断有一次计量数据则进行结净，没有则做一次计量操作
                        RESTfulResult<string> rmRst = workCarActualFirstService.doAddFirstDjDb(CacleCls.preTrackScale, new MeterWorkCarActualFirst
                        {
                            baseSpotNo = AppConfigCache.pointNo,
                            baseSpotName = AppConfigCache.pointName,
                            carNo = CacleCls.lockCarNo,
                            createTime = DateTime.Now,
                            meterWeight = CacleCls.lockWgt,
                            createManNo = "system",
                            createManName = "system",
                            valueFlag = "1",
                            meterMode = "2",
                            isPreScale = "0",
                            dataSource = "1",
                            checkFlag = "1"
                        });

                        if (rmRst.Succeed)
                        {
                            isMeasureSuccess = true;
                            CacleCls.actualNo = rmRst.Data;
                            CacleCls.tempNo = strGuid;
                        }
                        else
                        {
                            //计量失败，播报失败，然后写led屏幕及日志
                            led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                            vicPlayClass.GetVoicePlay(VoiceEnum.程序处理异常, CacleCls.lockCarNo);
                            txtMsgInfo.Text = "计量失败，请求服务异常：" + rmRst.ResultMessage;
                            lg.WriteLog(LogType.serverLog, "计量失败，请求服务异常：" + rmRst.ResultMessage);
                            CacleCls.isLock = false;
                            return;
                        }
                    }
                    else //结净操作
                    {
                        RESTfulResult<string> rmRst = workCarActualFirstService.doAddNet(CacleCls.preTrackScale, CacleCls.firstDb, new MeterWorkCarActualFirst
                        {
                            baseSpotNo = AppConfigCache.pointNo,
                            baseSpotName = AppConfigCache.pointName,
                            carNo = CacleCls.lockCarNo,
                            createTime = DateTime.Now,
                            meterWeight = CacleCls.lockWgt,
                            createManNo = "system",
                            createManName = "system",
                            valueFlag = "1",
                            meterMode = "2",
                            isPreScale = "0",
                            dataSource = "1",
                            checkFlag = "1"
                        });

                        if (rmRst.Succeed)
                        {
                            isMeasureSuccess = true;
                            CacleCls.actualNo = rmRst.Data;
                            CacleCls.tempNo = strGuid;
                        }
                        else
                        {
                            //计量失败，播报失败，然后写led屏幕及日志
                            vicPlayClass.GetVoicePlay(VoiceEnum.程序处理异常, CacleCls.lockCarNo);
                            led_controler.setStaticLineMsg(AppConfigCache.ledIp, "计量失败，请联系管理员");
                            txtMsgInfo.Text = "计量失败，请求服务异常：" + rmRst.ResultMessage;
                            lg.WriteLog(LogType.serverLog, "计量失败，请求服务异常：" + rmRst.ResultMessage);
                            CacleCls.isLock = false;
                            return;
                        }
                    }
                }
                else
                {
                    //写本地文件
                    bool flag = FileOption.WriterDb(new ActualFirstModel { actualFirstNo = strGuid, baseSpotNo = AppConfigCache.pointNo, baseSpotName = AppConfigCache.pointName, carNo = CacleCls.lockCarNo, createTime = DateTime.Now, meterWeight = CacleCls.lockWgt }, out msgInfo);
                    if (flag)
                    {
                        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)
                {
                    btnSave.Enabled = false;

                    if (!flagPre)
                    {
                        txtMsgInfo.Text = "计量完成，存在多个委托";
                    }else
                    {
                        txtMsgInfo.Text = "计量完成";
                    }
                    #region 毛皮净赋值
                    if (CacleCls.firstDb != null && CacleCls.firstDb.meterWeight > 0 && CacleCls.lockWgt > 0)
                    {
                        if (CacleCls.firstDb.meterWeight > CacleCls.lockWgt)
                        {
                            txtGroess.Text = $"{Math.Round((decimal)CacleCls.firstDb.meterWeight / 1000, 2)}"; 
                            txtTare.Text = $"{Math.Round((decimal)CacleCls.lockWgt / 1000, 2)}";
                            txtNet.Text = $"{Math.Round((decimal)(CacleCls.firstDb.meterWeight.Value - CacleCls.lockWgt) / 1000, 2)}";
                        }
                        else
                        {
                            txtGroess.Text = $"{Math.Round((decimal)CacleCls.lockWgt / 1000, 2)}";
                            txtTare.Text = $"{Math.Round((decimal)CacleCls.firstDb.meterWeight / 1000, 2)}";
                            txtNet.Text = $"{Math.Round((decimal)(CacleCls.lockWgt - CacleCls.firstDb.meterWeight) / 1000, 2)}";
                        }
                    }
                    if (CacleCls.firstDb == null)
                    {
                        //计量完成多委托

                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, $"车号{CacleCls.lockCarNo}，重量{Math.Round((decimal)CacleCls.lockWgt / 1000, 2)}吨，计量完成");
                    }
                    else 
                    {
                        led_controler.setStaticLineMsg(AppConfigCache.ledIp, $"车号{CacleCls.lockCarNo}，重量{Math.Round((decimal)CacleCls.lockWgt / 1000, 2)}吨，净重{Math.Round((decimal)Math.Abs(CacleCls.firstDb.meterWeight.Value - CacleCls.lockWgt) / 1000, 2)}吨，计量完成");
                    }

                    #endregion

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

                    BindTable();

                    //只需要控制plc即可，其他的不管
                    if (AppConfigCache.plcStart == "1")
                    {
                        plc.DataCollectWrite(AppConfigCache.dz, AppConfigCache.dzValue);
                    }
                }
                #endregion
            }
            catch (Exception ex)
            {
                vicPlayClass.GetVoicePlay(VoiceEnum.程序处理异常, CacleCls.lockCarNo);
                lg.WriteLog(LogType.SystemLog, "计量失败1：" + ex.Message);
                CacleCls.isLock = false;
            }
        }

        private void BindTable() 
        {
            bool bReadFlag = false;
            string strRtMsgInfo = "";
            List<ActualFirstModel> lm = FileOption.ReadDb<ActualFirstModel>(ref bReadFlag, ref strRtMsgInfo);
            DataTable dtV = dataTableFirst.Clone();
            if (lm != null && lm.Count > 0)
            {
                dtV = lm.ListToDataTable<ActualFirstModel>();
            }
            ClsControlPack.CopyDataToDatatable(ref dtV, ref this.dataTableFirst, true);
            ClsControlPack.RefreshAndAutoSize(ultraGridFirst);

        }

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

        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 { upload?.stop(); } catch { }

            try { carCls?.LoginOut(); } catch { }
            
            if (AppConfigCache.openVoice.Contains("2"))
            {
                try { carCls2?.LoginOut(); } catch { }
            }

            try { imgControl?.Stop(); } catch { }
        }

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

        private void btnExport_Click(object sender, EventArgs e)
        {
            ClsControlPack.ExportDataWithSaveDialog2(ref ultraGridFirst, DateTime.Now.ToString("yyyyMMddHHmmss"));
        }

        private void cbCarNo_SelectedIndexChanged(object sender, EventArgs e)
        {
            CacleCls.isLock = false;
        }

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

        private void txtCarNo_TextChanged(object sender, EventArgs e)
        {
            CacleCls.isLock = false;
        }

        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 txtCarNo_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter) txtMsgInfo.Focus();
        }

        private void btnOpenDz_Click(object sender, EventArgs e)
        {
            if (AppConfigCache.plcStart == "1")
            {
                plc.DataCollectWrite(AppConfigCache.dz, AppConfigCache.dzValue);
            }
            else
            {
                MessageBox.Show("当前PLC处于未连接状态，请先配置连接再操作");
            }
        }

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


        #region 释放内存
        [DllImport("kernel32.dll")]
        private static extern bool SetProcessWorkingSetSize(IntPtr process, int minSize, int maxSize);
        //刷新存储器
        private static void FlushMemory()
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
            {
                SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle, -1, -1);
            }
        }
        #endregion
    }
}