using System.Net.Sockets;
using System.Net;
using System.Text;
using System.IO;

namespace TCPServerDemo
{
    internal class Program
    {
        /// <summary>
        /// 0：DO 继电器输出接口
        /// 1：DI 开关量输入接口
        /// 2：AI 模拟量输入接口
        /// 3：VO 语音输出接口
        /// 4：PC电脑开关机接口
        /// 5：RS485相关指令
        /// </summary>
        public static int Type = 3;

        static void Main(string[] args)
        {
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
            TCPServerDemo();
            Console.WriteLine("更多控制指令的详细解释请查阅《AT指令手册V2.9.PDF》");
            Console.WriteLine("本Demo仅用于开发参考，不能直接用于商业项目实施！");
            Console.ReadLine();
        }

        public static void TCPServerDemo()
        {
            //服务端的IP地址
            //请先在终端上查询服务器IP
            string serverIP = "192.168.10.173";
            //服务器端口
            int serverPort = 6000;

            Console.WriteLine("本机作为服务端");
            Console.WriteLine($"本机IP：{serverIP}，端口：{serverPort}");

            //使用指定的地址族，套接字类型和协议实例化新的套接字
            Socket socketServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //将字符串地址转化为网际协议地址
            IPAddress ipAddress = IPAddress.Parse(serverIP);//这里为服务器IP
            //使用指定地址和端口号实例化新的网络端点
            IPEndPoint endPoint = new IPEndPoint(ipAddress, serverPort);//ipAddress为服务器IP ， 6000为服务器端口
            try
            {
                //socket与本地终结点相关联，绑定IP与端口
                socketServer.Bind(endPoint);
                //设置最大侦听长度，并启动侦听
                socketServer.Listen(200);
            }
            catch
            {
                Console.WriteLine("请检查IP是否正确，或端口是否被占用？");
                Console.ReadKey();
                socketServer.Close();
                return;
            }

            Console.WriteLine("启动侦听，等待客户端请求连接。。。");
            //等待客户端连接，如果没有客户端连接，即会一址等待
            //1、将硬件设备为TCP_Client
            //2、将硬件的目的IP设置与 serverIP 一致的值
            //3、将硬件的目的端口设备与 serverPort 一致的值
            //如果硬件不能连接上，请检查以上参数
            Socket socket = socketServer.Accept();
            Console.WriteLine("连接成功");

            string[] strs = socket.RemoteEndPoint.ToString().Split(':');
            Console.WriteLine("客户端IP：" + strs[0] + " 端口：" + strs[1]);
            // 以下为数据发送与接收
            switch (Type)
            {
                case 0:
                    {
                        TestDO(socket);
                    }
                    break;
                case 1:
                    {
                        TestDI(socket);
                    }
                    break;
                case 2:
                    {
                        TestAI(socket);
                    }
                    break;
                case 3:
                    {
                        TestVO(socket);
                    }
                    break;
                case 4:
                    {
                        TestPC(socket);
                    }
                    break;
                case 5:
                    {
                        TestRS485(socket);
                    }
                    break;
                default:
                    break;
            }
            Console.WriteLine("测试完成");
        }

