JG_TpsLabStudio_LTS/tps/TpsLabStudio/com/DioControlClass.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO.Ports;
using System.Threading;
using System.Windows.Forms;

namespace Tps_LQ_Transmitter.com
{
    /// <summary>
    /// DIO控制板与JSY电压电流模拟量采集模块 控制类。
    /// [DIO控制板与JSY模块都是RS485通信共用计算机的串口COM6]。
    /// </summary>
    public class DioControlClass:MySerial
    {
        SerialPort serial = null;
        public enum State {ON,OFF};
        public DioControlClass()
        {
            serial = new SerialPort();
            serial.PortName = "COM6";     //DIO控制板与JSY模块都是RS485通信共用计算机的串口COM6
            serial.BaudRate = 9600;
            serial.DataBits = 8;
            serial.StopBits = StopBits.One;//停止位设置为com_stop的值
            serial.Parity = Parity.None;//获取奇偶校验选项的值
            serial.ReadTimeout = 1000;    //读取等待时间1000
            serial.RtsEnable = true;
            if (!serial.IsOpen)
            {
                serial.Open();
                Thread.Sleep(50);
            }
            
        }
        public override void portClose()
        {
            serial.Close();
        }

        #region DIO

        /// <summary>
        /// DIO输出控制
        /// </summary>
        /// <param name="ch">控制通道号0-16</param>
        /// <param name="st">控制状态ON/OFF</param>
        public void DioOutput(int ch, State st)
        {
            byte[] byCh = { 0x7E, 0x7E, 0x01, 0x01, 0x00, 0x01, 0x0D, 0x0A };
            byCh[4] = (byte)ch;
            if (st== State.ON)
            { 
                byCh[5] = 0x01;
            }
            else
            {
                byCh[5] = 0x00;
            }
            if (serial.IsOpen==true)
            {
                serial.Write(byCh, 0, byCh.Length);
                Thread.Sleep(50);
            }
        }
        /// <summary>
        /// 供电开关
        /// </summary>
        /// <param name="ch">通道号(从1开始)</param>
        /// <param name="st">ON/off</param>
        public void SupplySwitch(int ch, State st)
        {
            if (ch>=1&&ch<=8)
            {
                ch = ch - 1;
                DioOutput(ch, st);
            }
            else
            {
                MessageBox.Show("超出通道号范围", "提示");
            }
        }

        /// <summary>
        /// 一分八射频开关控制
        /// </summary>
        /// <param name="ch"></param>
        /// <param name="st"></param>
        public void OneToEight(int ch,State st)
        {
            int chPlay = 16;
            switch (ch)
            {
                case 1:
                    chPlay = 16;
                    break;
                case 2:
                    chPlay = 17;
                    break;
                case 3:
                    chPlay = 18;
                    break;
                case 4:
                    chPlay = 19;
                    break;
                case 5:
                    chPlay = 20;
                    break;
                case 6:
                    chPlay = 21;
                    break;
                case 7:
                    chPlay = 22;
                    break;
                case 8:
                    chPlay = 23;
                    break;
                default:
                    break;
            }
            for (int i = 0; i < 8; i++)
            {
                DioOutput(16+i, State.OFF);
                Thread.Sleep(5);
            }
            DioOutput(chPlay, st);
        }

        /// <summary>
        /// 一分四射频开关控制
        /// </summary>
        /// <param name="ch"></param>
        /// <param name="st"></param>
        public void OneToFour(int ch, State st)
        {
            int chPlay = 11;
            switch (ch)
            {
                case 1:
                    chPlay = 11;
                    break;
                case 2:
                    chPlay = 12;
                    break;
                case 3:
                    chPlay = 13;
                    break;
                case 4:
                    chPlay = 14;
                    break;              
                default:
                    break;
            }
            for (int i = 0; i < 4; i++)
            {
                DioOutput(11 + i, State.OFF);
                Thread.Sleep(5);
            }
            DioOutput(chPlay, st);
        }
        /// <summary>
        /// 仪器接入(一分四射频开关控制)
        /// </summary>
        /// <param name="str"></param>
        public void RfSwitchX(string str)
        {
            if (str=="功率计")
            {
                OneToFour(1,State.ON);
            }
            else if (str == "频谱仪")
            {
                OneToFour(2, State.ON);
            }
            else if (str == "解调入")
            {
                OneToFour(3, State.ON);
            }
            else
            {
                OneToFour(4, State.OFF);
            }
        }
        /// <summary>
        /// 一分二射频开关控制(多模解调模块切换)
        /// </summary>
        /// <param name="st"></param>
        public void OneToTwo( State st)
        {
            int chPlay = 15;
            DioOutput(chPlay, st);
        }
        #endregion

