使用 C# 实现 CJ-T188 水表协议和 DL-T645 电表协议的解析与编码

一、协议的定义

要对某种协议进行编解码操作，就必须知道协议的基本定义，首先我们来看一下 cj/t188 的数据帧定义(协议定义)，了解请求数据与响应数据的基本结构。

1.1 cj/t188 水表通讯协议

请求帧：

字节	值	描述
0	0x68	数据帧开始标识。
1	t	表计类型代码，详细信息请参考 表计类型表 。
2-8	a0-a6	表计地址，水表设备的具体地址，这里是 bcd 形式。
9	ctr_01	协议控制码，例如 0x1 就是读表数据。
10	0x3	数据域长度。
11-12	0x1f,0x90	数据标识 di0-di1。
13	0x00	序列号，一般为 0x00，序列号也被作为整个数据域的长度。
14	cs	表示校验和数据，即 0-13 位置的所有字节的累加和。
15	0x16	数据帧的结束标识。

例如有以下请求帧数据(读取水表数据)：

68 10 01 00 00 05 08 00 00 01 03 1f 90 00 39 16

对应的解释如下。

顺序	0	1	2-8	9	10	11-12	13	14	15
说明	帧头	类型	地址	ctr_0	长度	数据标识	序列号	校验和	帧尾
实例	68	10	01 00 00 05 08 00 00	01	03	1f 90	00	39	16

表计类型表：

值	含义
10	冷水水表
11	生活热水水表
12	直饮水水表
13	中水水表
20	热量表 (记热量)
21	热量表 (记冷量)
30	燃气表
40	电度表

响应帧(读表操作)：

字节	值	描述
0	0x68	数据帧开始标识。
1	t	表计类型代码，详细信息请参考 表计类型表 。
2-8	a0-a6	表计地址，水表设备的具体地址，这里是 bcd 形式。
9	ctr_1	协议控制码，在返回帧含义即是请求帧的控制码加上 0x80。
10	l	数据域长度。
11-12	0x1f,0x90	数据标识 di0-di1。
13	0x00	序列号，一般为 0x00。
14-17	all data	累计用量，以 bcd 形式进行存储。
18	单位	计量单位，具体含义可以参考 计量单位表 。
19-22	month data	本月用量，以 bcd 形式进行存储。
23	单位	计量单位，具体含义可以参考 计量单位表 。
24-30	时间	表示实际时间，以 bcd 形式存储，格式为 ss mm hh dd mm yy yy。
31	状态 1	状态字段。
32	状态 2	保留字节，一般置为 0xff。
33	cs	表示校验和数据，即 0-32 位置的所有字节的累加和。
34	0x16	数据帧的结束标识。

例如有以下响应帧数据：

68 10 44 33 22 11 00 33 78 81 16 1f 90 00 00 77 66 55 2c 00 77 66 55 2c 31 01 22 11 05 15 20 21 84 6d 16

对应的解释如下：

顺序	0	1	2-8	9	10	11-12	13
说明	帧头	类型	地址	控制码	长度	标识	序列号
实例	68	10	44 33 22 11 00 33 78	81	16	1f 90	00

顺序	14-17	18	19-22	23	24-30
说明	累计用量	单位	本月用量	单位	时间
实例	00 77 66 55	2c	00 77 66 55	2c	31 01 22 11 05 15 20

顺序	31	32	33	34
说明	状态 1	状态 2	校验和	帧尾
实例	00	ff	6d	16

计量单位表：

单位	值
wh	0x2
kwh	0x5
mwh	0x8
mwh * 100	0xa
j	0x1
kj	0xb
mj	0xe
gj	0x11
gj * 100	0x13
w	0x14
kw	0x17
mw	0x1a
l	0x29
\[m^3\]	0x2c
\[ l/h \]	0x32
\[m^3/h\]	0x35

2.2 dl/t645 多功能电能表通信协议

请求帧：

字节	值	描述
0	0x68	数据帧开始标识。
1-6	a0-a5	电表设备地址，以 bcd 码形式存储。
7	0x68	帧起始符。
8	c	控制码。
9	l	数据域长度。
10	data	数据域。
11	cs	校验码，从 0-10 字节的累加和。
12	0x16	数据帧结束标识。

读取电表的当前正向有功总电量，表号为 12345678。

68 78 56 34 12 00 00 68 11 04 33 33 34 33 c6 16

顺序	0	1-6	7	8	9	10-13
说明	帧头	地址	帧头	控制码	长度	数据域
实例	68	78 56 34 12 00 00	68	11	04

顺序	14	15
说明	累加和	帧尾
实例	c6	16

这里需要注意的是，33 33 34 33 是 00 01 00 00 加上 0x33 之后的值，因为传输的时候是低位在前，高位在后，所以就是 00 00 01 00 每字节加上 0x33，00 01 00 00 即代表要读取当前正向有功总电能，也有其他的标识，这里不再叙述。

响应帧(读表操作)：

68 78 56 34 12 00 00 68 91 08 33 33 34 33 a4 56 79 38 f5 16

