dlt698.45

数据类型(以下提到的类型都属于其中)

基本数据类型

类型	说明	创建方式
null	空	Null{}
array	数组	&Array{Datas: datas}
structure	对象	&Structure{Array: Array{Datas: datas}}
bool	布尔值	Bool{Value: 1}
bit-string	位串	BitString{Size:8, Value: "11"}
double-long	32 位整数	DoubleLong{Value: 1}
double-long-unsigned	32 位正整数	DoubleLongUnsigned{Value: 1}
octet-string	8 位字节串	OctetString{Value: "ffffff"}
visible-string	ASCII 字符串	VisibleString{Value: "ffffff"}
UTF8-string	UTF-8 编码的字符串	UTF8String{Value: "ffffff"}
integer	8 位整数	Integer{Value: 1}
long	16 位整数	Long{Value: 1}
unsigned	8 位正整数	Unsigned{Value: 1}
long-unsigned	16 位正整数	LongUnsigned{Value: 1}
long64	64 位整数	Long64{Value: 1}
long64-unsigned	64 位正整数	Long64Unsigned{Value: 1}
enum	枚举	Enum{Value: 1}
float32	32 位浮点数	Double32{Value: 1}
float64	64 位浮点数	Double64{Value: 1}

特殊数据类型

date_time

dataTime := DateTime{}
// 依照当前时间生成
dataTimeBuild := dataTime.Build()

date

date := &Date{}
// 依照当前时间生成
dateBuild := date.Build()

time

t := &Time{Hour: 时, Minute: 分, Second: 秒}

date_time_s

dataTimes := DateTimes{}
// 依照当前时间生成
dataTimesBuild := dataTimes.Build()

OI

oi := OI{LongUnsigned: LongUnsigned{Value: 值}}

OAD

oad := &OAD{Value: 4个元素的byte数组}

ROAD

road := &ROAD{Oad: &OAD{Value: 4个元素的byte数组}, Oads: []*OAD{{Value: 4个元素的byte数组}, {Value: 4个元素的byte数组}}}

OMD

omd := &OMD{
		Oi: &OI{LongUnsigned: LongUnsigned{Value: 值}},
		FuncMark: 方法标识,
		Mode: 操作模式,
	}

TI

Ti := &TI{TimeUnit: 单位, Interval: 间隔值}

TSA

&TSA{AddressType: 地址类型, Address: 地址, CA: 客户机地址}

MAC

mac := &MAC{OctetString: OctetString{Value: 字符串}}

RN

rn := RN{OctetString: OctetString{Value: 字符串}}

Region

region := Region{
		Unit: 单位,
		Start: 起始值(数据类型中的一种),
		End: 起始值(数据类型中的一种),
	}

Scaler_Unit

scaler_Unit := ScalerUnit{
		Conver: &Integer{Value: 换算},
		Unit: 单位,
	}

RSD

//不选择
selector0 := Selector0{}

//Selector1 为选择对象的指定值
selector1 := Selector1{
    Oad: 4个元素的byte数组,
    Data: 数据类型中的一种,
}

//Selector2 为选择对象区间内连续间隔值
selector2 := Selector2{
    Oad:  4个元素的byte数组,
    StartData: 数据类型中的一种,
    EndData: 数据类型中的一种,
    Interval: 数据类型中的一种,
}

//Selector3 为多个选择对象区间内连续间隔值的并集
selector3 := Selector3{
		Selectors: []*Selector2{selector},
	}

//Selector4 为指定表计集合、指定采集启动时间
selector := &Selector4{
    StartTime: 时间,
    MS: 表计集合,
}

//Selector5 为指定表计集合、指定采集存储时间
selector5 := &Selector5{
    Selector4: Selector4{
        StartTime: 时间,
        MS: 表计集合,
    },
}

//Selector6 为指定表计集合、指定采集启动时间区间内连续间隔值
selector := &Selector6{
		StartTime:  采集启动时间起始值,
		EndTime:    采集启动时间结束值,
		Ti: 时间间隔,
		Ms:  表计集合,
	}

//Selector7 为指定表计集合、指定采集存储时间区间内连续间隔值
selector7 := &Selector7{
    Selector6:  Selector6{
        StartTime: 采集启动时间起始值,
        EndTime:   采集启动时间结束值,
        Ti: 时间间隔,
        Ms: 表计集合,
    },
}

//Selector8 为指定表计集合、指定采集成功时间区间内连续间隔值。
selector := &Selector8{
		Selector6: selector6,
	}

//Selector9 为指定选取上第 n 次记录
selector := &Selector9{
    Last: 上第 n 次记录,
}

//Select10 为指定选取最新的 n 条记录
selector := &Selector10{
    Last: 上 n 条记录,
    Ms: 表计集合,
}

CSD

csd := CSD{
		CsdType: 0,
		Oad: 4个元素的byte数组,
	}

MS

//无表计
ms := &MS{Ms: &MS0{}}

// 全部用户地址
ms := &MS{Ms: &MS1{}}