        #region JSY

        /// <summary>
        /// JSY电压电流模拟量采集查询
        /// </summary>
        /// <param name="data"></param>
        /// <returns>采集数据byte[]</returns>
        public byte[] QueryJSY(byte[] data,int delay=150)
        {
            if (data == null)
                return null;

            //先读空
            if (serial.BytesToRead > 0)
                serial.DiscardInBuffer();

            byte[] crc = crc16(data);
            byte[] newarray = new byte[data.Length + 2];
            Array.Copy(data, newarray, data.Length);
            newarray[data.Length] = crc[0];
            newarray[data.Length + 1] = crc[1];

            serial.Write(newarray, 0, newarray.Length);
            Thread.Sleep(delay);
            if (serial.BytesToRead > 0)
            {
                byte[] dat = new byte[serial.BytesToRead];
                serial.Read(dat, 0, dat.Length);
                return dat;
            }
            else
            {
                return null;
            }
        }
        /// <summary>
        ///  JSY模块单通道电压(V)读取
        /// </summary>
        /// <param name="ch">通道号(从1开始)</param>
        /// <returns>电压值</returns>
        public double ReadVolt(int ch)
        {
            double volt=0;
            byte[] command = {0x01,0x03,0x00,0x70,0x00,0x01};
            byte[] rddat = new byte[7];
            byte[] dat = new byte[5];
            switch (ch)
            {
                case 1:
                    command[3] = 0x70;
                    break;
                case 2:
                    command[3] = 0x71;
                    break;
                case 3:
                    command[3] = 0x72;
                    break;
                case 4:
                    command[3] = 0x73;
                    break;
                case 5:
                    command[3] = 0x74;
                    break;
                case 6:
                    command[3] = 0x75;
                    break;
                case 7:
                    command[3] = 0x76;
                    break;
                case 8:
                    command[3] = 0x77;
                    break;
                default:
                    command[3] = 0x70;
                    break;
            }
            rddat = QueryJSY(command);
            for (int i = 0; i < 5; i++)
            {
                dat[i] = rddat[i];
            }
            byte[] crcval=crc16(dat);

            if (rddat[5]== crcval[0] && rddat[6] == crcval[1])
            {
                ushort dat1=(ushort)((rddat[3] << 8) + rddat[4]);
                volt = dat1 / 100.0;

            }
            return volt;
        }

        /// <summary>
        /// JSY模块8个通道电压(V)同时读取
        /// </summary>
        /// <returns>电压值数组double[]</returns>
        public double[] ReadAllVolt()
        {
            double[] volt = new double[8];
            byte[] command = { 0x01, 0x03, 0x00, 0x70, 0x00, 0x08 };
            byte[] rddat = new byte[21];
            byte[] dat = new byte[19];
            rddat = QueryJSY(command);
            for (int i = 0; i < 19; i++)
            {
                dat[i] = rddat[i];
            }
            byte[] crcval = crc16(dat);

            if (rddat[19] == crcval[0] && rddat[20] == crcval[1])
            {
                for (int i = 0; i < 8; i++)
                {
                    ushort dat1 = (ushort)((rddat[3 + 2 * i] << 8) + rddat[4 + 2 * i]);
                    volt[i] = dat1 / 100.0;
                }
            }
            return volt;
        }