顺序	0	1-6	7	8	9
说明	帧头	地址	帧头	控制码，这里即 0x11 + 0x80	长度
实例	68	78 56 34 12 00 00	68	91	08

顺序	10-17	18	19
说明	数据域	累加和	帧尾
实例	33 33 34 33 a4 56 79 38	f5	16

这里只说明一下数据域，在这里 33 33 34 33 可以理解成寄存器地址，而 a4 56 79 38 则是具体的电量数据，在这里就是分别减去 0x33，即 71 23 46 5，因为其精度是两位，且是 bcd 码的形式，最后的结果就是 54623.71 度。

2.3 前导字节

前导字节并非水/电表协议强制规定的协议组，所谓前导字节是在数据帧的头部增加 1-4 组 0xfe，例如以下数据帧就是增加了前导字节。

fe fe fe fe 68 10 44 33 22 11 00 33 78 01 03 1f 90 00 80 16

所以在处理的协议的时候，某些厂家可能会加入前导字节，在处理的时候一定要注意。

2.4 小结

水/电表协议的请求帧与响应帧其实结构一致，区别仅在于不同的响应，其具体的数据域值也不同，所以在处理的时候可以用一个字典/列表来存储数据域。

二、代码的实现

2.1 工具类的编码

为了方便我们对协议的解析与组装，我们需要编写一个工具类实现对字节组的某些特殊操作，例如校验和、bcd 转换、十六进制数据的校验等。

2.1.1 累加和计算功能

首先我们来实现累加和的计算，累加和就是一堆字节相加的结果，不过这个结果可能超过一个字节的大小，我们需要对 256 取模，使其结果刚好能被 1 个字节存储。

/// <summary>
/// 计算一组二进制数据的累加和。
/// </summary>
/// <param name="waitcalcbytes">等待计算的二进制数据。</param>
public static byte calculateaccumulatesum(byte[] waitcalcbytes)
{
    int ck = 0;
    foreach (var @byte in waitcalcbytes) ck = (ck + @byte);
    // 对 256 取余，获得 1 个字节的数据。
    return (byte)(ck % 0x100);
}

2.1.2 十六进制字符串转字节数组

首先我们需要校验一个字符串是否是一个规范合法的十六进制字符串。

/// <summary>
/// 判断输入的字符串是否是有效的十六进制数据。
/// </summary>
/// <param name="hexstr">等待判断的十六进制数据。</param>
/// <returns>符合规范则返回 true，不符合则返回 false。</returns>
public static bool isillegalhexadecimal(string hexstr)
{
    var validstr = hexstr.replace("-", string.empty).replace(" ", string.empty);
    if (validstr.length % 2 != 0) return false;
    if (string.isnullorempty(hexstr) || string.isnullorwhitespace(hexstr)) return false;

    return new regex(@"[a-fa-f0-9]+$").ismatch(hexstr);
}

校验之后我们才能够将这个字符串用于转换。

/// <summary>
/// 将 16 进制的字符串转换为字节数组。
/// </summary>
/// <param name="hexstr">等待转换的 16 进制字符串。</param>
/// <returns>转换成功的字节数组。</returns>
public static byte[] hexstringtobytes(string hexstr)
{
    // 处理干扰，例如空格和 '-' 符号。
    var str = hexstr.replace("-", string.empty).replace(" ", string.empty);

    return enumerable.range(0, str.length)
        .where(x => x % 2 == 0)
        .select(x => convert.tobyte(str.substring(x, 2), 16))
        .toarray();
}

2.1.3 bcd 数据的转换

关于 bcd 码的介绍，网上有诸多解释，这里不再赘述，这里只讲一下编码实现。

/// <summary>
/// bcd 码转换成 <see cref="double"/> 类型。
/// </summary>
/// <param name="sourcebytes">等待转换的 bcd 码数据。</param>
/// <param name="precisionindex">精度位置，用于指示小数点所在的索引。</param>
/// <returns>转换成功的值。</returns>
public static double bcdtodouble(byte[] sourcebytes, int precisionindex)
{
    var sb = new stringbuilder();

    var reversebytes = sourcebytes.reverse().toarray();
    for (int index = 0; index < reversebytes.length; index++)
    {
        sb.append(reversebytes[index] >> 4 & 0xf);
        sb.append(reversebytes[index] & 0xf);
        if (index == precisionindex - 1) sb.append('.');
    }

    return convert.todouble(sb.tostring());
}

/// <summary>
/// bcd 码转换成 <see cref="string"/> 类型。
/// </summary>
/// <param name="sourcebytes">等待转换的 bcd 码数据。</param>
/// <returns>转换成功的值。</returns>
public static string bcdtostring(byte[] sourcebytes)
{
    var sb = new stringbuilder();
    var reversebytes = sourcebytes.reverse().toarray();

    for (int index = 0; index < reversebytes.length; index++)
    {
        sb.append(reversebytes[index] >> 4 & 0xf);
        sb.append(reversebytes[index] & 0xf);
    }

    return sb.tostring();
}

2.2 协议的实现

协议分为发送帧与响应帧，发送帧是通过传入一系列参数构建一个 byte 数组，而响应帧则需要我们从一个 byte 数组转换为方便读写的对象。