//一组用户类型
ms := &MS{Ms: &MS2{Meters: []byte{}}}

// 一组用户地址
ms := &MS{Ms: &MS3{TSAs: []*TSA{}}}

//一组配置序号
ms := &MS{Ms: &MS4{Meters: []uint16{}}}

//一组用户类型区间
ms := &MS{Ms: &MS5{Regions: []*Region{}}}

//一组用户地址区间
ms := &MS{Ms: &MS6{MS5: ms5}}

//一组配置序号区间
ms := &MS{Ms: &MS7{MS5: ms5}}

SID

sid := SID{
		Flag:       标识,
		Additional: &OctetString{Value: 附加数据},
	}

SID_MAC

sidMac := SIDMAC{
		Sid: sid,
		Mac: mac,
	}

COMDCB

COMDCB := COMDCB{
		Baud: 波特率,
		Parity: 校验位,
		DataBits: 数据位,
		StopBits: 停止位,
		FlowControl: 流控,
	}

RCSD

rcsd := RCSD{CSDs: []*CSD{}}

给从站用，旨在生成piid

piid := FlushPIID()

响应中的piid要和请求中的piid相同

生成时间标签域

dateTimes := &DateTimes{}
timeTag := &TimeTag{SendTime: dateTimes.Build(), Ti: &TI{TimeUnit: 1, Interval: 10}}

时间单位：秒(0), 分(1), 时(2), 日(3), 月(4), 年(5)

解析字符串报文

dlt698StrFrame := "需要解析的字符串报文"
dlt698statute, err := DecodeByStr(dlt698StrFrame)

解析byte数组报文

dlt698statute, err := DecodeByBytes(dlt698ArrayFrame)

获取piid和报文类型和报文中的地址

fmt.Println(dlt698statute.GetPiid())
fmt.Println(dlt698statute.GetAPDUType())
主站地址, 客户机地址 := dlt698statute.GetAddress()

预连接请求报文生成

心跳

frameBytes, err := CreateHeartBeat(主站地址, 心跳周期, piid, 客户机地址)

客户机地址：有些厂商是0，有的是16，有的是0A

退出登录

frameBytes, err := CreateLogOut(主站地址, 心跳周期, piid, 客户机地址)

客户机地址：有些厂商是0，有的是16，有的是0A

预连接响应报文生成

frameBytes, err := CreateLinkResponse(主站地址, 客户机地址, 结果, 时钟可信标志, linkRequest中的请求时间, piid)

客户机地址：有些厂商是0，有的是16，有的是0A

结果：0-成功 1-地址重复 2-非法设备 3-容量不足

时钟可信标志： 0-不可信 1-可信

linkRequest中的请求时间: 可以传nil，传nil就是当前时间

piid：要和linkRequest中的piid相同

请求建立应用连接报文生成

生成一个大部分厂家公用的公共连接

frameBytes, err := CreateConnectRequest(主站地址, 客户机地址, piid, 时间单位, 间隔时间)

客户机地址：有些厂商是0，有的是16，有的是0A

时间单位：秒(0), 分(1), 时(2), 日(3), 月(4), 年(5)

请求建立应用连接报文生成

生成认证连接对象

var connectMechanismInfo ConnectMechanismInfo
//公共连接
connectMechanismInfo = &NullSecurity{}
//一般密码
connectMechanismInfo = &PasswordSecurity{Password: &VisibleString{Value: "密码"}}
//对称加密
connectMechanismInfo = &SymmetrySecurity{Secret: &OctetString{Value: "密文 1"}, Signature: &OctetString{Value: "客户机签名 1"}}
//数字签名
connectMechanismInfo = &SignatureSecurity{Secret: &OctetString{Value: "密文 2"}, Signature: &OctetString{Value: "客户机签名 2"}}

2.创建connectRequest主体

connectRequestFrame := &ConnectRequest{
		ExpectVersion:           期望的协议版本号,
		ProtocolBlock:           期望的协议一致性块（8个元素的byte数组，一般每个元素都是0xFF）,
		FuncBlock:               期望的协议一致性块（16个元素的byte数组，一般每个元素都是0xFF）,
		ClientSendMaxSize:       客户机发送帧最大尺寸,
		ClientReceiveMaxSize:    客户机接收帧最大尺寸,
		ClientReceiveWindowSize: 客户机接收帧最大窗口尺寸,
		ClientHandleMaxSize:     客户机最大可处理帧尺寸,
		LinkTimeOut:             期望的应用连接超时时间,
		ConnectMechanismInfo:    connectMechanismInfo,
	}

生成报文

frameBytes, err := CustomConnectRequest(主站地址, 客户机地址, piid, connectRequestFrame, 时间标签域)

时间标签域：创建方式可以参照最上方，可以传nil

建立应用连接响应报文生成

1.创建连接响应对象