        public static void TestDO(Socket socket)
        {
            Console.WriteLine("DO 继电器输出接口测试");

            #region 控制 DO 继电器输出接口 OUT1 吸合
            //控制 DO 继电器输出接口 OUT1 吸合
            string sendCmd = "AT+STACH1=1\r\n";// \r\n(回车换行)
            Console.WriteLine($"控制 DO 继电器输出接口 OUT1 吸合，发送指令：{sendCmd.Trim()} \\r\\n");
            //将字符串指令转换为byte数组  编码为GB2312
            byte[] SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            byte[] recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            int recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            string recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

            #region 时间单位
            int timeType = 0; //0：秒 1：100毫秒
            //时间单位改成 秒

            sendCmd = $"AT+DLYUNIT={timeType}\r\n";// \r\n(回车换行)
            Console.WriteLine($"时间单位改成 {(timeType == 1 ? "100毫秒" : "秒")}，发送指令：{sendCmd.Trim()}\\r\\n");
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

            #region 控制 DO 继电器输出接口 OUT1 点动开，开启后延时<dlyTime>时间再关闭，参数<waitTime>和<times>可忽略
            int dlyTime = 5;//时间单位为秒或 100 毫秒，可通过 AT+DLYUNIT=0<回车换行> 指令设置  0：秒，1：100毫秒
            int waitTime = 100000;//时间单位为秒或 100 毫秒，可通过 AT+DLYUNIT=0<回车换行> 指令设置  0：秒，1：100毫秒
            int times = 1000000;

            //控制 DO 继电器输出接口 OUT1 点动开
            sendCmd = $"AT+STACH1=3,{dlyTime},{waitTime},{times}\r\n";// \r\n(回车换行)
            Console.WriteLine($"控制 DO 继电器输出接口 OUT1 点动开，开启后延时<{(timeType == 1 ? $"{dlyTime}*100毫秒" : "秒")}>后再关闭；发送指令：发送指令：{sendCmd.Trim()}\\r\\n");
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

            #region 控制 DO 继电器输出接口 OUT1~OUT4 间隔 1 秒轮流吸合
            //控制 DO 继电器输出接口 OUT1~OUT4 间隔 1 秒轮流吸合

            sendCmd = "AT+DODLY=1,1,4,1,1\r\n";// \r\n(回车换行)
            Console.WriteLine($"控制 DO 继电器输出接口 OUT1~OUT4 间隔 1 秒轮流吸合，发送指令：{sendCmd.Trim()}\\r\\n");
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

            #region 继电器 OUT1 每天早上 8 点定时吸合
            //继电器 OUT1 每天早上 8 点定时吸合 发送指令：AT+AUTOCONT=2,TASK1,[CYC:1],[T:3,0|1|2|3|4|5|6,08:00:00],[DO:0,1,1,100000,100000,1000000],[N:1,0]<回车换行>

            sendCmd = "AT+AUTOCONT=2,TASK1,[CYC:1],[T:3,0|1|2|3|4|5|6,08:00:00],[DO:0,1,1,100000,100000,1000000],[N:1,0]\r\n";// \r\n(回车换行)
            Console.WriteLine($"继电器 OUT1 每天早上 8 点定时吸合，发送指令：{sendCmd.Trim()}\\r\\n");

            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

            #region IN1/DI1 联动控制继电器 OUT1 点动输出 5 秒
            //IN1/DI1 联动控制继电器 OUT1 点动输出 5 秒；发送指令：AT+LINKAGE1=3,5,100000,1,1000000<回车换行>
            Console.WriteLine($"IN1/DI1 联动控制继电器 OUT1 点动输出 5 秒，发送指令：{sendCmd.Trim()}\\r\\n");
            sendCmd = "AT+LINKAGE1=3,5,100000,1,1000000\r\n";// \r\n(回车换行)
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

            #region 上电默认状态设置为吸合
            //上电默认状态设置为吸合；发送指令：AT+DODEFSTA=1<回车换行>
            Console.WriteLine($"上电默认状态设置为吸合，发送指令：{sendCmd.Trim()}\\r\\n");
            sendCmd = "AT+DODEFSTA=1\r\n";// \r\n(回车换行)
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

            #region 使能状态主动上传
            //使能状态主动上传；发送指令：AT+KPUPLOAD=1<回车换行>
            Console.WriteLine($"使能状态主动上传，发送指令：{sendCmd.Trim()}\\r\\n");
            sendCmd = "AT+KPUPLOAD=1\r\n";// \r\n(回车换行)
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

            #region 使能掉电保存
            //使能掉电保存；发送指令：AT+KPKEEP=1<回车换行>
            Console.WriteLine($"使能掉电保存，发送指令：{sendCmd.Trim()}\\r\\n");
            sendCmd = "AT+KPKEEP=1\r\n";// \r\n(回车换行)
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

        }

        public static void TestDI(Socket socket)
        {
            //上传类型 uploadType 0：被动上传  1：定时上传  2：触发上传(所有通道)  3：触发上传(单个通道)
            int uploadType = 1;
            int uploadInterval = 300; //上传间隔 单位：10ms

            Console.WriteLine("DI 开关量输入接口测试");

            #region 被动上传(实时读取)
            string sendCmd = "AT+OCCH1=?\r\n";
            Console.WriteLine($"读取 DI 开关量输入接口 IN1/DI1 的状态：发送指令：{sendCmd.Trim()}\\r\\n");
            //将字符串指令转换为byte数组  编码为GB2312
            byte[] SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            byte[] recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            int recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            string recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

            sendCmd = $"AT+OCMOD={uploadType},{(uploadType == 1 ? uploadInterval : 0)}\r\n";
            Console.WriteLine($"设置DI上传模式：发送指令：{sendCmd.Trim()}\\r\\n");
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
        }

