mes-client/FileWatcher/AutoMakeQTYRZ.cs

using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Threading;
using System.Windows.Forms;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO.Ports;

namespace FileWatcher
{
    public partial class AutoMakeQTYRZ : Form
    {

        DataHelper dh;

        DataTable dt;

        DataTable DB;

        /// <summary>
        /// 用户编号
        /// </summary>
        string iusercode;
        /// <summary>
        /// 岗位资源
        /// </summary>
        string isource;

        Thread InitDB;
        /// 当前工序
        /// </summary>
        string istepcode;
        StringBuilder sql = new StringBuilder();
        /// <summary>
        /// 缓存的文件
        /// </summary>
        public static string CachePath = Environment.GetEnvironmentVariable("windir").Substring(0, 1) + @":/UAS_MES/XmlAnalysor/Cache.xml";
        /// <summary>
        /// 缓存的文件夹
        /// </summary>
        public static string CachePathFolder = Environment.GetEnvironmentVariable("windir").Substring(0, 1) + @":/UAS_MES/XmlAnalysor/";

        ftpOperater ftp = new ftpOperater();

        private bool waitingForStableData = false;

        public AutoMakeQTYRZ()
        {
            InitializeComponent();
            StartPosition = FormStartPosition.CenterScreen;
            stableDataTimer.Interval = 2000; // 2秒
            stableDataTimer.Tick += (s, args) =>
            {
                ProcessStableData();
                stableDataTimer.Stop();
            };
        }
        DataTable Dbfind;

        private void nr_rule_DBChange(object sender, EventArgs e)
        {
            Dbfind = li_code.ReturnData;
            BaseUtil.SetFormValue(this.Controls, Dbfind);
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            CheckForIllegalCrossThreadCalls = false;
            InitDB = new Thread(ConnectDB);
            SetLoadingWindow stw = new SetLoadingWindow(InitDB, "正在启动程序");
            stw.StartPosition = FormStartPosition.CenterScreen;
            stw.ShowDialog();
            FormBorderStyle = FormBorderStyle.FixedSingle;
          
            List<string> CacheInf = new List<string>();
            //获取缓存信息
            try
            {
                Type.Text = BaseUtil.GetCacheData("Type").ToString();
                ComPort.Text = BaseUtil.GetCacheData("ComPort").ToString();
                BaudRate.Text = BaseUtil.GetCacheData("BaudRate").ToString();
                li_code.Text = BaseUtil.GetCacheData("Line").ToString();
            }
            catch (Exception ex) { MessageBox.Show(ex.Message); }
        }

        private float getdata(string tmp_b2)
        {
            byte[] b2 = new byte[4];
            float f2 = 0;

            tmp_b2 = tmp_b2.Replace(" ", "");//删除字符串中间的空格
            if (tmp_b2.Length != 8)
            {
                //判断输入字符串的长度是否合适
                MessageBox.Show("输入Byte长度错误，为连续8位4个字节,高位为0的补齐0");
            }
            else
            {
                //将收到的字符串分成4个字节，这4个字节是字符串的形式
                string tmp_char1 = tmp_b2.Substring(6, 2);
                string tmp_char2 = tmp_b2.Substring(4, 2);
                string tmp_char3 = tmp_b2.Substring(2, 2);
                string tmp_char4 = tmp_b2.Substring(0, 2);
                //将4字节的字符串格式转换成16进制的byte格式
                b2[3] = Convert.ToByte(tmp_char1, 16);
                b2[2] = Convert.ToByte(tmp_char2, 16);
                b2[1] = Convert.ToByte(tmp_char3, 16);
                b2[0] = Convert.ToByte(tmp_char4, 16);
                //将16进制byte转换成浮点数格式
                f2 = BitConverter.ToSingle(b2, 0);
            }
            return f2;
        }

        bool realwritedata = false;