factoryVersion := &FactoryVersion{
		ManuCode:            &VisibleString{Value: 厂商代码},
		SoftwareVersion:     &VisibleString{Value: 软件版本号},
		SoftwareVersionDate: &VisibleString{Value: 厂家版本日期},
		HardwareVersion:     &VisibleString{Value: 硬件版本号},
		HardwareVersionDate: &VisibleString{Value: 硬件版本日期},
		ExtendedInfo:        &VisibleString{Value: "FFFFFFFF"}, //厂家扩展信息
	}

2.创建应用连接响应报文对象

connectResponse := &ConnectResponse{
		FactoryVersion:             factoryVersion,
		ExpectVersion:              商定的协议版本号,
		ProtocolBlock:              商定的协议一致性块（8个元素的byte数组）,
		FuncBlock:                  商定的功能一致性块（16个元素的byte数组）,
		ServerSendMaxSize:          服务器发送帧最大尺寸,
		ServerReceiveMaxSize:       服务器接收帧最大尺寸,
		ServerReceiveWindowMaxSize: 服务器接收帧最大窗口尺寸,
		ServerHandleMaxSize:        服务器最大可处理帧尺寸,
		LinkTimeOut:                商定的应用连接超时时间,
		ConnectResponseInfo: &ConnectResponseInfo{
			ConnectResult: 结果,
			SecurityData: &SecurityData{
				RN:         &OctetString{Value: "服务器随机数"},
				ServerSign: &OctetString{Value: "服务器签名信息"},
			},
		},
	}

结果：允许建立应用连接（0），密码错误（1），对称解密错误（2），非对称解密错误（3），签名错误（4），协议版本不匹配（5），其他错误（255） 3.生成报文

frameBytes, err := CreateConnectResponse(主站地址, 客户机地址, piid, connectResponse, 时间标签域)

时间标签域：创建方式可以参照最上方，可以传nil

请求断开应用连接报文生成

frameBytes, _ := CreateReleaseRequest(主站地址, 客户机地址, piid, 时间标签, 间隔时间)

断开应用连接响应报文生成

frameBytes, _ := CreateReleaseResponse(主站地址, 客户机地址, piid, 时间标签, 间隔时间)

断开应用连接通知报文生成

frameBytes, _ := CreateReleaseNotification(主站地址, 客户机地址, piid, 时间标签域)

时间标签域：创建方式可以参照最上方，可以传nil

GetRequestNormal 请求读取一个对象属性

frameBytes, err := CreateGetRequestNormal(主站地址, 客户机地址, piid, oad, 时间标签域)

时间标签域：创建方式可以参照最上方，可以传nil

举例：采集组合有功电能

frameBytes, err := CreateGetRequestNormal("010203040506", 0, 1, []byte{0x00, 0x00, 0x00, 0x00}, nil)

GetRequestNormalList 请求读取若干个对象属性

frameBytes, err := CreateGetRequestNormalList(主站地址, 客户机地址, piid, 时间标签域, oads)

时间标签域：创建方式可以参照最上方，可以传nil

举例：采集组合有功电能和电压

frameBytes, err := CreateGetRequestNormalList("010203040506", 0, 1, nil, []byte{0x00, 0x00, 0x00, 0x00}, []byte{0x20, 0x00, 0x02, 0x00})

GetRequestRecord 请求读取一个记录型对象属性

frameBytes, err := CreateGetRequestRecord(主站地址, 客户机地址, piid, oad, rsd, rcsd, 时间标签域)

举例：读取终端停上电事件

rsd := &Selector9{Last: 1}
rcsd := &RCSD{
    CSDs: []*CSD{{CsdType: 0, Oad: []byte{0x20, 0x22, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x20, 0x1e, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x20, 0x20, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x20, 0x24, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x33, 0x09, 0x02, 0x06}}},
}
frameBytes, err := GetRequestRecord("010203040506", 1, 1, []byte{0x31, 0x06, 0x02, 0x00}, rsd, rcsd, nil)

GetRequestRecordList 请求读取若干个记录型对象属性

生成GetRecord对象

frameBytes, err := CreateGetRequestRecordList(主站地址, 客户机地址, piid, 时间标签域, getRecord1, getRecord2)

举例

生成两个getRecord

getRecord1 := &GetRecord{
		OAD: []byte{0x31, 0x06, 0x02, 0x00},
		Rsd: &RSD{Selector: &Selector9{Last: 1}},
		Rcsd: &RCSD{
			CSDs: []*CSD{{CsdType: 0, Oad: []byte{0x20, 0x22, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x20, 0x1e, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x20, 0x20, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x20, 0x24, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x33, 0x09, 0x02, 0x06}}},
		},
	}

getRecord2 := &GetRecord{
		OAD: []byte{0x31, 0x06, 0x02, 0x00},
		Rsd: &RSD{Selector: &Selector9{Last: 1}},
		Rcsd: &RCSD{
			CSDs: []*CSD{{CsdType: 0, Oad: []byte{0x20, 0x22, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x20, 0x1e, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x20, 0x20, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x20, 0x24, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x33, 0x09, 0x02, 0x06}}},
		},
	}

生成时间标签

