精华内容
下载资源
问答
  • fcs校验
    2021-05-23 09:33:46

    static uint8 calcFCS(uint8 *pBuf, uint8 len)

    {

    uint8 rtrn = 0;

    while (len--)

    {

    rtrn ^= *pBuf++;

    }

    return rtrn;

    }

    FCS

    FCS訊框檢查序列(Frame Check Sequence, FCS)為 32 位元 CRC 檢查碼。

    所謂的CRC錯誤就是指訊框(Frame->網路中傳輸的資料,在連結層中的最小單位)的FCS值與計算得到的FCS值不匹配,可能的原因為傳輸中的Frame被損壞所造成。

    FCS是802.3訊框和Ethernet訊框的最後一個字段.

    FCS is a field at the end of the frame that‘s used to store the CRC.2、FCS是由DCS与PLC发展而来,FCS不仅具备DCS与PLC的特点,而且跨出了革命性的一步。FCS是由DCS與PLC發展而來,FCS不僅具備DCS與PLC的特點,而且跨出了革命性的一步。

    FCS的关键要点有三点: FCS的關鍵要點有三點:

    1、 FCS系统的核心是总线协议,即总线标准 1、FCS系統的核心是總線協議,即總線標準

    2、FCS系统的基础是数字智能现场装置 2、FCS系統的基礎是數字智能現場裝置

    3、FCS系统的本质是信息处理现场化 3、FCS系統的本質是信息處理現場化

    这个只是通用的叫法,具体的FCS还要分各类校验方法,如CRC校验、XOR校验、LRC校验等,各个校验方法也要细分,如CRC分16位的、32位的等待。具體的FCS還要分各類校驗方法,如CRC校驗、XOR校驗、LRC校驗等,各個校驗方法也要細分,如CRC分16位的、32位的等。 我们说的FCS校验只是说明了这个位的数据是对这个帧的序列做校验,若想知道采用什么校验,需要给进一步的说明才可以。我們說的FCS校驗只是說明了這個位的數據是對這個訊框的序列做校驗,若想知道採用什麼校驗,需要給進一步的說明才可以。

    最普遍的FCS算法是cyclic redundancy check (CRC), 用于與32 bits, X.25 16或32 bits, HDLC 16 or 32 bits, Frame Relay 16 bits

    更多相关内容
  • 一个简单的网络帧FCS计算工具,可移植到自己的项目
  • FCS校验和软件工具

    2018-02-23 17:22:12
    该软件是计算CRC校验和的软件,主要用vs2005进行开发,主要的应用技术是上位机界面读取输入的数字,通过计算后进行显示。
  • 字符串FCS校验码计算方法
  • FCS校验工具

    2014-08-13 14:45:58
    FCS校验码计算工具。通信用的,小巧灵珑
  • FCS校验计算器

    热门讨论 2012-08-09 14:30:23
    FCS校验计算器
  • FCS校验计算器.rar

    热门讨论 2012-12-17 20:24:55
    用于计算OMRON PLC的HOST LINK的通信协议校验
  • 基于Verilog的FCS校验

    2022-06-23 14:13:12
    资源来自github,用于Verilog进行网络通信时的FCS校验码的生成
  • C#FCS校验算法

    2015-11-03 12:39:36
    两种方式进行异或运算 上面有详细的时间记录
  • FCS校验

    千次阅读 2018-12-22 14:50:33
    using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace FCS { public class FCSstr { public FCSstr() ... public string tobcc(string s) //帧校验函数FC...

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

    namespace FCS
    {
    public class FCSstr
    {

        public FCSstr()
        {
        }
        public string tobcc(string s)  //帧校验函数FCS
        {
            //获取s对应的字节数组
            byte[] b = Encoding.ASCII.GetBytes(s);
            // xorResult 存放校验结果。注意:初值去首元素值!
            byte xorResult = b[0];
            // 求xor校验和。注意:XOR运算从第二元素开始
            for (int i = 1; i < b.Length; i++)
            {
                //**进行异或运算,^=就是异或运算符,具体可查阅异或运算
                //**异或运算:两个二进制数的每一位进行比较,如果相同则为0,不同则为1,如下面2个10进制数37、     48的二进制值异或结果为21
                //**  37(10)       100101(2)
                //**  48(10)       110000(2)
                //**  21(10)       010101(2)
                //**这里的意思是:如a^=b,就是a与b先进行异或比较,得出的结果赋值给a;
                xorResult ^= b[i];
            }
            //**Convert.ToString(xorResult, 16):将当前值转换为16进制;ToUpper():结果大写;
            //**这里的意思是:将xorResult转换成16进制并大写;
    
            //**(//**返回的结果为一个两个ASCII码的异或值)
            return Convert.ToString(xorResult, 16).ToUpper();
        }
        public string tobccs(string ss)  //帧校验函数FCS后4位删除,两位校验,两个结束
        {
            //获取s对应的字节数组
            byte[] bs = Encoding.ASCII.GetBytes(ss);
            // xorResult 存放校验结果。注意:初值去首元素值!
            byte xorResults = bs[0];
            // 求xor校验和。注意:XOR运算从第二元素开始
            for (int ia = 1; ia< bs.Length-4; ia++)
            {
                //**进行异或运算,^=就是异或运算符,具体可查阅异或运算
                //**异或运算:两个二进制数的每一位进行比较,如果相同则为0,不同则为1,如下面2个10进制数37、     48的二进制值异或结果为21
                //**  37(10)       100101(2)
                //**  48(10)       110000(2)
                //**  21(10)       010101(2)
                //**这里的意思是:如a^=b,就是a与b先进行异或比较,得出的结果赋值给a;
                xorResults ^= bs[ia];
            }
            //**Convert.ToString(xorResult, 16):将当前值转换为16进制;ToUpper():结果大写;
            //**这里的意思是:将xorResult转换成16进制并大写;
    
            //**(//**返回的结果为一个两个ASCII码的异或值)
            return Convert.ToString(xorResults, 16).ToUpper();
        }
    }
    

    }

    展开全文
  • 该工具可以很快计算出PPP协议校验域的值,方便调试及判断协议数据帧是否正确。
  • 最后四个字节 8b 6b f5 13是其FCS字段,用于与后面生成的CRC32对照 alt_u8 tx_data[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x1f, //8 0x29, 0x00, 0xb5, 0xfa, 0x08, 0x06, 0x00, 0x01, //15 0x...
    #include <stdio.h>  
    #include <stdlib.h>  
    #include <io.h>  

    #define alt_8    char  
    #define alt_u8   unsigned char  
    #define alt_32   int  
    #define alt_u32  unsigned int  
    #define alt_64   long long  
    #define alt_u64  unsigned long long  

    //位翻转函数  
    alt_u64 Reflect(alt_u64 ref, alt_u8 ch)
    {
    int i;
    alt_u64 value = 0;
    for (i = 1; i < (ch + 1); i++)
    {
    if (ref & 1)
    value |= 1 << (ch - i);
    ref >>= 1;
    }
    return value;
    }

    //标准的CRC32多项式  
    #define poly  0x04C11DB7  
    //翻转的CRC32多项式  
    #define upoly 0xEDB88320  

    alt_u32 crc32_bit(alt_u8 *ptr, alt_u32 len, alt_u32 gx)
    {
    alt_u8 i;
    alt_u32 crc = 0xffffffff;
    while (len--)
    {
    for (i = 1; i != 0; i <<= 1)
    {
    if ((crc & 0x80000000) != 0)
    {
    crc <<= 1;
    crc ^= gx;
    }
    else
    crc <<= 1;
    if ((*ptr & i) != 0)
    crc ^= gx;
    }
    ptr++;
    }
    return (Reflect(crc, 32) ^ 0xffffffff);
    }

    alt_u32 Table1[256];
    alt_u32 Table2[256];

    // 生成CRC32 普通表 , 第二项是04C11DB7  
    void gen_direct_table(alt_u32 *table)
    {
    alt_u32 gx = 0x04c11db7;
    unsigned long i32, j32;
    unsigned long nData32;
    unsigned long nAccum32;
    for (i32 = 0; i32 < 256; i32++)
    {
    nData32 = (unsigned long)(i32 << 24);
    nAccum32 = 0;
    for (j32 = 0; j32 < 8; j32++)
    {
    if ((nData32 ^ nAccum32) & 0x80000000)
    nAccum32 = (nAccum32 << 1) ^ gx;
    else
    nAccum32 <<= 1;
    nData32 <<= 1;
    }
    table[i32] = nAccum32;
    }
    }

    // 生成CRC32 翻转表 第二项是77073096  
    void gen_normal_table(alt_u32 *table)
    {
    alt_u32 gx = 0x04c11db7;
    alt_u32 temp, crc;
    for (int i = 0; i <= 0xFF; i++)
    {
    temp = Reflect(i, 8);
    table[i] = temp << 24;
    for (int j = 0; j < 8; j++)
    {
    unsigned long int t1, t2;
    unsigned long int flag = table[i] & 0x80000000;
    t1 = (table[i] << 1);
    if (flag == 0)
    t2 = 0;
    else
    t2 = gx;
    table[i] = t1^t2;
    }
    crc = table[i];
    table[i] = Reflect(table[i], 32);
    }
    }

    alt_u32 DIRECT_TABLE_CRC(alt_u8 *ptr, int len, alt_u32 * table)
    {
    alt_u32 crc = 0xffffffff;
    alt_u8 *p = ptr;
    int i;
    for (i = 0; i < len; i++)
    crc = (crc << 8) ^ table[(crc >> 24) ^ (alt_u8)Reflect((*(p + i)), 8)];
    return ~(alt_u32)Reflect(crc, 32);
    }

    alt_u32 Reverse_Table_CRC(alt_u8 *data, alt_32 len, alt_u32 * table)
    {
    alt_u32 crc = 0xffffffff;
    alt_u8 *p = data;
    int i;
    for (i = 0; i <len; i++)
    crc = table[(crc ^ (*(p + i))) & 0xff] ^ (crc >> 8);
    return  ~crc;
    }

    //这是一个完整的以太网帧。最后四个字节 8b 6b f5 13是其FCS字段,用于与后面生成的CRC32对照  
    alt_u8  tx_data[] = {
    0xff,   0xff,   0xff,   0xff,   0xff,   0xff,   0x00,   0x1f,   //8  
    0x29,   0x00,   0xb5,   0xfa,   0x08,   0x06,   0x00,   0x01,   //15  
    0x08,   0x00,   0x06,   0x04,   0x00,   0x01,   0x00,   0x1f,   //24  
    0x29,   0x00,   0xb5,   0xfa,   0xac,   0x15,   0x0e,   0xd9,   //32  
    0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0xac,   0x15,   //40  
    0x0e,   0x8e,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   //48  
    0x00,   0x00 ,  0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   //56  
    0x00,   0x00,   0x00,   0x00,   0x8b,   0x6b,   0xf5,   0x13    //64  
    };

    int main()
    {
    alt_u8 *data = tx_data;
    alt_u32 dataLen = sizeof(tx_data) - 4;


    int sum = 256;

    int i = 0;


    //生成普通表,用于直接计算的表  
    gen_direct_table(Table1);
    printf("Table1 :\n");
    for (i = 0; i < sum; i++)
    {
    if (i<16)
    printf("%08x ", Table1[i]);
    }
    printf("\n\n");

    //生成翻转表,是官方推荐的,故称其为normal_table  
    gen_normal_table(Table2);
    printf("Table2 :\n");
    for (i = 0; i < sum; i++)
    {
    if (i<16)
    printf("%08x ", Table2[i]);
    }
    printf("\n\n");

    printf("dataLen = %d\n", dataLen);//打印数据长度,应该是60字节。  

     //计算并打印出CRC32校验码,应该是0x13f56b8b  

                                                                              //按照bit进行校验,最慢  

    printf("Slow CRC by bit          : %08x\n", crc32_bit(data, dataLen, 0x04c11db7));
    //使用普通表,非官方,很慢  
    printf("Direct Table  ref + xor  : %08x\n", DIRECT_TABLE_CRC(data, dataLen, Table1));
    //使用翻转表,官方推荐的,很快  
    printf("Reverse Table  ref + xor : %08x\n", Reverse_Table_CRC(data, dataLen, Table2));

    system("pause");
    return 0;
    }
    展开全文
  • 数据包校验记录——IP校验&FCS校验

    千次阅读 2015-11-25 15:06:36
    数据包校验和 IP校验:IP校验范围为IP字段共ip_hdr.ip_hl*4个字节; code: /* 参数: buffer:IP段开始地址; length:IP段长度; 返回值: 成功:返回checksum:两个字节 */ uint16_t checksum(uint16_t *...

    数据包校验和

    IP校验:IP校验范围为IP字段共ip_hdr.ip_hl*4个字节;

    code:

    /*

    参数:

    buffer:IP段开始地址;

    length:IP段长度;

    返回值:

    成功:返回checksum:两个字节

    */

    uint16_t checksum(uint16_t *buffer, int length)
    {
      uint32_t cksum = 0;
      while(length> 1)
      {
        cksum += *buffer ++;
        length-= sizeof(uint16_t);
      }
      if (length)
      {
        cksum += *(uint8_t*)buffer;
      }
      cksum = (cksum >> 16) + (cksum & 0xffff);
      cksum += (cksum >> 16);
      return (uint16_t)(~cksum);
    }


    数据包FCS校验:

    #include <stdio.h>  
    #include <stdlib.h>  
    #include <arpa/inet.h>
      
      
    #define alt_8    char  
    #define alt_u8   unsigned char  
    #define alt_32   int  
    #define alt_u32  unsigned int  
    #define alt_64   long long  
    #define alt_u64  unsigned long long  
      
      
    alt_u64 Reflect(alt_u64 ref,alt_u8 ch)  
    {     
        int i;  
        alt_u64 value = 0;  
        for( i = 1; i < ( ch + 1 ); i++ )  
        {  
            if( ref & 1 )  
                value |= 1 << ( ch - i );  
            ref >>= 1;  
        }  
        return value;  
    }  
      
      
    #define poly  0x04C11DB7  
    #define upoly 0xEDB88320  
      
      
      
    alt_u32 crc32_bit(alt_u8 *ptr, alt_u32 len, alt_u32 gx)  
    {  
        alt_u8 i;  
        alt_u32 crc = 0xffffffff;  
        while( len-- )  
        {  
            for( i = 1; i != 0; i <<= 1 )  
            {  
                if( ( crc & 0x80000000 ) != 0 )  
                {  
                    crc <<= 1;  
                    crc ^= gx;  
                }  
                else   
                    crc <<= 1;  
                if( ( *ptr & i ) != 0 )   
                    crc ^= gx;  
            }  
            ptr++;  
        }  
        return ( Reflect(crc,32) ^ 0xffffffff );  
    }  
      
    alt_u32 Table1[256];  
    alt_u32 Table2[256];  
      
    void gen_direct_table(alt_u32 *table)  
    {  
        alt_u32 gx = 0x04c11db7;  
        unsigned long i32, j32;  
        unsigned long nData32;  
        unsigned long nAccum32;  
        for ( i32 = 0; i32 < 256; i32++ )  
        {  
            nData32 = ( unsigned long )( i32 << 24 );  
            nAccum32 = 0;  
            for ( j32 = 0; j32 < 8; j32++ )  
            {  
                if ( ( nData32 ^ nAccum32 ) & 0x80000000 )  
                    nAccum32 = ( nAccum32 << 1 ) ^ gx;  
                else  
                    nAccum32 <<= 1;  
                nData32 <<= 1;  
            }  
            table[i32] = nAccum32;  
        }  
    }  
      
      
    void gen_normal_table(alt_u32 *table)  
    {  
        alt_u32 gx = 0x04c11db7;  
        alt_u32 temp,crc;  
        for(int i = 0; i <= 0xFF; i++)   
        {  
            temp=Reflect(i, 8);  
            table[i]= temp<< 24;  
            for (int j = 0; j < 8; j++)  
            {  
                unsigned long int t1,t2;  
                unsigned long int flag=table[i]&0x80000000;  
                t1=(table[i] << 1);  
                if(flag==0)  
                t2=0;  
                else  
                t2=gx;  
                table[i] =t1^t2 ;  
            }  
            crc=table[i];  
            table[i] = Reflect(table[i], 32);  
        }  
    }  
      
      
      
    alt_u32 DIRECT_TABLE_CRC(alt_u8 *ptr,int len, alt_u32 * table)   
    {  
        alt_u32 crc = 0xffffffff;   
        alt_u8 *p= ptr;  
        int i;  
        for ( i = 0; i < len; i++ )  
            crc = ( crc << 8 ) ^ table[( crc >> 24 ) ^ (alt_u8)Reflect((*(p+i)), 8)];  
        return ~(alt_u32)Reflect(crc, 32) ;  
    }  
      
      
      
      
    alt_u32 Reverse_Table_CRC(alt_u8 *data, alt_32 len, alt_u32 * table)  
    {  
        alt_u32 crc = 0xffffffff;    
        alt_u8 *p = data;  
        int i;  
        for(i=0; i <len; i++)  
            crc =  table[( crc ^( *(p+i)) ) & 0xff] ^ (crc >> 8);  
        return  ~crc ;   
    }  
      
      
      
    alt_u8  tx_data[] = {  
            0xff,   0xff,   0xff,   0xff,   0xff,   0xff,   0x00,   0x1f,   //8  
            0x29,   0x00,   0xb5,   0xfa,   0x08,   0x06,   0x00,   0x01,   //15  
            0x08,   0x00,   0x06,   0x04,   0x00,   0x01,   0x00,   0x1f,   //24  
            0x29,   0x00,   0xb5,   0xfa,   0xac,   0x15,   0x0e,   0xd9,   //32  
            0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0xac,   0x15,   //40  
            0x0e,   0x8e,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   //48  
            0x00,   0x00 ,  0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   //56  
            0x00,   0x00,   0x00,   0x00,   0x8b,   0x6b,   0xf5,   0x13    //64  
    };  
      
    alt_u8 packet[] = {
    0xFF, 0xFF, 0xFF ,0xFF, 0xFF, 0xFF, 0x68, 0x17, 0x29, 0x1F, 0x01, 0x71, 0x08, 0x00, 0x45, 0x00, 
    0x00, 0x4E, 0x3C, 0x82, 0x00, 0x00, 0x40, 0x11, 0xB9, 0xC8, 0xC0, 0xA8, 0x01, 0x05, 0xC0, 0xA8, 
    0x01, 0xFF, 0x00, 0x89, 0x00, 0x89, 0x00, 0x3A, 0x1E, 0x0C, 0xDA, 0x8A, 0x01, 0x10, 0x00, 0x01, 
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x46, 0x48, 0x45, 0x50, 0x46, 0x43, 0x45, 0x4C, 0x45, 
    0x48, 0x46, 0x43, 0x45, 0x50, 0x46, 0x46, 0x46, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 0x41, 0x43, 
    0x41, 0x43, 0x41, 0x43, 0x41, 0x42, 0x4D, 0x00, 0x00, 0x20, 0x00, 0x01
    };
      
      
      
    int main()  
    {  
    //    alt_u8 *data = tx_data;  
    //    alt_u8 dataLen = sizeof(tx_data) -4;  
        
        alt_u8 *data = packet;  
        alt_u8 dataLen = sizeof(packet) ;  
        int sum = 256;  
        int i = 0;  
      
        gen_direct_table(Table1);  
        printf("Table1 :\n");  
        for( i = 0; i < sum; i++)  
        {  
            if(i<16)  
                printf("%08x ",Table1[i]);  
        }  
        printf("\n\n");  
      
      
        gen_normal_table(Table2);  
        printf("Table2 :\n");  
        for( i = 0; i < sum; i++)  
        {  
            if(i<16)  
                printf("%08x ",Table2[i]);  
        }  
        printf("\n\n");  
      
      
      
        printf("dataLen = %d\n",dataLen);
      
      
      
      
        printf("Slow CRC by bit          : %08x\n",ntohl(crc32_bit( data, dataLen, 0x04c11db7 )));  
        printf("Reverse Table  ref + xor : %08x\n",Reverse_Table_CRC(data,dataLen,Table2));   
      
      
        system("pause");      
        return 0;  
    }  

    展开全文
  • 欧姆龙plc的 hostlink 的fcs校验工具 http://blog.csdn.net/aliealie/article/details/53930703
  • 用C#编写的小工具软件,校验值计算工具,可以计算校验和、FCS校验,可以将ASCII码转成十六进制数据显示
  • CRC码计算及原理(FCS校验序列生成)

    千次阅读 多人点赞 2019-11-12 20:06:36
    我们知道在以太网帧的末尾有一个叫FCS的东西。 全称:Frame Check Sequence,中文名:帧检验序列 这个东西是用来检验我们的数据是否在传输的过程中被破坏(不一定是收到攻击,也可能是一些物理干扰),以更好的安排...
  • 欧姆龙FCS校验器 VB源代码

    热门讨论 2008-10-09 19:38:47
    欧姆龙FCS校验器 VB源代码,校验FCS值,可以算出FCS值,直接输入COM口通讯字串代码运算.
  • 发现以太网这个东西真的涉及到太多了,我没有系统地学过网络通信,所以欠缺的东西还很多,越学发现越...FCS(帧检验序列)是在以太网数据帧的尾部的4个字节的序列,而CRC是循环冗余校验码,也就是说FCS是真正位于以太
  • BCC(FCS)校验 labview PLC

    2013-12-19 17:39:30
    BCC(FCS)校验 labview PLC通信
  • CRC,全称Cyclic Redundancy Check,中文名称为循环冗余校验,是一种根据网络数据包或计算机文件等数据产生简短固定位数校验码的一种信道编码技术,主要用来检测或校验数据传输或者保存后可能出现的错误。...
  • 方法一:按位计算CRC32校验码。 方法二:使用非翻转的查找表进行快速计算,按字节计算CRC32校验码。但计算过程中有位翻转操作,计算速度慢。 方法三:使用翻转的查找表进行快速计算,按字节计算CRC校验码。速度极快...
  • 你没有指定哪个操作系统,但我至少可以为Linux发言:... (通常在传递之前被截断)2)不丢弃具有不良FCS字段的分组,而是按原样传递它们有两个ethtool选项来实现每个这些:ethtool -K eth0 rx-fcs on #1 above: give u...
  • C#学习之帧校验序列码FCS

    千次阅读 2017-04-24 09:38:18
    在上位机与PLC通信中,为了更好的校验发送与接收的数据的准确性,一般都会加一位校验位,校验码的算法有多种,帧校验序列码FCS就是其中的一种。  帧校验序列码FCS ( Frame Check Sequences)是为提高通信的可靠性...
  • CRC校验码的基本思想是利用线性编码理论,在发送端根据要传送的k位二进制码序列,以一定的规则产生一个校验用的监督码(既CRC码)r位,并附在信息后边,构成一个新的二进制码序列数共(k+ r)位,最后发送出去。...
  • 为什么wireshark抓不到帧尾的FCS 4字节和以太网V2的前序8字节 这是wireshark的ARP包(通过type:0x0806可以知道) 这里可以看到没有8字节的前序和4字节的FCS,而且大部分的数据链路层都是Ethernet II. 因为...
  • <p>2层报头|3层报头|4层报头|data |FCS <p>FCS校验的是从哪里到哪里</p>
  • python crc-16 crc-16校验码 crc-16校验算法 ppp(MAC)帧检验序列FCS 想弄明白这里要看多几遍,配合下面的例子能更快理解。 第一、CRC-16校验码计算方法: 常用查表法和计算法。计算方法一般都是: (1)、预置1个...
  • 使用java实现FCS生成与CRC冗余循环校验 #插入链接与图片 最近在看计算机网络技术,关于MAC帧如何通过CRC检验,尝试用代码写出,记录一下。 代码如下 package test; public class Test { @org.junit.Test public...
  • 方法一:按位计算CRC32校验码。 方法二:使用非翻转的查找表进行快速计算,按字节计算CRC32校验码。但计算过程中有位翻转操作,计算速度慢。 方法三:使用翻转的查找表进行快速计算,按字节计算CRC校验码。速度极...
  • 在测24 GE口POE+交换机挂上PD负载打流时,在发包仪端有多个端口收到FCS错误,FCS错误率最高达千分之五。PD负载每个端口16瓦。 关掉POE供电关掉只打流,不会有FCS错误。 将网线全部由超5类网线换成6类网线,不会有FCS...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,655
精华内容 2,662
关键字:

fcs校验