        /// <summary>
        /// JSY模块单通道电流(A)读取
        /// </summary>
        /// <param name="ch">通道号(从1开始)</param>
        /// <returns>电流值</returns>
        public double ReadCurr(int ch)
        {
            double curr = 0;
            byte[] command = { 0x01, 0x03, 0x00, 0x78, 0x00, 0x01 };
            byte[] rddat = new byte[7];
            byte[] dat = new byte[5];
            switch (ch)
            {
                case 1:
                    command[3] = 0x78;
                    break;
                case 2:
                    command[3] = 0x79;
                    break;
                case 3:
                    command[3] = 0x7A;
                    break;
                case 4:
                    command[3] = 0x7B;
                    break;
                case 5:
                    command[3] = 0x7C;
                    break;
                case 6:
                    command[3] = 0x7D;
                    break;
                case 7:
                    command[3] = 0x7E;
                    break;
                case 8:
                    command[3] = 0x7F;
                    break;
                default:
                    command[3] = 0x78;
                    break;
            }
            rddat = QueryJSY(command);
            for (int i = 0; i < 5; i++)
            {
                dat[i] = rddat[i];
            }
            byte[] crcval = crc16(dat);

            if (rddat[5] == crcval[0] && rddat[6] == crcval[1])
            {
                ushort dat1 = (ushort)((rddat[3] << 8) + rddat[4]);
                curr = dat1 / 1000.0;

            }
            return curr;
        }
        /// <summary>
        /// JSY模块8个通道电流(A)同时读取
        /// </summary>
        /// <returns>电流值数组double[]</returns>
        public double[] ReadAllCurr()
        {
            double[] curr = new double[8];
            byte[] command = { 0x01, 0x03, 0x00, 0x78, 0x00, 0x08 };
            byte[] rddat = new byte[21];
            byte[] dat = new byte[19];
            rddat = QueryJSY(command);
            for (int i = 0; i < 19; i++)
            {
                dat[i] = rddat[i];
            }
            byte[] crcval = crc16(dat);

            if (rddat[19] == crcval[0] && rddat[20] == crcval[1])
            {
                for (int i = 0; i < 8; i++)
                {
                    ushort dat1 = (ushort)((rddat[3 + 2 * i] << 8) + rddat[4 + 2 * i]);
                    curr[i] = dat1 / 1000.0;
                }
            }
            return curr;
        }


        /// <summary>
        /// JSY模块单通道供电功率(W)读取
        /// </summary>
        /// <param name="ch">通道号</param>
        /// <returns>电流值</returns>
        public double ReadPower(int ch)
        {
            double power = 0;
            byte[] command = { 0x01, 0x03, 0x00, 0x80, 0x00, 0x01 };
            byte[] rddat = new byte[7];
            byte[] dat = new byte[5];
            switch (ch)
            {
                case 1:
                    command[3] = 0x80;
                    break;
                case 2:
                    command[3] = 0x81;
                    break;
                case 3:
                    command[3] = 0x82;
                    break;
                case 4:
                    command[3] = 0x83;
                    break;
                case 5:
                    command[3] = 0x84;
                    break;
                case 6:
                    command[3] = 0x85;
                    break;
                case 7:
                    command[3] = 0x86;
                    break;
                case 8:
                    command[3] = 0x87;
                    break;
                default:
                    command[3] = 0x80;
                    break;
            }
            rddat = QueryJSY(command);
            for (int i = 0; i < 5; i++)
            {
                dat[i] = rddat[i];
            }
            byte[] crcval = crc16(dat);

            if (rddat[5] == crcval[0] && rddat[6] == crcval[1])
            {
                ushort dat1 = (ushort)((rddat[3] << 8) + rddat[4]);
                power = dat1 / 1.0;

            }
            return power;
        }
        /// <summary>
        /// JSY模块8个通道的供电功率(W)同时读取
        /// </summary>
        /// <returns>电流值数组double[]</returns>
        public double[] ReadAllPower()
        {
            double[] power = new double[8];
            byte[] command = { 0x01, 0x03, 0x00, 0x80, 0x00, 0x08 };
            byte[] rddat = new byte[21];
            byte[] dat = new byte[19];
            rddat = QueryJSY(command);
            for (int i = 0; i < 19; i++)
            {
                dat[i] = rddat[i];
            }
            byte[] crcval = crc16(dat);

            if (rddat[19] == crcval[0] && rddat[20] == crcval[1])
            {
                for (int i = 0; i < 8; i++)
                {
                    ushort dat1 = (ushort)((rddat[3 + 2 * i] << 8) + rddat[4 + 2 * i]);
                    power[i] = dat1 / 1.0;
                }
            }
            return power;
        }
        #endregion
    }
}