dateTimes := &DateTimes{}
timeTag := &TimeTag{SendTime: dateTimes.Build(), Ti: &TI{TimeUnit: 1, Interval: 10}}

封装出报文

frameBytes, err := CreateGetRequestRecordList("010203040506", 1, 1, timeTag, getRecord1, getRecord2)

timeTag 可以为nil

GetRequestNext 请求读取分帧传输的下一帧

frameBytes, err := CreateGetRequestNext(主站地址, 客户机地址, piid, 已接收的最后分帧序号)

GetRequestMD5 请求读取一个对象属性MD5值

frameBytes, err := CreateGetRequestMD5(主站地址, 客户机地址, piid, [4]byte)

GetResponseNormal 响应读取一个对象属性

frameBytes, err := CreateGetResponseNormal(主站地址, 客户机地址, piid, oad([4]byte), 结果数据, 时间标签域, 跟随上报信息域)

举例：创建一个携带正常数据的GetResponseNormal

frameBytes, err := CreateGetResponseNormal("010203040506", 1, 1, []byte{0x00, 0x00, 0x00, 0x00}, &Long{Value: 220}, nil, nil)

举例：创建一个携带错误信息的GetResponseNormal

frameBytes, err := CreateGetResponseNormal("010203040506", 1, 1, []byte{0x00, 0x00, 0x00, 0x00}, &DAR{Value: 错误信息代码 0~255}, nil, nil)

timeTag 可以为nil

跟随上报信息域创建方式详见下方

GetResponseNormalList 响应读取若干个对象属性

创建resultNormal

	resultNormal1 := &ResultNormal{
		OAD: 4个元素的byte数组,
		GetResult: &GetResult{
			Data: 对应数据,
		},
	}
	resultNormal2 := &ResultNormal{
		OAD: 4个元素的byte数组,
		GetResult: &GetResult{
			Data: 对应数据,
		},
	}

创建报文

frameBytes, err := CreateGetResponseNormalList(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, resultNormal1, resultNormal2)

GetResponseRecord 响应读取一个记录型对象属性

创建resultRecord

resultRecord := &ResultRecord{
		Oad: oad,
		Rcsd: &RCSD{
			CSDs: []*CSD{},
		},
		Data: &RecordRow{},
		},
	}

创建报文

frameBytes, err := CreateGetResponseRecord(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, resultRecord)

举例：读取终端停上电事件的成功响应

dateTimes := &DateTimes{}
dt := dateTimes.Build()
//创建若一个ResultNormal
resultRecord := &ResultRecord{
    Oad: []byte{0x31, 0x06, 0x02, 0x00},
    Rcsd: &RCSD{
        CSDs: []*CSD{
            {0, []byte{0x20, 0x22, 0x02, 0x00}},
            {0, []byte{0x20, 0x1e, 0x02, 0x00}},
            {0, []byte{0x20, 0x20, 0x02, 0x00}},
            {0, []byte{0x20, 0x24, 0x02, 0x00}},
            {0, []byte{0x33, 0x09, 0x02, 0x06}},
        },
    },
    Data: &RecordRow{
        RecordRow: []Datatype{
            &DoubleLongUnsigned{Value: 0x02},
            dt,
            dt,
            &Enum{Value: 0x01},
            &BitString{Size: 8, Value: "10"},
        },
    },
}
frameBytes, err := CreateGetResponseRecord("010203040506", 1, 1, nil, nil, resultRecord)
if err != nil {
    fmt.Println(err)
}
fmt.Println(hex.EncodeToString(frameBytes))

举例：读取终端停上电事件的失败响应

dateTimes := &DateTimes{}
dt := dateTimes.Build()
//创建若一个ResultNormal
resultRecord := &ResultRecord{
    Oad: []byte{0x31, 0x06, 0x02, 0x00},
    Rcsd: &RCSD{
        CSDs: []*CSD{
            {0, []byte{0x20, 0x22, 0x02, 0x00}},
            {0, []byte{0x20, 0x1e, 0x02, 0x00}},
            {0, []byte{0x20, 0x20, 0x02, 0x00}},
            {0, []byte{0x20, 0x24, 0x02, 0x00}},
            {0, []byte{0x33, 0x09, 0x02, 0x06}},
        },
    },
    Data: &DAR{Value: 0xff},
}
frameBytes, err := CreateGetResponseRecord("010203040506", 1, 1, nil, nil, resultRecord)
if err != nil {
    fmt.Println(err)
}
fmt.Println(hex.EncodeToString(frameBytes))

GetResponseRecordList 响应读取若干个记录型对象属性

frameBytes, err := CreateGetResponseRecordList(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, resultRecord1, resultRecord2, resultRecord3, resultRecord4)

FollowReport 跟随上报信息域

跟随上报信息域分为两种： ResultNormal， ResultRecord

创建跟随上报信息域对象

fr := &FollowReport{}

创建ResultNormal格式的跟随上报信息域

err := fr.BuildByResultNormal(resultNormal)

3.创建ResultRecord格式的跟随上报信息域