        private bool isWaitingForStableData = false;
        private bool canRecordNext = true;
        private string pendingData = "";
        private System.Windows.Forms.Timer stableDataTimer = new System.Windows.Forms.Timer();
        private void SerialPort1_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            try
            {
                int len = serialPort1.BytesToRead;
                byte[] readBuffer = new byte[len];
                serialPort1.Read(readBuffer, 0, len);
                string rawData = BitConverter.ToString(readBuffer).Replace("-", "");

                this.Invoke((MethodInvoker)delegate
                {
                    pendingData = rawData.Length >= 48 ? rawData.Substring(0, 48) : rawData;
                    //OperateResult.AppendText($"收到数据: {pendingData}\n");

                    if (pendingData.Length == 48)
                    {
                        float current = getdata(pendingData.Substring(14, 8));
                        // 电流归零时重置记录许可
                        if (current == 0)
                        {
                            canRecordNext = true;
                            //OperateResult.AppendText("电流归零，已允许下次记录\n");
                        }
                        // 电流非零且允许记录时触发
                        else if (current != 0 && canRecordNext && !isWaitingForStableData)
                        {
                            //OperateResult.AppendText("[开始] 检测到有效电流，启动2秒延迟...\n");
                            isWaitingForStableData = true;
                            stableDataTimer.Start();
                        }
                    }
                });
            }
            catch (Exception ex)
            {
                this.Invoke((MethodInvoker)delegate
                {
                    OperateResult.AppendText($"数据接收错误: {ex.Message}\n");
                });
            }
        }

        private void ProcessStableData()
        {
            try
            {
                this.Invoke((MethodInvoker)delegate
                {
                    if (string.IsNullOrEmpty(pendingData) || pendingData.Length < 48)
                    {
                        //OperateResult.AppendText("错误: 数据长度不足\n");
                        isWaitingForStableData = false;
                        return;
                    }

                    float current = getdata(pendingData.Substring(14, 8));

                    // 延迟后再次检查电流
                    if (current == 0)
                    {
                        //OperateResult.AppendText("警告: 延迟后电流已归零，取消记录\n");
                        isWaitingForStableData = false;
                        return;
                    }
                    // 解析其他数据
                    float voltage = getdata(pendingData.Substring(6, 8));
                    float power = getdata(pendingData.Substring(22, 8));
                    float frequency = getdata(pendingData.Substring(30, 8));
                    float powerFactor = getdata(pendingData.Substring(38, 8));

                    // 检查功率范围
                    if (double.TryParse(FunctionNum.Text, out double minPower) &&
                        double.TryParse(FunctionNum1.Text, out double maxPower))
                    {
                        if (power >= minPower && power <= maxPower)
                        {
                            // 写入数据库
                            dh.ExecuteSql("INSERT INTO currenttest(CT_ID, ct_linecode, CT_MAKECODE, CT_VOLTAGE, CT_CURRENT, CT_POWER, CT_FREQUENCY, CT_POWER1) " +
                                            "VALUES(currenttest_SEQ.NEXTVAL,'" + li_code.Text + "', '" + ma_code.Text + "', " + voltage + ", " + current + ", " + power + ", " + frequency + "" +
                                            ", " + powerFactor + ")", "insert");
                            NowQTY.Text = dh.getRowCount("currenttest", $"ct_makecode='{ma_code.Text}'").ToString();
                            OperateResult.AppendText(DateTime.Now.ToString("HH:mm:ss") + $"数据上成功,记录: 电流={current}A 功率={power}W\n");
                            // 记录成功后禁止下次记录，直到电流归零
                            canRecordNext = false;
                        }
                        else
                        {
                            OperateResult.AppendText($"功率超出范围: {power}W (要求: {minPower}-{maxPower}W)\n");
                            canRecordNext = false;
                        }
                    }
                    else
                    {
                        OperateResult.AppendText("错误: 无效的功率范围设置\n");
                    }
                    isWaitingForStableData = false;
                });
            }
            catch (Exception ex)
            {
                this.Invoke((MethodInvoker)delegate
                {
                    OperateResult.AppendText($"处理稳定数据时出错: {ex.Message}\n");
                    isWaitingForStableData = false;
                });
            }
        }

        private void ConnectDB()
        {
            dh = new DataHelper();
            SystemInf.dh = dh;

            ma_code.TableName = "make";
            ma_code.SelectField = "ma_code # 工单号";
            ma_code.FormName = Name;
            ma_code.DBTitle = "工单查询";
            ma_code.SetValueField = new string[] { "ma_code" };
            ma_code.Condition = "";
            ma_code.DbChange += nr_rule_DBChange;

            li_code.TableName = "line";
            li_code.SelectField = "li_code # 线别编号,li_name # 线别名称";
            li_code.FormName = Name;
            li_code.DBTitle = "线别查询";
            li_code.SetValueField = new string[] { "li_code" };
            li_code.Condition = "";
            li_code.DbChange += nr_rule_DBChange;
        }
        SerialPort serialPort1 = new SerialPort();

