设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 电子技术分类讨论区 › 程序设计/上位机 › 基于c#的配气仪源程序
返回列表 发新帖
查看: 1311|回复: 0
打印 上一主题 下一主题
收起左侧

基于c#的配气仪源程序

[复制链接]
跳转到指定楼层
楼主
ID:611900 发表于 2019-9-16 09:37 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
基于C#的配气仪源码，个人练习做的

单片机源程序如下:
  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.ComponentModel;
  5. using System.Data;
  6. using System.Drawing;
  7. using System.IO;
  8. using System.IO.Ports;
  9. using System.Linq;
  10. using System.Text;
  11. using System.Threading;
  12. using System.Windows.Forms;

  14. namespace GCC
  15. {
  16.     public partial class MainForm : Form
  17.     {
  18.         public static bool isRun = false;
  19.         public static string keyBoardValue;
  20.         //public readonly Thread timerThread = new Thread(SetTimer);
  21.         //public System.Timers.Timer showTimer = new System.Timers.Timer();

  23.         public MainForm()
  24.         {
  25.             InitializeComponent();
  26.             Control.CheckForIllegalCrossThreadCalls = false;   //防止跨线程访问出错
  27.         }

  29.         private void Cb_gas1_SelectedIndexChanged(object sender, EventArgs e)
  30.         {
  31.             tb_coefficient1.Text = DataProcessing.GetCoefficient(cb_gas1.SelectedItem.ToString());
  32.             tb_concentration1.Text = "";
  33.             tb_target_concentration1.Text = "";
  34.         }

  36.         private void Cb_gas2_SelectedIndexChanged(object sender, EventArgs e)
  37.         {
  38.             tb_coefficient2.Text = DataProcessing.GetCoefficient(cb_gas2.SelectedItem.ToString());
  39.             tb_concentration2.Text = "";
  40.             tb_target_concentration2.Text = "";
  41.         }

  43.         private void Cb_gas3_SelectedIndexChanged(object sender, EventArgs e)
  44.         {
  45.             tb_coefficient3.Text = DataProcessing.GetCoefficient(cb_gas3.SelectedItem.ToString());
  46.             tb_concentration3.Text = "";
  47.             tb_target_concentration3.Text = "";
  48.         }

  50.         private void Cb_gas4_SelectedIndexChanged(object sender, EventArgs e)
  51.         {
  52.             tb_coefficient4.Text = DataProcessing.GetCoefficient(cb_gas4.SelectedItem.ToString());
  53.             tb_concentration4.Text = "";
  54.             tb_target_concentration4.Text = "";
  55.         }

  57.         private void MainForm_Load(object sender, EventArgs e)
  58.         {
  59.             try
  60.             {
  61.                 SerialPortHandle.LoadSerialConfig(sp, "COM7", "9600", "8", "2", "NONE");

  63.                 MachineInitialization(sp);
  64.                 tb_states1.Text = "关闭";
  65.                 tb_states2.Text = "关闭";
  66.                 tb_states3.Text = "关闭";
  67.                 tb_states4.Text = "关闭";

  69.                 DataProcessing.LogRecord("系统初始化完成");
  70.                 //showTimer.Interval = 1000;
  71.                 //showTimer.Elapsed += new System.Timers.ElapsedEventHandler(TimerExecute);
  72.             }
  73.             catch
  74.             { }
  75.         }
  76.         
  77.         private void Bt_start_Click(object sender, EventArgs e)
  78.         {
  79.             ComboBox[] comboBoxes = { cb_gas1, cb_gas2, cb_gas3, cb_gas4 };
  80.             TextBox[,] aisle = {
  81.                 { tb_concentration1, tb_target_concentration1, tb_coefficient1, tb_flow1, tb_test_concentration1, tb_states1 },
  82.                 { tb_concentration2, tb_target_concentration2, tb_coefficient2, tb_flow2, tb_test_concentration2, tb_states2 },
  83.                 { tb_concentration3, tb_target_concentration3, tb_coefficient3, tb_flow3, tb_test_concentration3, tb_states3 },
  84.                 { tb_concentration4, tb_target_concentration4, tb_coefficient4, tb_flow4, tb_test_concentration4, tb_states4 }
  85.             };

  87.             if (!sp.IsOpen)
  88.             {
  89.                 SerialPortHandle.LoadSerialConfig(sp, "COM7", "9600", "8", "2", "NONE");
  90.             }
  91.             DataProcessing.DataCounting(comboBoxes, aisle);
  92.             WriteSetflowValue();
  93.             bt_start.Enabled = false;
  94.             cb_gas1.Enabled = false;
  95.             cb_gas2.Enabled = false;
  96.             cb_gas3.Enabled = false;
  97.             cb_gas4.Enabled = false;
  98.             tb_concentration1.ReadOnly = true;
  99.             tb_concentration2.ReadOnly = true;
  100.             tb_concentration3.ReadOnly = true;
  101.             tb_concentration4.ReadOnly = true;
  102.             tb_target_concentration1.ReadOnly = true;
  103.             tb_target_concentration2.ReadOnly = true;
  104.             tb_target_concentration3.ReadOnly = true;
  105.             tb_target_concentration4.ReadOnly = true;
  106.             tb_concentration1.MouseDown -= new System.Windows.Forms.MouseEventHandler(Tb_concentration1_MouseDown);
  107.             tb_concentration2.MouseDown -= new System.Windows.Forms.MouseEventHandler(Tb_concentration2_MouseDown);
  108.             tb_concentration3.MouseDown -= new System.Windows.Forms.MouseEventHandler(Tb_concentration3_MouseDown);
  109.             tb_concentration4.MouseDown -= new System.Windows.Forms.MouseEventHandler(Tb_concentration4_MouseDown);
  110.             tb_target_concentration1.MouseDown -= new System.Windows.Forms.MouseEventHandler(Tb_target_concentration1_MouseDown);
  111.             tb_target_concentration2.MouseDown -= new System.Windows.Forms.MouseEventHandler(Tb_target_concentration2_MouseDown);
  112.             tb_target_concentration3.MouseDown -= new System.Windows.Forms.MouseEventHandler(Tb_target_concentration3_MouseDown);
  113.             tb_target_concentration4.MouseDown -= new System.Windows.Forms.MouseEventHandler(Tb_target_concentration4_MouseDown);
  114.         }

  116.         string aisle1_setFlow = "";
  117.         string aisle2_setFlow = "";
  118.         string aisle3_setFlow = "";
  119.         string aisle4_setFlow = "";
  120.         /// <summary>
  121.         /// 写入设定流量值
  122.         /// </summary>
  123.         public void WriteSetflowValue()
  124.         {
  125.             timer.Enabled = false;
  126.             //showTimer.Enabled = false;
  127.             string[] setFlowValue = new string[4];
  128.             ComboBox[] comboBoxes = { cb_gas1, cb_gas2, cb_gas3, cb_gas4 };
  129.             
  130.             if (sp.IsOpen)
  131.             {
  132.                 for (int i = 0; i < comboBoxes.Length; i++)
  133.                 {
  134.                     if (comboBoxes[i].Text != "")
  135.                     {
  136.                         if (comboBoxes[i].Text != " ")
  137.                         {
  138.                             try
  139.                             {
  140.                                 //string a = tb_setOutputFlow.Text;
  141.                                 setFlowValue[i] = DataProcessing.GetGasSetFlow(DataProcessing.gasR[i], Convert.ToDouble(tb_setOutputFlow.Text)).ToString();
  142.                                 //MessageBox.Show(setFlowValue[i]);
  143.                                 //Thread.Sleep(50);
  144.                                 if (isRun)
  145.                                 {
  146.                                     int index = i + 1;
  147.                                     if (ValveIsClose("通道" + index, "读关闭", "", index))
  148.                                     {
  149.                                         while (true)    //等待消息接收完成
  150.                                         {
  151.                                             if (isReceived)
  152.                                             {
  153.                                                 isReceived = false;
  154.                                                 SerialPortHandle.SendSerialData(sp, DataProcessing.SendDataformat("通道" + index, "阀控控制", ""));
  155.                                                 Thread.Sleep(100);
  156.                                                 break;
  157.                                             }
  158.                                         }
  159.                                         //MessageBox.Show("通道" + index + "阀控打开");
  160.                                     }
  161.                                     DataProcessing.LogRecord("通道"+index+ "写入设定流量值");
  162.                                     byte[] sendData = DataProcessing.SendDataformat("通道" + index, "写入设定流量值", setFlowValue[i]);
  163.                                     while (true)    //等待消息接收完成
  164.                                     {
  165.                                         if (isReceived)
  166.                                         {
  167.                                             isReceived = false;
  168.                                             SerialPortHandle.SendSerialData(sp, sendData);
  169.                                             Thread.Sleep(100);
  170.                                             break;
  171.                                         }
  172.                                     }
  173.                                     //MessageBox.Show("通道" + index + "写入设定流量值成功");
  174.                                     switch (i)
  175.                                     {
  176.                                         case 0:
  177.                                             aisle1_setFlow = setFlowValue[i];
  178.                                             break;
  179.                                         case 1:
  180.                                             aisle2_setFlow = setFlowValue[i];
  181.                                             break;
  182.                                         case 2:
  183.                                             aisle3_setFlow = setFlowValue[i];
  184.                                             break;
  185.                                         case 3:
  186.                                             aisle4_setFlow = setFlowValue[i];
  187.                                             break;
  188.                                     }
  189.                                 }
  190.                                 isRun = false;
  191.                             }
  192.                             catch (System.Exception ex)
  193.                             {
  194.                                 MessageBox.Show("WriteSetflowValue函数：" + ex.Message);
  195.                             }
  196.                         }
  197.                     }
  198.                 }
  199.                 timer.Enabled = true;
  200.                 DataProcessing.LogRecord("定时器打开");
  201.                 //showTimer.Enabled = true;
  202.             }
  203.             //showTimer.Enabled = true;
  204.         }

  206.         /// <summary>
  207.         /// 设置定时器
  208.         /// </summary>
  209.         //private void SetTimer()
  210.         //{
  211.         //    //showTimer.Interval = 1000;
  212.         //    //showTimer.Elapsed += new System.Timers.ElapsedEventHandler(TimerExecute);
  213.         //    //showTimer.Enabled = true;
  214.         //}

  216.         ///// <summary>
  217.         ///// 定时器执行函数
  218.         ///// </summary>
  219.         ///// <param name="source"></param>
  220.         ///// <param name="e"></param>
  221.         //private void TimerExecute(object source, System.Timers.ElapsedEventArgs e)
  222.         //{
  223.         //    //showTimer.Enabled = false;
  224.         //    if (sp.IsOpen)
  225.         //    {
  226.         //        ShowFlowAndConcentration();
  227.         //        sp.DiscardInBuffer();
  228.         //        sp.DiscardOutBuffer();
  229.         //    }
  230.         //    else
  231.         //    {
  232.         //    }
  233.         //    //showTimer.Enabled = true;
  234.         //}

  236.         /// <summary>
  237.         /// 判断通道阀门状态
  238.         /// </summary>
  239.         /// <param name="aisleName">通道名称</param>
  240.         /// <param name="strFun">功能码</param>
  241.         /// <param name="data">数据值</param>
  242.         /// <param name="index">索引</param>
  243.         /// <returns>返回值为true，阀门打开；返回值为false，阀门关闭</returns>
  244.         public bool ValveIsClose(string aisleName, string strFun, string data, int index)
  245.         {
  246.             DataProcessing.LogRecord(aisleName + strFun);
  247.             while (true)    //等待消息接收完成
  248.             {
  249.                 if (isReceived)
  250.                 {
  251.                     isReceived = false;
  252.                     SerialPortHandle.SendSerialData(sp, DataProcessing.SendDataformat(aisleName, strFun, data));
  253.                     Thread.Sleep(100);
  254.                     break;
  255.                 }
  256.             }
  257.             if (index == 1)
  258.             {

  260.                 //string A = p;
  261.                 if (DataProcessing.aisle1[1] == 0x01)
  262.                 {
  263.                     return true;
  264.                 }
  265.                 else
  266.                 {
  267.                     return false;
  268.                 }
  269.             }
  270.             else if (index == 2)
  271.             {
  272.                 //string B = p;
  273.                 if (DataProcessing.aisle2[1] == 0x01)
  274.                 {
  275.                     return true;
  276.                 }
  277.                 else
  278.                 {
  279.                     return false;
  280.                 }
  281.             }
  282.             else if (index == 3)
  283.             {
  284.                 //string C = p;
  285.                 if (DataProcessing.aisle3[1] == 0x01)
  286.                 {
  287.                     return true;
  288.                 }
  289.                 else
  290.                 {
  291.                     return false;
  292.                 }
  293.             }
  294.             else
  295.             {
  296.                 //string D = p;
  297.                 if (DataProcessing.aisle4[1] == 0x01)
  298.                 {
  299.                     return true;
  300.                 }
  301.                 else
  302.                 {
  303.                     return false;
  304.                 }
  305.             }
  306.         }

  308.         /// <summary>
  309.         /// 显示测量流量和测量浓度
  310.         /// </summary>
  311.         public void ShowFlowAndConcentration()
  312.         {
  313.             ComboBox[] comboBoxes = { cb_gas1, cb_gas2, cb_gas3, cb_gas4 };
  314.             TextBox[] tb_concentration = { tb_concentration1, tb_concentration2, tb_concentration3, tb_concentration4 };
  315.             TextBox[] tb_test_concentration = { tb_test_concentration1, tb_test_concentration2, tb_test_concentration3, tb_test_concentration4 };
  316.             double[] result = { 0, 0, 0, 0 };
  317.             double temp;
  318.             if (sp.IsOpen)
  319.             {
  320.                 try
  321.                 {
  322.                     for (int i = 1; i <= 4; i++)
  323.                     {
  324.                         if (comboBoxes[i - 1].Text != "")
  325.                         {
  326.                             if (comboBoxes[i - 1].Text != " ")
  327.                             {
  328.                                 DataProcessing.LogRecord("通道" + i + "读显示流量");
  329.                                 byte[] sendData = DataProcessing.SendDataformat("通道" + i, "读显示流量", "");
  330.                                 while (true)    //等待消息接收完成
  331.                                 {
  332.                                     if (isReceived)
  333.                                     {
  334.                                         isReceived = false;
  335.                                         SerialPortHandle.SendSerialData(sp, sendData);
  336.                                         Thread.Sleep(100);
  337.                                         break;
  338.                                     }
  339.                                 }
  340.                                 switch (i)
  341.                                 {
  342.                                     case 1:
  343.                                         temp = CountFlowAndConcentration(DataProcessing.aisle1);
  344.                                         result[0] = Convert.ToInt32(temp / 4095 * 2000);
  345.                                         tb_flow1.Text = result[0].ToString();
  346.                                         //tb_test_concentration1.Text = (result[0] * double.Parse(tb_coefficient1.Text)).ToString();
  347.                                         tb_states1.Text = MeasuringCondition(aisle1_setFlow, temp);
  348.                                         break;
  349.                                     case 2:
  350.                                         temp = CountFlowAndConcentration(DataProcessing.aisle2);
  351.                                         result[1] = Convert.ToInt32(temp / 4095 * 2000);
  352.                                         tb_flow2.Text = result[1].ToString();
  353.                                         //tb_test_concentration2.Text = (result[1] * double.Parse(tb_coefficient2.Text)).ToString();
  354.                                         tb_states2.Text = MeasuringCondition(aisle2_setFlow, temp);
  355.                                         break;
  356.                                     case 3:
  357.                                         temp = CountFlowAndConcentration(DataProcessing.aisle3);
  358.                                         result[2] = Convert.ToInt32(temp / 4095 * 2000);
  359.                                         tb_flow3.Text = result[2].ToString();
  360.                                         //tb_test_concentration3.Text = (result[2] * double.Parse(tb_coefficient3.Text)).ToString();
  361.                                         tb_states3.Text = MeasuringCondition(aisle3_setFlow, temp);
  362.                                         break;
  363.                                     case 4:
  364.                                         temp = CountFlowAndConcentration(DataProcessing.aisle4);
  365.                                         result[3] = Convert.ToInt32(temp / 4095 * 2000);
  366.                                         tb_flow4.Text = result[3].ToString();
  367.                                         //tb_test_concentration4.Text = (result[3] * double.Parse(tb_coefficient4.Text)).ToString();
  368.                                         tb_states4.Text = MeasuringCondition(aisle4_setFlow, temp);
  369.                                         break;
  370.                                 }
  371.                             }
  372.                         }
  373.                     }
  374.                     DataProcessing.GetTestGasCoefficient(result);
  375.                     for (int j = 0; j < comboBoxes.Length; j++)
  376.                     {
  377.                         if (comboBoxes[j].Text != "")
  378.                         {
  379.                             if (comboBoxes[j].Text != " ")
  380.                             {
  381.                                 if (comboBoxes[j].Text == "N2")
  382.                                 {
  383.                                     //tb_test_concentration[j].Text = (double.Parse(tb_concentration[j].Text) * 1).ToString("#0.00");
  384.                                 }
  385.                                 else
  386.                                 {
  387.                                     tb_test_concentration[j].Text = (double.Parse(tb_concentration[j].Text) * DataProcessing.testGasR[j]).ToString("#0.00");
  388.                                 }
  389.                                     
  390.                             }
  391.                         }
  392.                     }
  393.                 }
  394.                 catch (System.Exception ex)
  395.                 {
  396.                     MessageBox.Show("ShowFlowAndConcentration函数：" + ex.Message);
  397.                 }
  398.             }
  399.         }

  401.         /// <summary>
  402.         ///
  403.         /// </summary>
  404.         /// <param name="aisle"></param>
  405.         /// <returns></returns>
  406.         private static double CountFlowAndConcentration(byte[] aisle)
  407.         {
  408.             double temp = double.Parse(Convert.ToInt32(aisle[1] * 256 + aisle[2]).ToString());
  409.             if (temp > 4095)
  410.             {
  411.                 temp = 0;
  412.             }
  413.             DataProcessing.LogRecord("读取的流量值为：" + temp);
  414.             return temp;
  415.         }

  417.         private void Bt_back_Click(object sender, EventArgs e)
  418.         {
  419.             //showTimer.Enabled = false;
  420.             //timerThread.Suspend();
  421.             bt_start.Enabled = true;
  422.             cb_gas1.Enabled = true;
  423.             cb_gas2.Enabled = true;
  424.             cb_gas3.Enabled = true;
  425.             cb_gas4.Enabled = true;
  426.             tb_concentration1.ReadOnly = false;
  427.             tb_concentration2.ReadOnly = false;
  428.             tb_concentration3.ReadOnly = false;
  429.             tb_concentration4.ReadOnly = false;
  430.             tb_target_concentration1.ReadOnly = false;
  431.             tb_target_concentration2.ReadOnly = false;
  432.             tb_target_concentration3.ReadOnly = false;
  433.             tb_target_concentration4.ReadOnly = false;
  434.             tb_maxOutputFlow.ReadOnly = false;
  435.             tb_setOutputFlow.ReadOnly = false;
  436.             tb_flow1.Text = "";
  437.             tb_flow2.Text = "";
  438.             tb_flow3.Text = "";
  439.             tb_flow4.Text = "";
  440.             tb_test_concentration1.Text = "";
  441.             tb_test_concentration2.Text = "";
  442.             tb_test_concentration3.Text = "";
  443.             tb_test_concentration4.Text = "";
  444.             tb_concentration1.MouseDown += new System.Windows.Forms.MouseEventHandler(Tb_concentration1_MouseDown);
  445.             tb_concentration2.MouseDown += new System.Windows.Forms.MouseEventHandler(Tb_concentration2_MouseDown);
  446.             tb_concentration3.MouseDown += new System.Windows.Forms.MouseEventHandler(Tb_concentration3_MouseDown);
  447.             tb_concentration4.MouseDown += new System.Windows.Forms.MouseEventHandler(Tb_concentration4_MouseDown);
  448.             tb_target_concentration1.MouseDown += new System.Windows.Forms.MouseEventHandler(Tb_target_concentration1_MouseDown);
  449.             tb_target_concentration2.MouseDown += new System.Windows.Forms.MouseEventHandler(Tb_target_concentration2_MouseDown);
  450.             tb_target_concentration3.MouseDown += new System.Windows.Forms.MouseEventHandler(Tb_target_concentration3_MouseDown);
  451.             tb_target_concentration4.MouseDown += new System.Windows.Forms.MouseEventHandler(Tb_target_concentration4_MouseDown);
  452.             if (sp.IsOpen)
  453.             {
  454.                 timer.Enabled = false;
  455.                 for (int i = 1; i <= 4; i++)
  456.                 {
  457.                     while (true)    //等待消息接收完成
  458.                     {
  459.                         if (isReceived)
  460.                         {
  461.                             isReceived = false;
  462.                             SerialPortHandle.SendSerialData(sp, DataProcessing.SendDataformat("通道" + i, "阀控关闭", ""));
  463.                             Thread.Sleep(100);
  464.                             break;
  465.                         }
  466.                     }
  467.                 }
  468.                 tb_states1.Text = "关闭";
  469.                 tb_states2.Text = "关闭";
  470.                 tb_states3.Text = "关闭";
  471.                 tb_states4.Text = "关闭";
  472.                 //tb_states1.ForeColor = System.Drawing.SystemColors.WindowText;
  473.                 //tb_states2.ForeColor = System.Drawing.SystemColors.WindowText;
  474.                 //tb_states3.ForeColor = System.Drawing.SystemColors.WindowText;
  475.                 //tb_states4.ForeColor = System.Drawing.SystemColors.WindowText;
  476.                 //sp.Close();
  477.             }
  478.         }

  480.         public static bool isReceived = false;

  482.         /// <summary>
  483.         /// 串口数据接收
  484.         /// </summary>
  485.         /// <param name="sender"></param>
  486.         /// <param name="e"></param>
  487.         private void Sp_DataReceived(object sender, SerialDataReceivedEventArgs e)
  488.         {
  489.             Thread.Sleep(50);
  490.             int bufferlen = sp.BytesToRead;
  491.             string readStr = "";
  492.             if (bufferlen > 0)
  493.             {
  494.                 byte[] readbuffer = new byte[bufferlen];
  495.                 sp.Read(readbuffer, 0, readbuffer.Length);
  496.                 for (int i = 0; i < readbuffer.Length; i++)
  497.                 {
  498.                     readStr += readbuffer[i] + "/";
  499.                 }
  500.                 DataProcessing.LogRecord("串口接收到的数据：" + readStr);
  501.                 Thread dataAnalysisThread = new Thread(() => DataProcessing.DataAnalysis(readbuffer));
  502.                 dataAnalysisThread.IsBackground = true;
  503.                 dataAnalysisThread.Start();
  504.                 //DataProcessing.DataAnalysis(readbuffer);
  505.                 isReceived = true;
  506.             }
  507.         }
  508.         
  509.         /// <summary>
  510.         /// 机器初始化设置
  511.         /// </summary>
  512.         /// <param name="sp">通信的串口</param>
  513.         private static void MachineInitialization(SerialPort sp)
  514.         {
  515.             Queue initializtionQueue = new Queue();
  516.             initializtionQueue.Clear();

  518.             initializtionQueue.Enqueue(DataProcessing.SendDataformat("通道1", "阀控关闭", ""));   //0  
  519.             initializtionQueue.Enqueue(DataProcessing.SendDataformat("通道1", "读关闭", ""));    //1  
  520.             

  522.             initializtionQueue.Enqueue(DataProcessing.SendDataformat("通道2", "阀控关闭", ""));   //2
  523.             initializtionQueue.Enqueue(DataProcessing.SendDataformat("通道2", "读关闭", ""));    //3


  526.             initializtionQueue.Enqueue(DataProcessing.SendDataformat("通道3", "阀控关闭", ""));   //4
  527.             initializtionQueue.Enqueue(DataProcessing.SendDataformat("通道3", "读关闭", ""));    //5


  530.             initializtionQueue.Enqueue(DataProcessing.SendDataformat("通道4", "阀控关闭", ""));   //6
  531.             initializtionQueue.Enqueue(DataProcessing.SendDataformat("通道4", "读关闭", ""));    //7

  533.             SendQueueMessage(sp,initializtionQueue);
  534.         }

  536.         /// <summary>
  537.         /// 发送队列消息
  538.         /// </summary>
  539.         /// <param name="sp">串口对象</param>
  540.         /// <param name="sendQueue">需要发送的消息队列</param>
  541.         private static void SendQueueMessage(SerialPort sp,Queue sendQueue)
  542.         {
  543.             if (sp.IsOpen)
  544.             {
  545.                 isReceived = true;
  546.                 foreach (byte[] sendData in sendQueue)
  547.                 {
  548.                     int index = GetIndexFromQueue(sendData, sendQueue);
  549.                     //send:  SerialPortHandle.SendSerialData(sp, sendData);

  551.                     send: while (true)    //等待消息接收完成
  552.                     {
  553.                         if (isReceived)
  554.                         {
  555.                             isReceived = false;
  556.                             SerialPortHandle.SendSerialData(sp, sendData);
  557.                             Thread.Sleep(50);
  558.                             break;
  559.                         }
  560.                     }

  562.                     if (index == 1)
  563.                     {
  564.                         if (DataProcessing.aisle1[1] != 0x01)
  565.                         {
  566.                             goto send;
  567.                         }
  568.                     }
  569.                     else if (index == 3)
  570.                     {
  571.                         if (DataProcessing.aisle2[1] != 0x01)
  572.                         {
  573.                             goto send;
  574.                         }
  575.                     }
  576.                     else if (index == 5)
  577.                     {
  578.                         if (DataProcessing.aisle3[1] != 0x01)
  579.                         {
  580.                             goto send;
  581.                         }
  582.                     }
  583.                     else if (index == 7)
  584.                     {
  585.                         if (DataProcessing.aisle4[1] != 0x01)
  586.                         {
  587.                             goto send;
  588.                         }
  589.                     }
  590.                     else
  591.                     {
  592.                         //continue;
  593.                     }
  594.                     //isReceived = false;
  595.                 }
  596.                 sendQueue.Clear();
  597.             }
  598.         }

  600.         /// <summary>
  601.         /// 获取队列索引值
  602.         /// </summary>
  603.         /// <param name="element">被索引的元素</param>
  604.         /// <param name="queue">索引队列</param>
  605.         /// <returns>索引值</returns>
  606.         private static int GetIndexFromQueue(byte[] element, Queue queue)
  607.         {
  608.             int index = 0;
  609.             if (queue.Count > 0)
  610.             {
  611.                 for (int i = 0; i < queue.ToArray().Length; i++)
  612.                 {
  613.                     if (element == queue.ToArray()[i])
  614.                     {
  615.                         index = i;
  616.                         break;
  617.                     }
  618.                 }
  619.             }
  620.             return index;
  621.         }

  623.         private void Timer_Tick(object sender, EventArgs e)
  624.         {
  625.             if (sp.IsOpen)
  626.             {
  627.                 timer.Enabled = false;
  628.                 ShowFlowAndConcentration();
  629.                 sp.DiscardInBuffer();
  630.                 sp.DiscardOutBuffer();
  631.                 timer.Enabled = true;
  632.             }
  633.         }

  635.         /// <summary>
  636.         /// 获取测量状态
  637.         /// </summary>
  638.         /// <param name="setFlow">设定的流量值</param>
  639.         /// <param name="testFlow">测试的流量值</param>
  640.         /// <param name="textBox"></param>
  641.         /// <returns></returns>
  642.         private static string MeasuringCondition(string setFlow, double testFlow)
  643.         {
  644.             string status;
  645.             //textBox.ReadOnly = false;
  646.             double difference = System.Math.Abs(testFlow - double.Parse(setFlow));
  647.             if (double.Parse(setFlow) > 100)
  648.             {
  649.                 if (difference > double.Parse(setFlow) * 0.05)
  650.                 {
  651.                     status = "异常";
  652.                     //textBox.ForeColor = System.Drawing.Color.Red;
  653.                 }
  654.                 else
  655.                 {
  656.                     status = "正常";
  657.                     //textBox.ForeColor = System.Drawing.Color.Chartreuse;
  658.                 }
  659.             }
  660.             else
  661.             {
  662.                 if (difference > 5)
  663.                 {
  664.                     status = "异常";
  665.                     //textBox.ForeColor = System.Drawing.Color.Red;
  666.                 }
  667.                 else
  668.                 {
  669.                     status = "正常";
  670.                     //textBox.ForeColor = System.Drawing.Color.Chartreuse;
  671.                 }
  672.             }
  673.             //textBox.ReadOnly = true;
  674.             return status;
  675.         }

  677.         /// <summary>
  678.         /// 获取键盘窗口输入值
  679.         /// </summary>
  680.         /// <param name="textBox"></param>
  681.         private void GetKeyBoardValue(TextBox textBox)
  682.         {

  684.             KeyBoardForm keyBoard = new KeyBoardForm();
  685.             keyBoard.ShowDialog();
  686.             textBox.Text = keyBoardValue;
  687.             keyBoard.Dispose();
  688.         }

  690.         private void Bt_clear_Click(object sender, EventArgs e)
  691.         {
  692.             
  693.         }

  695.         private void Tb_setOutputFlow_MouseDown(object sender, MouseEventArgs e)
  696.         {
  697.             GetKeyBoardValue(tb_setOutputFlow);
  698.         }

  700.         private void Tb_concentration1_MouseDown(object sender, MouseEventArgs e)
  701.         {
  702.             GetKeyBoardValue(tb_concentration1);
  703.         }

  705.         private void Tb_concentration2_MouseDown(object sender, MouseEventArgs e)
  706.         {
  707.             GetKeyBoardValue(tb_concentration2);
  708.         }

  710.         private void Tb_concentration3_MouseDown(object sender, MouseEventArgs e)
  711.         {
  712.             GetKeyBoardValue(tb_concentration3);
  713.         }

  715.         private void Tb_concentration4_MouseDown(object sender, MouseEventArgs e)
  716.         {
  717.             GetKeyBoardValue(tb_concentration4);
  718.         }

  720.         private void Tb_target_concentration1_MouseDown(object sender, MouseEventArgs e)
  721.         {
  722.             GetKeyBoardValue(tb_target_concentration1);
  723.         }

  725.         private void Tb_target_concentration2_MouseDown(object sender, MouseEventArgs e)
  726.         {
  727.             GetKeyBoardValue(tb_target_concentration2);
  728.         }

  730.         private void Tb_target_concentration3_MouseDown(object sender, MouseEventArgs e)
  731.         {
  732.             GetKeyBoardValue(tb_target_concentration3);
  733.         }

  735.         private void Tb_target_concentration4_MouseDown(object sender, MouseEventArgs e)
  736.         {
  737.             GetKeyBoardValue(tb_target_concentration4);
  738.         }

  740.         private void Tb_setOutputFlow_TextChanged(object sender, EventArgs e)
  741.         {
  742.             if (sp.IsOpen)
  743.             {
  744.                 if (!bt_start.Enabled)
  745.                 {
  746.                     WriteSetflowValue();
  747.                 }
  748.             }
  749.         }

  751.         private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
  752.         {
  753.             if (sp.IsOpen)
  754.             {
  755.                 sp.Close();
  756.             }
  757.         }

  759.     }
  760. }
复制代码

所有资料51hei提供下载:
GCC.rar (326.54 KB, 下载次数: 22)


评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏2 分享淘帖 顶顶 踩踩
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表