err := fr.BuildByResultRecord(resultRecord)

ResultNormal ResultRecord 创建方式同上方

GetResponseNext 响应读取分帧传输的下一帧

返回一个错误信息

frameBytes, err := CreateGetResponseNextError(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, 末帧标志, 分帧序号, &DAR{Value: 错误信息})

返回ResultRecord

frameBytes, err := CreateGetResponseNextResultRecord(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, 末帧标志, 分帧序号, resultRecord1, resultRecord2)

返回ResultNormal

frameBytes, err := CreateGetResponseNextResultNormal(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, 末帧标志, 分帧序号, resultNormal1, resultNormal1)

GetResponseMD5 响应读取对象属性MD5值

返回一个错误信息

frameBytes, err := CreateGetResponseNextError(主站地址, 客户机地址, piid, oad, 错误信息, 时间标签域, 跟随上报信息域)

返回正常信息

frameBytes, err := CreateGetResponseMD5(主站地址, 客户机地址, piid, oad, 字符串, 时间标签域, 跟随上报信息域)

SetRequestNormal 请求设置一个对象属性

frameBytes, err := CreateSetRequestNormal(主站地址, 客户机地址, piid, oad, 设置的数据值, 时间标签域)

举例：设置安全模式系数

dateTimes := &DateTimes{}
timeTag := &TimeTag{SendTime: dateTimes.Build(), Ti: &TI{TimeUnit: 1, Interval: 10}}
frameBytes, err := SetRequestNormal("010203040506", 1, 1, []byte{0xf1, 0x01, 0x02, 0x00}, &Enum{Value: 1}, timeTag)
if err != nil {
    fmt.Println(err)
}
fmt.Println(hex.EncodeToString(frameBytes))

时间标签域可以为nil

SetRequestNormalList 请求设置若干个对象属性

创建若干setRequestNormal

setRequestNormal1 := &SetRequestNormal{
		Oad:  oad,
		Data: data,
	}
setRequestNormal2 := &SetRequestNormal{
Oad:  oad,
Data: data,
}

创建报文

frameBytes, err := CreateSetRequestNormalList(主站地址, 客户机地址, piid, 时间标签域, setRequestNormal1, setRequestNormal2)

SetThenGetRequestNormalList 请求设置后读取若干个对象属性

frameBytes, err := CreateSetThenGetRequestNormalList(主站地址, 客户机地址, piid, 时间标签域, timeTag, item1, item2)

举例：设置安全模式系数和终端时间后读取

dateTimes := &DateTimes{}
dt := dateTimes.Build()
//timeTag := &TimeTag{SendTime: dt, Ti: &TI{TimeUnit: 1, Interval: 10}}
item1 := &SetThenGetRequestItem{
    SetOad:  []byte{0xf1, 0x01, 0x02, 0x00},
    Data:    &Enum{Value: 1},
    ReadOad: []byte{0xf1, 0x01, 0x02, 0x00},
    Delay:   20,
}
item2 := &SetThenGetRequestItem{
    SetOad:  []byte{0x40, 0x00, 0x02, 0x00},
    Data:    dt,
    ReadOad: []byte{0x40, 0x00, 0x02, 0x00},
    Delay:   20,
}
frameBytes, err := SetThenGetRequestNormalList("010203040506", 1, 1, nil, item1, item2)
if err != nil {
    fmt.Println(err)
}
fmt.Println(hex.EncodeToString(frameBytes))

SetResponseNormal 响应设置一个对象属性

frameBytes, err := CreateSetResponseNormal(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, oad, 设置结果)

举例：安全参数设置成功

dateTimes := &DateTimes{}
dt := dateTimes.Build()
timeTag := &TimeTag{SendTime: dt, Ti: &TI{TimeUnit: 1, Interval: 10}}
frameBytes, err := SetResponseNormal("010203040506", 1, 1, timeTag, nil, []byte{0xf1, 0x01, 0x02, 0x00}, 0)
if err != nil {
fmt.Println(err)
}
fmt.Println(hex.EncodeToString(frameBytes))

SetResponseNormalList 响应设置若干个对象属性

生成结果集

setResponseNormal1 := &SetResponseNormal{
		Oad: oad,
		Dar: &DAR{Value: 设置结果},
	}
setResponseNormal2 := &SetResponseNormal{
Oad: oad,
Dar: &DAR{Value: 设置结果},
}

生成报文

frameBytes, err := CreateSetResponseNormalList(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, setResponseNormal1, setResponseNorma2)

举例：返回设置安全参数和时间的结果

dateTimes := &DateTimes{}
dt := dateTimes.Build()
timeTag := &TimeTag{SendTime: dt, Ti: &TI{TimeUnit: 1, Interval: 10}}
setResponseNormal1 := &SetResponseNormal{
    Oad: []byte{0xf1, 0x01, 0x02, 0x00},
    Dar: &DAR{Value: 0},
}
setResponseNorma2 := &SetResponseNormal{
    Oad: []byte{0x40, 0x00, 0x02, 0x00},
    Dar: &DAR{Value: 0},
}
frameBytes, err := CreateSetResponseNormalList("010203040506", 1, 1, timeTag, nil, setResponseNormal1, setResponseNorma2)
if err != nil {
    fmt.Println(err)
}
fmt.Println(hex.EncodeToString(frameBytes))

