using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.IO.Ports;

namespace TD4000系列上位机
{
    class MODBUS
    {
        public System.IO.Ports.SerialPort UartPort = new System.IO.Ports.SerialPort();//新建串口
        private bool RecvEnd = false;

        public MODBUS()
        {
            UartPort.DataReceived += UartPortDataRecv;//添加串口接收的方法
        }

        public int TimeOutVal = 1000;//通信超时时间，ms

        private void UartPortDataRecv(object sender, SerialDataReceivedEventArgs e)//串口接收事件
        {
            RecvEnd = true;
        }

        public bool Open(string PortName, int Baud, System.IO.Ports.Parity Parity)//打开串口
        {
            try
            {
                if (UartPort.IsOpen == true)
                {
                    UartPort.Close();//串口已经打开，则首先关闭串口
                }

                UartPort.PortName = PortName;
                UartPort.BaudRate = Baud;//波特率
                UartPort.Parity = Parity;//校验方式
                UartPort.StopBits = System.IO.Ports.StopBits.One;//停止位
                UartPort.ReadTimeout = 100;
                UartPort.DtrEnable = true;
                UartPort.RtsEnable = true;

                UartPort.Open();
            }
            catch
            {

                return false;
            }

            return true;
        }

        public void Close()
        {
            UartPort.Close();
        }

        static byte[] auchCRCHi = new byte[] { 
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0/**/, 
        0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
        0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 
        0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 
        0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 
        0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 
        0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 
        0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 
        0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 
        0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 
        0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 
        0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 
        0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
        0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 
        0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
        0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 
        0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 
        0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 
        0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 
        0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 
        0x80, 0x41, 0x00, 0xC1, 0x81, 0x40 
        };
        /* CRC֍低8位*/
        static byte[] auchCRCLo = new byte[]{ 
        0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06,
        0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD, 
        0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 		  
        0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 
        0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4, 
        0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3, 
        0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 
        0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4, 
        0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 
        0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 
        0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 
        0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26, 
        0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 
        0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 
        0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 
        0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 
        0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 
        0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5, 
        0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 
        0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 
        0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C, 
        0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 
        0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B, 
        0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C, 
        0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 
        0x43, 0x83, 0x41, 0x81, 0x80, 0x40 
        };

        static UInt16 CRC16(byte[] dataIn, int length)//CRC计算
        {
            byte uchCRCHi = 0xFF;
            byte uchCRCLo = 0xFF;
            UInt16 uIndex;
            UInt16 Count = 0;
            while (length-- > 0)
            {
                uIndex = (UInt16)(uchCRCHi ^ (UInt16)dataIn[Count++]);
                uchCRCHi = (byte)(uchCRCLo ^ auchCRCHi[uIndex]);
                uchCRCLo = auchCRCLo[uIndex];
            }
            return (UInt16)(uchCRCLo << 8 | uchCRCHi);
        }

        private byte[] UartSendRecv(byte[] SendBuf, byte SendNum)//串口发送接收方法
        {
            RecvEnd = false;//清除接收完成标志
            try
            {
                if (UartPort.BytesToRead > 0)//串口接收缓存有数据，则读取，在发送modbus指令前需清空串口接收缓冲区
                {
                    byte[] TmpBuf = new byte[UartPort.BytesToRead];
                    UartPort.Read(TmpBuf, 0, UartPort.BytesToRead);
                }


                UInt16 CrcTemp = CRC16(SendBuf, SendNum - 2);
                SendBuf[SendNum - 1] = (byte)(CrcTemp >> 8);
                SendBuf[SendNum - 2] = (byte)(CrcTemp & 0xff);

                UartPort.Write(SendBuf, 0, SendNum);//串口发送数据

                int TimeOutCnt = 0;//超时等待时间
                while (RecvEnd == false && TimeOutCnt < (TimeOutVal / 20))//等待串口接收完成，或超时
                {
                    Thread.Sleep(20);
                    TimeOutCnt++;
                }

                
                if (UartPort.BytesToRead == 0)//接收缓冲区为0，则接收失败
                {
                    return null;
                }
                byte[] TempBuf = new byte[UartPort.BytesToRead];
                UartPort.Read(TempBuf, 0, UartPort.BytesToRead);
                if (TempBuf.Length > 2)
                {
                    CrcTemp = CRC16(TempBuf, TempBuf.Length - 2);
                    if (TempBuf[TempBuf.Length - 1] == (byte)(CrcTemp >> 8) && TempBuf[TempBuf.Length - 2] == (byte)(CrcTemp & 0xff))
                    {
                        return TempBuf;//crc校验成功，返回接收的数组
                    }
                }
            }
            catch
            {

            }
            return null;
        }





