using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;

namespace FLY.ModbusModule
{
    //class ModbusServer_Conn_ASCII:ModbusServer_Conn
    //{
    //    public Serial mSerial;
    //    // For MODE_ASCII
    //    int m_Scanpos;
    //    int m_STARTpos;
    //    int m_LFpos;
    //    int m_CRpos;

    //    const char m_STARTChar = ':';
    //    const char m_LFChar = (char)0x0A;
    //    const char m_CRChar = (char)0x0D;
    //    char[] cvrtlist = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
            
    //    /// <summary>
    //    /// 从设备接收所有byte
    //    /// </summary>
    //    /// <returns></returns>
    //    protected override int Receive_Polling()
    //    {
    //        int len = mSerial.Read(in_buf, in_len, MAX_BUFFER - in_len);
    //        if (len > 0)
    //        {
    //            in_len += len;
    //            return len;
    //        }
    //        else return 0;
    //    }
    //    /// <summary>
    //    /// 从in_buf, 找出包, 只找一个包，多出去的都不要
    //    /// </summary>
    //    /// <returns></returns>
    //    protected override bool Receive_Packet()
    //    {
    //        int ret = 0;
    //        if (in_len <= 0) return false;

    //        int p = m_Scanpos;
    //        while ((p < in_len) && (ret == 0))
    //        {
    //            byte ch = in_buf[p];
    //            if (ch == m_STARTChar)
    //            {
    //                m_STARTpos = p;
    //                m_LFpos = m_CRpos = -100;
    //            }
    //            else if (ch == m_CRChar)//0x0D
    //            {
    //                if (m_STARTpos >= 0)
    //                {
    //                    m_CRpos = p;
    //                    m_LFpos = -100;
    //                }
    //                else
    //                {
    //                    //数据异常
    //                    m_STARTpos = -100;
    //                    m_CRpos = -100;
    //                    m_LFpos = -100;
    //                }
    //            }
    //            else if (ch == m_LFChar)//0x0A
    //            {
    //                if (m_STARTpos >= 0)
    //                {
    //                    m_LFpos = p;
    //                    if (m_CRpos == (p - 1))
    //                    {
    //                        ret = 1;
    //                    }
    //                    else
    //                    {
    //                        //数据异常
    //                        m_STARTpos = -100;
    //                        m_CRpos = -100;
    //                        m_LFpos = -100;
    //                    }
    //                }
    //                else
    //                {
    //                    //数据异常
    //                    m_STARTpos = -100;
    //                    m_CRpos = -100;
    //                    m_LFpos = -100;
    //                }
    //            }
    //            p++;
    //        }
    //        if (ret == 1)
    //        {
    //            //if (m_debug)
    //            //{
    //            //    string s = "rec --";
    //            //    for (int i = m_STARTpos; i < p; i++)
    //            //    {
    //            //        if (in_buf[i] == 0xD)
    //            //            s += "\\r";
    //            //        else if (in_buf[i] == 0xA)
    //            //            s += "\\n";
    //            //        else
    //            //            s += (char)in_buf[i];
    //            //    }
    //            //    FDEBUG.Debug.LogMessage(this, 10, s);
    //            //}
    //            in_len = p;
    //        }
    //        if (m_STARTpos >= 0)//找到开始，没找到结尾
    //        {
    //            int to;
    //            int i, j;
    //            to = in_len;
    //            for (i = m_STARTpos, j = 0; i < to; i++, j++)
    //                in_buf[j] = in_buf[i];
    //            in_len = j;
    //        }
    //        else
    //        {
    //            //清空所有
    //            Clear_Packet();
    //        }
    //        m_Scanpos = in_len;
    //        if (ret == 1)
    //            return true;
    //        return false;

    //    }
    //    /// <summary>
    //    /// CheckADU return 	0 ---OK,
    //    ///		   	-1---CRC Err
    //    ///			-2---Frame Err
    //    /// </summary>
    //    /// <returns></returns>
    //    protected override CHECKADU_RESULT CheckADU()
    //    {
    //        byte lrc;
    //        if (!m_checksum)
    //            return CHECKADU_RESULT.OK;


    //        if (in_len < 6)
    //            return CHECKADU_RESULT.Frame_Err;