        public static void TestAI(Socket socket)
        {
            Console.WriteLine("AI 模拟量输入接口");
            //上传类型 uploadType 0：被动上传  1：定时上传  2：触发上传  3：定时 + 触发上传
            int uploadType = 1;
            int uploadInterval = 30; //上传间隔 单位：100ms

            #region 设置信号类型
            //设置 AI1 接口的信号类型是电压型
            string sendCmd = "AT+AIMODE1=0\r\n";
            Console.WriteLine($"设置 AI1 接口的信号类型是电压型：发送指令：{sendCmd.Trim()}\\r\\n");
            //将字符串指令转换为byte数组  编码为GB2312
            byte[] SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            byte[] recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            int recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            string recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

            #region 被动上传(实时读取)
            //读取 AI1 接口实时采样值
            sendCmd = "AT+AIVALUE1=?\r\n";
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[20];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");

            #endregion

            #region 定时上传、触发上传、定时+触发上传 
            if (uploadType == 1)
            {
                //设置3秒上传1次AI1接口采样值(定时上传)
                uploadInterval = 30;
                sendCmd = $"AT+AIUPLOAD1={uploadType},{uploadInterval}\r\n";
            }
            else if (uploadType == 2)
            {
                //设置AI1接口采样值高于2000并持续3秒触发上传
                uploadInterval = 0;
                sendCmd = $"AT+AIUPLOAD1={uploadType},{uploadInterval},20,0,2000,0,0\r\n";
            }
            else if (uploadType == 3)
            {
                //设置3秒上传1次和AI1接口采样值高于2000并持续3秒触发上传
                uploadInterval = 30;
                sendCmd = $"AT+AIUPLOAD1={uploadType},{uploadInterval},20,0,2000,0,0\r\n";
            }
            Console.WriteLine($"设置AI上传模式：发送指令：{sendCmd.Trim()}\\r\\n");

            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

        }

        /// <summary>
        /// 发音人
        /// 0：晓玲（女声）
        /// 1：尹小坚（男声）
        /// 2：易小强（男声）
        /// 3：田蓓蓓（女声）
        /// 4：唐老鸭（效果器）
        /// 5：小燕子（女童声）
        /// </summary>
        public static int TtsPronunciationPeople = 4;
        /// <summary>
        /// 语调
        /// 0 - 不识别汉语拼音 1 - 识别汉语拼音 
        /// 注意： 
        /// 1）拼音格式为：1 至 6 位字母 + 1 位数字 
        /// 2）声调用 1 位数字表示 ：1 阴平、2 阳平、3 上声、4 去声、5 轻声
        /// </summary>
        public static int ToneOfVoice = 0;

        /// <summary>
        /// 语速 1-10档
        /// </summary>
        public static int TtsSpeed = 5;
        /// <summary>
        /// 语调 1-10档
        /// </summary>
        public static int TtsIntonation = 5;
        /// <summary>
        /// 音量 1-10档
        /// </summary>
        public static int TtsVolume = 5;
        /// <summary>
        /// TTS循环次数
        /// </summary>
        public static int TtsTimes = 1;
        /// <summary>
        /// TTS间隔时间
        /// </summary>
        public static int TtsInterval = 1;

        public static void TestVO(Socket socket)
        {
            Console.WriteLine("VO 语音输出接口");

            #region 实时播放
            //控制 VO1 接口播放文字“泥人科技”
            string sendCmd = "AT+TTS1=1,0,8\r\n泥人科技";
            Console.WriteLine($"控制 VO1 接口播放文字“泥人科技” 发送指令：AT+TTS1=1,0,8\\r\\n泥人科技");
            //将字符串指令转换为byte数组  编码为GB2312
            byte[] SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(1000);
            //真正使用时，接收缓冲区需要适当的调整
            byte[] recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            int recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            string recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");

            //控制 VO1 接口播放语音文件 1
            sendCmd = "AT+AUDIO1=1,10\r\n";
            Console.WriteLine($"控制 VO1 接口播放语音文件 1 发送指令：{sendCmd.Trim()}\\r\\n");
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");

            #endregion

            #region 定时播放
            //VO1 接口每天早上 8 点播放语音文件 1
            sendCmd = "AT+AUTOCONT=2,TASK1,[CYC:1],[T:3,0|1|2|3|4|5|6,08:00:00],[VO:0,1,1,10,1,0],[N:1,0]\r\n";
            Console.WriteLine($"VO1 接口每天早上 8 点播放语音文件 1  发送指令：{sendCmd.Trim()}\\r\\n");
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[20];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");

            #endregion

            #region 开关量联动播放
            //IN1/DI1 联动播放语音文件 1
            sendCmd = "AT+AUTOCONT=2,TASK1,[CYC:1],[DI:3,1,1],[VO:0,1,1,10,1,0],[N:1,0]\r\n";
            Console.WriteLine($"IN1/DI1 联动播放语音文件 1  发送指令：{sendCmd.Trim()}\\r\\n");
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[20];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");

            #endregion

            #region 文本播放拓展(发音人、声调、语速、语调)
            //使用VO1 接口、晓玲的声音 语速：5 语调：5 音量：5播放“泥人科技1234567890”
            string[] pronunciationPeople = new string[] { "3", "51", "52", "53", "54", "55" };
            //if (string.IsNullOrEmpty(txt)) return;
            string txt = "[m" + pronunciationPeople[TtsPronunciationPeople] + "][s"
                + TtsSpeed.ToString() + "][t" + TtsIntonation.ToString()
                + "][v" + TtsVolume.ToString() + "]" + $"欢迎[i{ToneOfVoice}]shi3用泥人科技1234567890";
            //以GB2312的格式转为byte数组
            byte[] bytes = Encoding.GetEncoding("GB2312").GetBytes(txt);
            sendCmd = "AT+TTS1=1,0," + TtsTimes.ToString() + ","
                + TtsInterval.ToString() + "," + bytes.Length.ToString() + "\r\n" + txt;
            //将字符串指令转换为byte数组  编码为GB2312
            Console.WriteLine($"使用VO1 接口、晓玲的声音 声调：0 语速：5 语调：5 音量：5  播放文本 发送指令：{sendCmd.Trim()}\\r\\n");
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[20];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion
        }