        /// <summary>
        /// 写单个16位无符号寄存器，如果需要写有符号数，请使用强制转换
        /// </summary>
        /// <param name="Addr"></设备地址>
        /// <param name="RegAddr"></寄存器地址>
        /// <param name="Reg"></param>
        /// <returns></returns>
        public bool WriteReg(int Addr, int RegAddr, UInt16 Reg)
        {
            UartPort.ReceivedBytesThreshold = 8;//设置串口需要接收的字节数
            byte[] UartSendBuf = new byte[] { 0x01, 0x10, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 };
            UartSendBuf[0] = (byte)Addr;
            UartSendBuf[2] = (byte)(RegAddr >> 8);
            UartSendBuf[3] = (byte)RegAddr;
            UartSendBuf[7] = (byte)(Reg >> 8);
            UartSendBuf[8] = (byte)(Reg & 0xff);
            if (UartSendRecv(UartSendBuf, 11) != null)
            {
                return true;//成功则返回真
            }
            return false;
        }

        /// <summary>
        /// 写多个16位无符号寄存器，如果需要写有符号数，请使用强制转换
        /// </summary>
        /// <param name="Addr"></设备地址>
        /// <param name="RegAddr"></寄存器地址>
        /// <param name="RegBuf"></param>
        /// <returns></returns>
        public bool WriteReg(int Addr, int RegAddr, UInt16[] RegBuf)
        {
            if (RegBuf.Length > 16)
            {
                return false;
            }
            UartPort.ReceivedBytesThreshold = 8;//设置串口需要接收的字节数
            byte[] UartSendBuf = new byte[RegBuf.Length * 2 + 9];
            UartSendBuf[0] = (byte)Addr;//
            UartSendBuf[1] = 0x10;
            UartSendBuf[2] = (byte)(RegAddr >> 8);
            UartSendBuf[3] = (byte)RegAddr;
            UartSendBuf[4] = (byte)(RegBuf.Length >> 8);
            UartSendBuf[5] = (byte)(RegBuf.Length & 0x00ff);
            UartSendBuf[6] = (byte)(RegBuf.Length * 2);
            for (int i = 0; i < RegBuf.Length; i++)
            {
                UartSendBuf[7 + i * 2] = (byte)(RegBuf[i] >> 8);
                UartSendBuf[8 + i * 2] = (byte)(RegBuf[i] & 0xff);

            }

            if (UartSendRecv(UartSendBuf, (byte)UartSendBuf.Length) != null)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 读16位无符号寄存器，如果需要有符号数，请使用强制类型转换
        /// </summary>
        /// <param name="Addr"></设备地址>
        /// <param name="RegAddr"></寄存器地址>
        /// <param name="RegNum"></寄存器数量>
        /// <returns></returns>
        public UInt16[] ReadReg(int Addr, int RegAddr, int RegNum)
        {
            UartPort.ReceivedBytesThreshold = 5 + RegNum * 2;//设置串口需要接收的字节数
            byte[] UartSendBuf = new byte[] { 0x01, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 };
            UartSendBuf[0] = (byte)Addr;
            UartSendBuf[2] = (byte)(RegAddr >> 8);
            UartSendBuf[3] = (byte)RegAddr;
            UartSendBuf[5] = (byte)RegNum;
            byte[] UartRecvBuf = UartSendRecv(UartSendBuf, 8);
            if (UartRecvBuf == null)
            {
                return null;//失败则返回空
            }
            UInt16[] RegBuf = new UInt16[RegNum];
            for (int i = 0; i < RegNum; i++)
            {
                RegBuf[i] = UartRecvBuf[3 + i * 2];
                RegBuf[i] <<= 8;
                RegBuf[i] |= UartRecvBuf[4 + i * 2];
            }

            return RegBuf;
        }

        /// <summary>
        /// 读多个线圈
        /// </summary>
        /// <param name="Addr"></设备地址>
        /// <param name="RegAddr"></线圈地址>
        /// <param name="RegNum"></线圈数量>
        /// <returns></returns>
        public bool[] ReadCoil(int Addr, int CoilAddr, int CoilNum)
        {
            UartPort.ReceivedBytesThreshold = 5 + (CoilNum + 7) / 8;//设置串口需要接收的字节数
            byte[] UartSendBuf = new byte[] { 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 };
            UartSendBuf[0] = (byte)Addr;
            UartSendBuf[2] = (byte)(CoilAddr >> 8);
            UartSendBuf[3] = (byte)CoilAddr;
            UartSendBuf[5] = (byte)CoilNum;
            byte[] UartRecvBuf = UartSendRecv(UartSendBuf, 8);
            if (UartRecvBuf == null)
            {
                return null;//失败则返回空
            }
            bool[] CoilBuf = new bool[CoilNum];
            for (int i = 0; i < CoilNum; i++)
            {
                CoilBuf[i] = ( (UartRecvBuf[3 + i / 8] & (0x01 << i % 8)) > 0 );
            }

            return CoilBuf;
        }

        /// <summary>
        /// 写单个线圈
        /// </summary>
        /// <param name="Addr"></设备地址>
        /// <param name="CoilAddr"></线圈地址>
        /// <param name="CoilVal"></线圈值>
        /// <returns></returns>
        public bool WriteCoil(int Addr, int CoilAddr, bool CoilVal)
        {
            UartPort.ReceivedBytesThreshold = 5;//设置串口需要接收的字节数
            byte[] UartSendBuf = new byte[] { 0x01, 0x0f, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00 };
            UartSendBuf[0] = (byte)Addr;
            UartSendBuf[2] = (byte)(CoilAddr >> 8);
            UartSendBuf[3] = (byte)CoilAddr;
            if (CoilVal == true)
            {
                UartSendBuf[7] = 1;
            }
            

            byte[] UartRecvBuf = UartSendRecv(UartSendBuf, 10);
            if (UartRecvBuf == null)
            {
                return false;
            }

            return true;
        }


        /// <summary>
        /// 写多个线圈
        /// </summary>
        /// <param name="Addr"></设备地址>
        /// <param name="CoilAddr"></线圈地址>
        /// <param name="CoilBuf"></线圈组>
        /// <returns></returns>
        public bool WriteCoil(int Addr, int CoilAddr, bool[] CoilBuf)
        {
            if (CoilBuf.Length > 32)
            {
                return false;
            }
            UartPort.ReceivedBytesThreshold = 5;//设置串口需要接收的字节数
            byte[] UartSendBuf = new byte[(CoilBuf.Length + 7) / 8 + 9];
            UartSendBuf[0] = (byte)Addr;
            UartSendBuf[1] = 0x0f;//功能码
            UartSendBuf[2] = (byte)(CoilAddr >> 8);
            UartSendBuf[3] = (byte)CoilAddr;
            UartSendBuf[4] = (byte)(CoilBuf.Length >> 8);
            UartSendBuf[5] = (byte)(CoilBuf.Length & 0x00ff);
            UartSendBuf[6] = (byte)((CoilBuf.Length + 7) / 8);
            for (int i = 0; i < CoilBuf.Length; i++)
            {
                UartSendBuf[7 + i / 8] &= (byte)(~(0x01 << (i % 8)));
                if (CoilBuf[i] == true)
                {
                    UartSendBuf[7 + i / 8] |= (byte)(0x01 << (i % 8));
                }
            }

            if (UartSendRecv(UartSendBuf, (byte)UartSendBuf.Length) != null)
            {
                return true;
            }
            return false;
        }

    }
}