SetThenGetResponseNormalList 响应设置若干个对象属性以及读取若干个对象属性

创建结果集

item1, err := CreateSetThenGetResponseNormalListItem(oad, 设置执行结果, ResultNormal中的oad, ResultNormal中的数据)
item2, err := CreateSetThenGetResponseNormalListItem(oad, 设置执行结果, ResultNormal中的oad, ResultNormal中的数据)

创建报文

frameBytes, err := CreateSetThenGetResponseNormalList(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, item1, item2)

举例：回复设置安全系数和时间

dateTimes := &DateTimes{}
dt := dateTimes.Build()
timeTag := &TimeTag{SendTime: dt, Ti: &TI{TimeUnit: 1, Interval: 10}}
item1 := SetThenGetResponseNormalListItem([]byte{0xf1, 0x01, 0x02, 0x00}, 0, []byte{0xf1, 0x01, 0x02, 0x00}, &Enum{Value: 1})
item2 := SetThenGetResponseNormalListItem([]byte{0x40, 0x00, 0x02, 0x00}, 1, []byte{0x40, 0x00, 0x02, 0x00}, dt)
frameBytes, err := CreateSetThenGetResponseNormalList("010203040506", 1, 1, timeTag, nil, item1, item2)
if err != nil {
    fmt.Println(err)
}
fmt.Println(hex.EncodeToString(frameBytes))

ActionRequestNormal 请求操作一个对象方法

frameBytes, err := CreateActionRequestNormal(主站地址, 客户机地址, piid, oi, 方法标识, 操作模式, 要操作的数据, 时间标签域)

举例：剔除相关2组地址下广播校时

dateTimes := &DateTimes{}
dt := dateTimes.Build()
timeTag := &TimeTag{SendTime: dt, Ti: &TI{TimeUnit: 1, Interval: 10}}
frameBytes, err := CreateActionRequestNormal("010203040506", 1, 1, []byte{0x04, 0x00, 0x00, 0x00}, 0x7f, 0, dt, timeTag)
if err != nil {
    fmt.Println(err)
}
fmt.Println(hex.EncodeToString(frameBytes))

ActionRequestNormalList 请求操作若干个对象方法

创建结果集

actionRequestNormalItem1, err := ActionRequestNormalItem(oi, 方法标识, 操作模式, 要操作的数据)
actionRequestNormalItem2, err := ActionRequestNormalItem(oi, 方法标识, 操作模式, 要操作的数据)

创建报文

frameBytes, err := CreateActionRequestNormalList(主站地址, 客户机地址, piid, 时间标签域, actionRequestNormalItem1, actionRequestNormalItem2)

举例：剔除相关2组地址下广播校时、剔除相关1组地址下设其它参数

dateTimes := &DateTimes{}
dt := dateTimes.Build()
timeTag := &TimeTag{SendTime: dt, Ti: &TI{TimeUnit: 1, Interval: 10}}
actionRequestNormalItem1, err := ActionRequestNormalItem([]byte{0x04, 0x00, 0x00, 0x00}, 0x7f, 0, dt)
if err != nil {
    fmt.Println(err)
}
actionRequestNormalItem2, err := ActionRequestNormalItem([]byte{0x08, 0x01, 0x00, 0x00}, 0x02, 0, &Long64{Value: 50000})
if err != nil {
    fmt.Println(err)
}

frameBytes, err := CreateActionRequestNormalList("010203040506", 1, 1, timeTag, actionRequestNormalItem1, actionRequestNormalItem2)
if err != nil {
    fmt.Println(err)
}
fmt.Println(hex.EncodeToString(frameBytes))

ActionThenGetRequestNormalList 请求操作若干个对象方法后读取若干个对象属性

创建结果集

item1, err := ActionThenGetRequestNormalListItem(oi, 方法标识, 操作模式, 要操作的数据, oad, 读取延时)
item1, err := ActionThenGetRequestNormalListItem(oi, 方法标识, 操作模式, 要操作的数据, oad, 读取延时)

创建报文

frameBytes, err := ActionThenGetRequestNormalList(主站地址, 客户机地址, piid, 时间标签域, item1, item2)

举例：剔除相关2组地址下广播校时、剔除相关1组地址下设其它参数

dateTimes := &DateTimes{}
dt := dateTimes.Build()
timeTag := &TimeTag{SendTime: dt, Ti: &TI{TimeUnit: 1, Interval: 10}}
item1, err := ActionThenGetRequestNormalListItem([]byte{0x04, 0x00, 0x00, 0x00}, 0x7f, 0, dt, []byte{0x04, 0x00, 0x00, 0x00}, 2)
if err != nil {
    fmt.Println(err)
}
item2, err := ActionThenGetRequestNormalListItem([]byte{0x08, 0x01, 0x00, 0x00}, 0x02, 0, &Long64{Value: 50000}, []byte{0x08, 0x01, 0x00, 0x00}, 2)
if err != nil {
    fmt.Println(err)
}