    //        lrc = Misc.CRC.LRCDelta(in_buf, 1, in_len - 5);
    //        if (in_buf[in_len - 4] != cvrtlist[lrc >> 4])
    //            return CHECKADU_RESULT.CRC_Err;
    //        if (in_buf[in_len - 3] != cvrtlist[lrc & 0x0f])
    //            return CHECKADU_RESULT.CRC_Err;
    //        return CHECKADU_RESULT.OK;
    //    }

    //    /// <summary>
    //    /// in_buf -> ADU
    //    /// </summary>
    //    /// <param name="ptran"></param>
    //    /// <returns></returns>
    //    protected override bool TransferADU(Transaction_s ptran)
    //    {
    //        int i, j, n;
    //        if (m_checksum)
    //            n = in_len - 4;
    //        else 
    //            n = in_len - 2;
            
    //        i = 0; j = 1;
            
    //        while (j < n)
    //        {
    //            char[] cs = new char[] { (char)in_buf[j], (char)in_buf[j + 1] };
    //            ptran.ADU[i] = byte.Parse(new string(cs), System.Globalization.NumberStyles.HexNumber);
    //            j += 2; i++;
    //        }
    //        ptran.ADU_len = i;

    //        ptran.header[0] = ptran.ADU[0];
    //        for (int k = 0; k < i - 1; k++) 
    //        {
    //            ptran.ADU[k] = ptran.ADU[k + 1];
    //        }
    //        ptran.ADU_len = i - 1;
    //        return true; 
    //    }

    //    /// <summary>
    //    /// 清除接收区
    //    /// </summary>
    //    protected override void Clear_Packet()
    //    {
    //        in_len = 0;
    //        m_STARTpos = -1;
    //        m_Scanpos = 0;
    //    }

    //    /// <summary>
    //    /// 检测地址
    //    /// </summary>
    //    /// <param name="tran"></param>
    //    /// <returns></returns>
    //    protected override bool CheckAddr(Transaction_s tran)
    //    {
    //        if (tran.header[0] == m_serv_addr)
    //            return true;
    //        return false;
    //    }


    //    /// <summary>
    //    /// PDU->ADU
    //    /// </summary>
    //    /// <param name="ADU"></param>
    //    /// <param name="ADU_index"></param>
    //    /// <param name="ptran"></param>
    //    /// <param name="RPDU"></param>
    //    /// <param name="RPDU_index"></param>
    //    /// <param name="rlen"></param>
    //    /// <returns></returns>
    //    protected override int MakeADU(byte[] ADU, int ADU_index, Transaction_s ptran, byte[] RPDU, int RPDU_index, int rlen)
    //    {
    //        int p = ADU_index;
    //        int i;
    //        byte lrc;


    //        ADU[p++] = (byte)m_STARTChar;
    //        ADU[p++] = (byte)cvrtlist[ptran.header[0] >> 4];
    //        ADU[p++] = (byte)cvrtlist[ptran.header[0] & 0x0f];
            
    //        for (i = 0; i < rlen; i++)
    //        {
    //            ADU[p++] = (byte)cvrtlist[RPDU[RPDU_index + i] >> 4];
    //            ADU[p++] = (byte)cvrtlist[RPDU[RPDU_index + i] & 0x0f];
    //        }
    //        if (m_checksum)
    //        {
    //            lrc = Misc.CRC.LRCDelta(ADU, ADU_index + 1, p - 1 - ADU_index);
    //            ADU[p++] = (byte)cvrtlist[lrc >> 4];
    //            ADU[p++] = (byte)cvrtlist[lrc & 0x0f];
    //        }
    //        ADU[p++] = (byte)m_CRChar;
    //        ADU[p++] = (byte)m_LFChar;

    //        //if (m_debug)
    //        //{
    //        //    string s = "Sen --";
    //        //    for (int j = ADU_index; j < p; j++)
    //        //    {
    //        //        if (ADU[j] == 0xD)
    //        //            s += "\\r";
    //        //        else if (ADU[j] == 0xA)
    //        //            s += "\\n";
    //        //        else
    //        //            s += (char)ADU[j];
    //        //    }
    //        //    FDEBUG.Debug.LogMessage(this, 10, s);
    //        //}

    //        return p - ADU_index;
    //    }