        private void StartWatch_Click(object sender, EventArgs e)
        {
            BaseUtil.SetCacheData("Type", Type.Text);
            BaseUtil.SetCacheData("ComPort", ComPort.Text);
            BaseUtil.SetCacheData("BaudRate", BaudRate.Text);
            BaseUtil.SetCacheData("Line", li_code.Text);
            if (!dh.CheckExist("Make", "ma_code='" + ma_code.Text + "'"))
            {
                OperateResult.AppendText("工单号不能为空\n");
                return;
            }
            //设置按钮不可点击
            StartWatch.Enabled = false;
            ma_code.Enabled = false;
            StopWatch.Enabled = true;
            serialPort1.DataReceived += SerialPort1_DataReceived;
            try
            {
                serialPort1.PortName = ComPort.Text;
                serialPort1.BaudRate = int.Parse(BaudRate.Text);
                serialPort1.Open();
                Timer.Start();
            }
            catch (Exception mes)
            {
                if (BaudRate.Text == "" || BaudRate.Text == "")
                    OperateResult.AppendText(">>请先维护波特率和串口\n");
                else
                    OperateResult.AppendText(">>" + mes.Message + "\n");
            }
            OperateResult.AppendText("开始执行监控\n");
        }


        private void StopWatch_Click(object sender, EventArgs e)
        {
            StartWatch.Enabled = true;
            ma_code.Enabled = true;
            StopWatch.Enabled = false;
            serialPort1.DataReceived -= SerialPort1_DataReceived;
            serialPort1.Close();
          
            Timer.Stop();
            OperateResult.AppendText("停止执行监控\n");
        }

        private void Clean_Click(object sender, EventArgs e)
        {
            OperateResult.Clear();
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            string ExitConfirm = MessageBox.Show(this, "确认退出？", "提示", MessageBoxButtons.YesNo, MessageBoxIcon.Question).ToString();
            if (ExitConfirm != "Yes")
            {
                WindowState = FormWindowState.Minimized;
                e.Cancel = true;
            }
        }
        private void Timer_Tick(object sender, EventArgs e)
        {
            if (serialPort1.IsOpen)
            {
                if (!realwritedata)
                {
                    byte[] data = HexStringToBytes("55 00 10 65");
                    serialPort1.Write(data, 0, data.Length);
                }
            }
        }

        private void AutoStart_CheckedChanged(object sender, EventArgs e)
        {
            SetAutoRun();
        }
        private void SetAutoRun()
        {
            if (AutoStart.Checked) //设置开机自启动  
            {
                string path = Application.ExecutablePath;
                RegistryKey rk = Registry.LocalMachine;
                RegistryKey rk2 = rk.CreateSubKey(@"Software\Microsoft\Windows\CurrentVersion\Run");
                rk2.SetValue("FileWatcher.exe", path);
                rk2.Close();
                rk.Close();
            }
            else //取消开机自启动  
            {
                string path = Application.ExecutablePath;
                RegistryKey rk = Registry.LocalMachine;
                RegistryKey rk2 = rk.CreateSubKey(@"Software\Microsoft\Windows\CurrentVersion\Run");
                rk2.DeleteValue("FileWatcher.exe", false);
                rk2.Close();
                rk.Close();
            }
        }
        private byte[] HexStringToBytes(string hs)//十六进制字符串转byte
        {
            string a = hs.Replace(" ", "");
            int bytelength = 0;
            if (a.Length % 2 == 0)
            {
                bytelength = a.Length / 2;
            }
            else
            {
                bytelength = a.Length / 2 + 1;
            }
            byte[] b = new byte[bytelength];
            //逐个字符变为16进制字节数据
            for (int i = 0; i < bytelength; i++)
            {
                if (i == bytelength - 1)
                {
                    b[i] = Convert.ToByte(a.Substring(i * 2), 16);
                }
                else
                {
                    b[i] = Convert.ToByte(a.Substring(i * 2, 2), 16);
                }
            }
            //按照指定编码将字节数组变为字符串
            return b;
        }
    }
}