根据以上特点，我们编写一个 iprotocol 接口，该接口拥有两个方法，即编码 (encode) 和解码 (decode) 方法。

public interface iprotocol
{
    byte[] encode();

    iprotocol decode(byte[] sourcebytes);

    list<datadefine> datadefines { get;}
}

接着我们可以使用一个类型来表示每个数据域的数据，这里我定义了一个 datadefine 类型。

public class datadefine
{
    public string name { get; set; }

    public byte[] data { get; set; }

    public int length { get; set; }
}

这里我以水表的读表操作为例，定义了一个抽象基类，在抽象基类里面定义了数据帧的基本接口，并且实现了编码/解码方法。在这里 datadefines 的作用就体现了，他主要是用于

public abstract class cjt188protocol : iprotocol
{
    protected const byte framehead = 0x68;
    
    public byte devicetype { get; protected set; }

    public byte[] address { get; protected set; }

    public byte controlcode { get; protected set; }

    public int datalength { get; protected set; }

    public byte[] dataarea { get; private set; }

    public list<datadefine> datadefines { get;}
    
    public byte accumulatesum { get; protected set; }

    protected const byte frameend = 0x16;
    
    public cjt188protocol()
    {
        datadefines = new list<datadefine>();
    }

    public datadefine this[string key]
    {
        get
        {
            return datadefines.firstordefault(x => x.name == key);
        }
    }

    public virtual byte[] encode()
    {
        // 校验协议数据。
        if(address.length != 7) throw new argumentexception($"水表地址 {bitconverter.tostring(address)} 的长度不正确，长度不等于 7 个字节。");

        builddataarea();
        
        using (var mem = new memorystream())
        {
            mem.writebyte(framehead);
            mem.writebyte(devicetype);
            mem.write(address);
            mem.writebyte(controlcode);
            mem.writebyte((byte)datalength);
            mem.write(dataarea);
            accumulatesum = byteutils.calculateaccumulatesum(mem.toarray());
            mem.writebyte(accumulatesum);
            mem.writebyte(frameend);

            return mem.toarray();
        }
    }

    public virtual iprotocol decode(byte[] sourcebytes)
    {
        using (var mem = new memorystream(sourcebytes))
        {
            using (var reader = new binaryreader(mem))
            {
                reader.readbyte();
                
                devicetype = reader.readbyte();
                address = reader.readbytes(7);
                controlcode = reader.readbyte();
                datalength = reader.readbyte();
                foreach (var datadefine in datadefines)
                {
                    datadefine.data = reader.readbytes(datadefine.length);
                }

                accumulatesum = reader.readbyte();
            }
        }

        return this;
    }
    
    protected virtual void builddataarea()
    {
        // 构建数据域。
        using (var datamemory = new memorystream())
        {
            foreach (var data in datadefines)
            {
                if(data==null) continue;
                datamemory.write(data.data);
            }

            dataarea = datamemory.toarray();
            datalength = dataarea.length;
        }
    }
}

最后我们定义了两个具体的协议类，分别是读表的请求帧和读表的响应帧，在其构造方法分别定义了具体的数据域。

public class cjt188_read_request : cjt188protocol
{
    public cjt188_read_request(string address,byte type)
    {
        address = byteutils.hexstringtobytes(address).reverse().toarray();
        controlcode = 0x1;
        devicetype = type;
        
        datadefines.add(new datadefine{name = "default",length = 2});
        datadefines.add(new datadefine{name = "seq",length = 1});
    }
}

public class cjt188_read_response : cjt188protocol
{
    public cjt188_read_response()
    {
        datadefines.add(new datadefine{name = "default",length = 2});
        datadefines.add(new datadefine{name = "seq",length = 1});
        datadefines.add(new datadefine{name = "alldata",length = 4});
        datadefines.add(new datadefine{name = "alldataunit",length = 1});
        datadefines.add(new datadefine{name = "monthdata",length = 4});
        datadefines.add(new datadefine{name = "monthdataunit",length = 1});
        datadefines.add(new datadefine{name = "datetime",length = 7});
        datadefines.add(new datadefine{name = "status1",length = 1});
        datadefines.add(new datadefine{name = "status2",length = 1});
    }
}

测试代码：

class program
{
    static void main(string[] args)
    {
        // 发送水表读表数据。
        var sendprotocol = new cjt188_read_request("00000805000001",0x10);
        sendprotocol["default"].data = new byte[] {0x1f, 0x90};
        sendprotocol["seq"].data = new byte[] {0x00};

        console.writeline(bitconverter.tostring(sendprotocol.encode()));
        
        // 解析水表响应数据。
        var receiveprotocol = new cjt188_read_response().decode(byteutils.hexstringtobytes("68 10 78 06 12 18 20 00 00 81 16 90 1f 00 00 01 00 00 2c 00 01 00 00 2c 00 00 00 00 00 00 00 01 ff e0 16"));
        
        console.readline();
    }
}

2.3 代码打包下载

上述代码实现均已打包为压缩文件，点击我 即可直接下载。