        public static void TestPC(Socket socket)
        {
            //上传类型 uploadType 0：被动上传  1：定时上传  2：触发上传  3：定时 + 触发上传
            int uploadType = 1;
            int uploadInterval = 30; //上传间隔 单位：100ms

            Console.WriteLine("电脑开关机接口测试");
            #region 实时控制
            //控制电脑开机
            string sendCmd = "AT+PCSSSTA=1\r\n";
            Console.WriteLine($"发送控制电脑开机指令：{sendCmd.Trim()}\\r\\n");
            //将字符串指令转换为byte数组  编码为GB2312
            byte[] SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            byte[] recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            int recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            string recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

            #region  定时控制
            //电脑每天早上 8 点定时开机
            sendCmd = $"AT+AUTOCONT=2,TASK1,[CYC:1],[T:3,0|1|2|3|4|5|6,08:00:00],[PC:0,1],[N:1,0]\r\n";
            Console.WriteLine($"发送电脑每天早上 8 点定时开机指令：{sendCmd.Trim()}\\r\\n");
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

            #region 被动上传(实时读取)
            //读取电脑开关机状态
            sendCmd = $"AT+PCSSSTA=?\r\n";
            Console.WriteLine($"发送读取电脑开关机状态：{sendCmd.Trim()}\\r\\n");
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion

            #region 定时上传、触发上传、定时 + 触发上传
            if (uploadType == 1)
            {
                //设置 3 秒上传 1 次电脑开关机状态
                sendCmd = $"AT+PCSSSTA={uploadType},{uploadInterval}\r\n";
                Console.WriteLine($"发送设置 3 秒上传 1 次电脑开关机状态指令：{sendCmd.Trim()}\\r\\n");
            }
            else if (uploadType == 2)
            {
                //设置电脑开关机状态触发上传
                sendCmd = $"AT+PCSSSTA={uploadType}\r\n";
                Console.WriteLine($"发送设置电脑开关机状态触发上传指令：{sendCmd.Trim()}\\r\\n");
            }
            else if (uploadType == 3)
            {
                //设置3秒和触发电脑开关机 上传1次电脑开关机状态
                sendCmd = $"AT+PCSSSTA={uploadType},{uploadInterval}\r\n";
                Console.WriteLine($"发送设置3秒和触发电脑开关机 上传1次电脑开关机状态指令：{sendCmd.Trim()}\\r\\n");
            }
            //将字符串指令转换为byte数组  编码为GB2312
            SendBuf = Encoding.GetEncoding("GB2312").GetBytes(sendCmd);
            //发送指令
            socket.Send(SendBuf);

            Thread.Sleep(100);
            //真正使用时，接收缓冲区需要适当的调整
            recBuf = new byte[10];
            //等待硬件响应命令，接收到的数据为byte数组
            //会等待到有数据返回为止
            recLen = socket.Receive(recBuf);
            //将byte数组转为字符串
            recMsg = Encoding.GetEncoding("GB2312").GetString(recBuf);
            recMsg = recMsg.Replace("\r\n", "").Replace("\0", "");
            Console.WriteLine($"指令应答：{recMsg}\\r\\n");
            #endregion
        }

        public static void TestRS485(Socket socket)
        {
            Console.WriteLine("RS485 通讯接口测试：");

        }
    }
}