frameBytes, err := CreateActionThenGetRequestNormalList("010203040506", 1, 1, timeTag, item1, item2)
if err != nil {
    fmt.Println(err)
}
fmt.Println(hex.EncodeToString(frameBytes))

ActionResponseNormal 响应操作一个对象方法

frameBytes, err := CreateActionResponseNormal(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, oi, 方法标识, 操作模式, 操作执行结果, 结果值)

举例：剔除相关1组地址下设其它参数

dateTimes := &DateTimes{}
dt := dateTimes.Build()
timeTag := &TimeTag{SendTime: dt, Ti: &TI{TimeUnit: 1, Interval: 10}}
frameBytes, err := CreateActionResponseNormal("010203040506", 1, 1, timeTag, nil, []byte{0x08, 0x01, 0x00, 0x00}, 0x02, 0x00, 0, &Long64{Value: 50000})
if err != nil {
    fmt.Println(err)
}
fmt.Println(hex.EncodeToString(frameBytes))

ActionResponseNormalList 响应操作若干个对象方法

创建ActionResponseNormal对象

actionResponseNormalItem1, err := ActionResponseNormalItem(oi, 方法标识, 操作模式, 操作执行结果, 结果值)
actionResponseNormalItem2, err := ActionResponseNormalItem(oi, 方法标识, 操作模式, 操作执行结果, 结果值)

生成报文

frameBytes, err := CreateActionResponseNormalList(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, actionResponseNormalItem1, actionResponseNormalItem2)

举例：剔除相关2组地址下广播校时、剔除相关1组地址下设其它参数

dateTimes := &DateTimes{}
dt := dateTimes.Build()
timeTag := &TimeTag{SendTime: dt, Ti: &TI{TimeUnit: 1, Interval: 10}}
actionResponseNormalItem1, err := ActionResponseNormalItem([]byte{0x08, 0x01, 0x00, 0x00}, 0x02, 0x00, 0, &Long64{Value: 50000})
actionResponseNormalItem2, err := ActionResponseNormalItem([]byte{0x04, 0x00, 0x00, 0x00}, 0x7f, 0x00, 0, dt)
frameBytes, err := CreateActionResponseNormalList("010203040506", 1, 1, timeTag, nil, actionResponseNormalItem1, actionResponseNormalItem2)
if err != nil {
    fmt.Println(err)
}
fmt.Println(hex.EncodeToString(frameBytes))

ActionThenGetResponseNormalList 响应操作若干个对象方法后读取若干个属性

创建属性