    //    /// <summary>
    //    /// 输出
    //    /// </summary>
    //    /// <param name="ADU"></param>
    //    /// <param name="len"></param>
    //    protected override void Write(byte[] ADU, int len)
    //    {
    //        mSerial.Write(ADU, 0, len);
    //    }



    //}
    //class ModbusServer_Conn_RTU:ModbusServer_Conn
    //{
    //    static TimeSpan TIMER_C35 = new TimeSpan(10 * 1000 * 35);//35ms

    //    public Serial mSerial;

    //    /// <summary>
    //    /// 从设备接收所有byte
    //    /// </summary>
    //    /// <returns></returns>
    //    protected override int Receive_Polling()
    //    {
    //        int len = mSerial.Read(in_buf, in_len, MAX_BUFFER - in_len);
    //        if (len > 0)
    //        {
    //            in_len += len;
    //            return len;
    //        }
    //        else return 0;
    //    }
    //    /// <summary>
    //    /// 从in_buf, 找出包, 只找一个包，多出去的都不要
    //    /// </summary>
    //    /// <returns></returns>
    //    protected override bool Receive_Packet()
    //    {

    //        if (in_len <= 0) return false;
    //        if (DateTime.Now.Subtract(last_recv_time) > TIMER_C35)
    //            return true;
    //        return false;
    //    }
    //    // CheckADU return 	0 ---OK,
    //    //		   	-1---CRC Err
    //    //			-2---Frame Err
    //    protected override CHECKADU_RESULT CheckADU()
    //    {
    //        UInt16 crc;
    //        if (!m_checksum)
    //            return CHECKADU_RESULT.OK;

    //        if (in_len < 3)
    //            return CHECKADU_RESULT.Frame_Err;

    //        crc = Misc.CRC.CRC16(in_buf, 0, in_len - 2);
    //        if (crc == ((in_buf[in_len - 1] << 8) | in_buf[in_len - 2]))
    //            return CHECKADU_RESULT.OK;
    //        else
    //            return CHECKADU_RESULT.CRC_Err;
    //    }
    //    /// <summary>
    //    /// in_buf -> ADU
    //    /// </summary>
    //    /// <param name="ptran"></param>
    //    /// <returns></returns>
    //    protected override bool TransferADU(Transaction_s ptran)
    //    {
    //        if (m_checksum)
    //            ptran.ADU_len = in_len - 2-1;
    //        else
    //            ptran.ADU_len = in_len-1;

    //        Array.Copy(in_buf, 1, ptran.ADU, 0, ptran.ADU_len);
    //        ptran.header[0] = in_buf[0];

    //        return true; 
    //    }


    //    /// <summary>
    //    /// 清除接收区
    //    /// </summary>

    //    protected override void Clear_Packet()
    //    {
    //        in_len = 0;
    //    }

    //    /// <summary>
    //    /// 检测地址
    //    /// </summary>
    //    /// <param name="tran"></param>
    //    /// <returns></returns>
    //    protected override bool CheckAddr(Transaction_s tran)
    //    {
    //        if (tran.header[0] == m_serv_addr)
    //            return true;
    //        return false;
    //    }
    //    /// <summary>
    //    /// PDU->ADU
    //    /// </summary>
    //    /// <param name="ADU"></param>
    //    /// <param name="ADU_index"></param>
    //    /// <param name="ptran"></param>
    //    /// <param name="RPDU"></param>
    //    /// <param name="RPDU_index"></param>
    //    /// <param name="rlen"></param>
    //    /// <returns></returns>
    //    protected override int MakeADU(byte[] ADU, int ADU_index, Transaction_s ptran, byte[] RPDU, int RPDU_index, int rlen)
    //    {
    //        int p = ADU_index;
    //        UInt16 crc;
    //        ADU[p++] = ptran.header[0];
    //        Array.Copy(RPDU, RPDU_index, ADU, p, rlen);
    //        p += rlen;
    //        if (m_checksum)
    //        {
    //            crc = Misc.CRC.CRC16(ADU, ADU_index, p);
    //            ADU[p++] = (byte)crc;
    //            ADU[p++] = (byte)(crc >> 8);
    //        }
    //        return p - ADU_index;
    //    }
    //    protected override void Write(byte[] ADU, int len)
    //    {
    //        mSerial.Write(ADU, 0, len);
    //    }
    //}


}