actionThenGetResponseNormalListItem1, err := ActionThenGetResponseNormalListItem([]byte{oi, 方法标识, 操作模式, 操作执行结果, 结果值1, oad, 结果值2)
actionThenGetResponseNormalListItem2, err := ActionThenGetResponseNormalListItem([]byte{oi, 方法标识, 操作模式, 操作执行结果, 结果值1, oad, 结果值2)

创建报文

frameBytes, err := CreateActionThenGetResponseNormalList(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, actionThenGetResponseNormalListItem1, actionThenGetResponseNormalListItem2)

ReportNotificationList 通知上报若干个对象属性

frameBytes, err := CreateReportNotificationList(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, resultNormal2, resultNormal1)

举例：电压、终端时间

dateTimes := &DateTimes{}
dt := dateTimes.Build()
timeTag := &TimeTag{SendTime: dt, Ti: &TI{TimeUnit: 1, Interval: 10}}
resultNormal1 := &ResultNormal{
    OAD: []byte{0x40, 0x00, 0x02, 0x00},
    GetResult: &GetResult{
        Data: dt,
    },
}
resultNormal2 := &ResultNormal{
    OAD: []byte{0x20, 0x00, 0x02, 0x00},
    GetResult: &GetResult{
        Data: &Array{
            Datas: []Datatype{
                &LongUnsigned{Value: 220},
                &LongUnsigned{Value: 220},
                &LongUnsigned{Value: 220},
            },
        },
    },
}
frameBytes, err := CreateReportNotificationList("010203040506", 1, 1, timeTag, nil, resultNormal2, resultNormal1)
if err != nil {
    fmt.Println(err)
}
fmt.Println(hex.EncodeToString(frameBytes))

ReportNotificationRecordList 通知上报若干个记录型对象属性

frameBytes, err := CreateReportNotificationRecordList(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, resultRecord1, resultRecord2)

ReportNotificationTransData 通知上报透明数据

frameBytes, err := CreateReportNotificationTransData(主站地址, 客户机地址, piid, 时间标签域, 跟随上报信息域, oad, 字符串型结果)

字符串结果可以为""

ReportResponseList 响应上报若干个对象属性

frameBytes, err := CreateReportResponseList(主站地址, 客户机地址, piid, 时间标签域, oad1, oad2)

ReportResponseRecordList 上报若干个记录型对象属性的响应

frameBytes, err := CreateReportResponseRecordList(主站地址, 客户机地址, piid, 时间标签域, oad1, oad2)

ReportResponseTransData 响应上报透明数据

frameBytes, err := CreateReportResponseTransData(主站地址, 客户机地址, piid, 时间标签域)

ProxyGetRequestList 请求代理读取若干个服务器的若干个对象属性

创建属性

pgr1 := &ProxyGetRequestListItem{
    Tsa:     "一个目标服务器地址TSA",
    TimeOut: &LongUnsigned{Value: 代理一个目标服务器的超时时间},
    Oads: [][]byte{
        oad,
		oad,
    },
}
pgr2 := &ProxyGetRequestListItem{
    Tsa:     "一个目标服务器地址TSA",
    TimeOut: &LongUnsigned{Value: 代理一个目标服务器的超时时间},
    Oads: [][]byte{
        oad,
        oad,
    },
}

创建报文

frameBytes, err := CreateProxyGetRequestList(主站地址, 客户机地址, piid, 时间标签域, 代理整个请求的超时时间, pgr1, pgr2)

ProxyGetRequestRecord 请求代理读取一个服务器的一个记录型对象属性

frameBytes, err := CreateProxyGetRequestRecord(主站地址, 客户机地址, piid, 时间标签域, 代理整个请求的超时时间, 目标服务器地址, 对象属性描述符 oad,  记录行选择描述符,  记录列选择描述符)

举例

rsd := &Selector9{Last: 1}
rcsd := &RCSD{
    CSDs: []*CSD{{CsdType: 0, Oad: []byte{0x20, 0x22, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x20, 0x1e, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x20, 0x20, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x20, 0x24, 0x02, 0x00}}, {CsdType: 0, Oad: []byte{0x33, 0x09, 0x02, 0x06}}},
}
frameBytes, err := ProxyGetRequestRecord("202306002314", 1, 1, nil, 30, "010203040506", []byte{0x33, 0x09, 0x02, 0x06}, rsd, rcsd)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(hex.EncodeToString(frameBytes))

Files

dlt_698.md

Latest commit

History

dlt_698.md

File metadata and controls

dlt698.45

数据类型(以下提到的类型都属于其中)

基本数据类型

特殊数据类型

date_time

date

time

date_time_s

OI

OAD

ROAD

OMD

TI

TSA

MAC

RN

Region

Scaler_Unit

RSD

CSD

MS

SID

SID_MAC

COMDCB

RCSD

给从站用，旨在生成piid

生成时间标签域

解析字符串报文

解析byte数组报文

获取piid和报文类型和报文中的地址

预连接请求报文生成

登录

心跳

退出登录

预连接响应报文生成

请求建立应用连接报文生成

生成一个大部分厂家公用的公共连接

请求建立应用连接报文生成

建立应用连接响应报文生成

请求断开应用连接报文生成

断开应用连接响应报文生成

断开应用连接通知报文生成

GetRequestNormal 请求读取一个对象属性

GetRequestNormalList 请求读取若干个对象属性

GetRequestRecord 请求读取一个记录型对象属性

GetRequestRecordList 请求读取若干个记录型对象属性

GetRequestNext 请求读取分帧传输的下一帧

GetRequestMD5 请求读取一个对象属性MD5值

GetResponseNormal 响应读取一个对象属性

GetResponseNormalList 响应读取若干个对象属性

GetResponseRecord 响应读取一个记录型对象属性

GetResponseRecordList 响应读取若干个记录型对象属性

FollowReport 跟随上报信息域

GetResponseNext 响应读取分帧传输的下一帧

GetResponseMD5 响应读取对象属性MD5值

SetRequestNormal 请求设置一个对象属性

SetRequestNormalList 请求设置若干个对象属性

SetThenGetRequestNormalList 请求设置后读取若干个对象属性

SetResponseNormal 响应设置一个对象属性

SetResponseNormalList 响应设置若干个对象属性

SetThenGetResponseNormalList 响应设置若干个对象属性以及读取若干个对象属性

ActionRequestNormal 请求操作一个对象方法

ActionRequestNormalList 请求操作若干个对象方法

ActionThenGetRequestNormalList 请求操作若干个对象方法后读取若干个对象属性

ActionResponseNormal 响应操作一个对象方法

ActionResponseNormalList 响应操作若干个对象方法

ActionThenGetResponseNormalList 响应操作若干个对象方法后读取若干个属性

ReportNotificationList 通知上报若干个对象属性

ReportNotificationRecordList 通知上报若干个记录型对象属性

ReportNotificationTransData 通知上报透明数据

ReportResponseList 响应上报若干个对象属性

ReportResponseRecordList 上报若干个记录型对象属性的响应

ReportResponseTransData 响应上报透明数据

ProxyGetRequestList 请求代理读取若干个服务器的若干个对象属性