iec61850采样协议（9-1、9-2）解析(二)
生活随笔
收集整理的這篇文章主要介紹了
iec61850采样协议（9-1、9-2）解析(二)
小編覺(jué)得挺不錯(cuò)的,現(xiàn)在分享給大家,幫大家做個(gè)參考.
1 /*
2 * iec61850采樣協(xié)議（9-1、9-2）解析。
3 *
4 *
5 * 本代碼支持win32平臺(tái)和linux平臺(tái)。
6 *
7 * Copyright,lizhi<ibox>
8 *
9 * 2012-10-10 V1.0 lizhi<QQ:252240557,msn:ddgooo@hotmail.com> created
10 *
11 * 我曾經(jīng)問(wèn)過(guò)不休，你何時(shí)跟我走？可你卻總是笑我，一無(wú)所有；
12 * 我要給你我的追求，還有我的自由；可你卻總是笑我，一無(wú)所有；
13 *
14 */
15
16
17 /*
18 * 頭文件
19 */
20 #include "base_type.h"
21 #include "base_include.h"
22 #include "base_debug.h"
23 #include "base_function.h"
24 #include "base_endian.h"
25
26 #include "iec61850sv_protocol.h"
27
28
29 /*
30 * 測(cè)試宏開(kāi)關(guān)
31 */
32 //*
33 #define IEC61850SV_CONSOLE_DEMO
34 // */
35
36
37 /*
38 * _my_read_sv_bytes/_my_write_sv_bytes - 讀取/寫(xiě)入并且轉(zhuǎn)換sv數(shù)據(jù)。讀取count個(gè)字節(jié),fd會(huì)自加;
39 * @pfd: 讀寫(xiě)地址，為buffer地址；
40 * @ptr: 讀取/寫(xiě)入的數(shù)據(jù)；
41 * @count: 需要讀取/寫(xiě)入的字節(jié)個(gè)數(shù)；
42 * @counter: 讀取/寫(xiě)入的字節(jié)計(jì)數(shù)器；
43 *
44 */
45 #define _my_read_sv_bytes(pfd, ptr, count, counter) \
46 do { \
47 _my_read_svpdu_bufn((pfd), (u8*)(ptr), (count)); \
48 (counter) += (count); \
49 } while(0)
50
51 #define _my_write_sv_bytes(pfd, ptr, count, counter) \
52 do { \
53 _my_write_svpdu_bufn((pfd), (u8*)(ptr), (count)); \
54 (counter) += (count); \
55 } while(0)
56
57 /*
58 * _my_read_asn1_tag8/_my_write_asn1_tag8 - 按照asn.1規(guī)范讀取/寫(xiě)入標(biāo)志字節(jié),fd會(huì)自加;
59 * @pfd: 讀寫(xiě)地址，為buffer地址；
60 * @tag: 讀取/寫(xiě)入的數(shù)據(jù)；
61 * @counter: 讀取/寫(xiě)入的字節(jié)計(jì)數(shù)器；
62 *
63 */
64 #define _my_read_asn1_tag8(pfd, tag, counter) \
65 do { \
66 u8 data = 0; \
67 _my_read_sv_bytes((pfd), &data, 1, counter); \
68 (tag) = _my_get8(&data); \
69 } while(0)
70 #define _my_write_asn1_tag8(pfd, tag, counter) \
71 do { \
72 u8 data = _my_get8(&tag); \
73 _my_write_sv_bytes((pfd), &data, 1, counter); \
74 } while(0)
75
76 /*
77 * _my_read_asn1_length/_my_write_asn1_length - 按照asn.1規(guī)范讀取/寫(xiě)入長(zhǎng)度,fd會(huì)自加;
78 * @pfd: 讀寫(xiě)地址，為buffer地址；
79 * @len: 讀取/寫(xiě)入的數(shù)據(jù)；
80 * @counter: 讀取/寫(xiě)入的字節(jié)計(jì)數(shù)器；
81 *
82 */
83 #define _my_read_asn1_length(pfd, len, counter) \
84 do { \
85 u8 len_first, len_bytes; \
86 u8 datas[5]; \
87 _my_read_sv_bytes((pfd), &len_first, 1, counter); \
88 if ( len_first & 0x80 ) { \
89 len_bytes = len_first & 0x7f; \
90 if (len_bytes == 1) { \
91 _my_read_sv_bytes((pfd), datas, 1, counter); \
92 (len) = *datas; \
93 } \
94 else if (len_bytes == 2) { \
95 _my_read_sv_bytes((pfd), datas, 2, counter); \
96 (len) = _my_btoh16((_my_getb16(datas))); \
97 } \
98 else if (len_bytes == 3) { \
99 datas[0] = 0x00; \
100 _my_read_sv_bytes((pfd), datas+1, 3, counter); \
101 (len) = _my_btoh32((_my_getb32(datas))); \
102 } \
103 else { \
104 _my_read_sv_bytes((pfd), datas, 4, counter); \
105 (len) = _my_btoh32((_my_getb32(datas))); \
106 } \
107 } \
108 else { \
109 (len) = len_first; \
110 } \
111 } while(0)
112 #define _my_write_asn1_length(pfd, len, counter) \
113 do { \
114 u8 tag; \
115 u32 datas; \
116 datas = _my_htob32(((u32)(len))); \
117 if ((len) <= 0x0000007f) { \
118 _my_write_sv_bytes((pfd), (u8*)(&datas), 1, counter); \
119 } \
120 else if ((len) <= 0x000000ff) { \
121 tag = (u8)0x81; \
122 _my_write_sv_bytes((pfd), (u8*)(&tag), 1, counter); \
123 _my_write_sv_bytes((pfd), (u8*)(&datas), 1, counter); \
124 } \
125 else if ((len) <= 0x0000ffff) { \
126 tag = (u8)0x82; \
127 _my_write_sv_bytes((pfd), (u8*)(&tag), 1, counter); \
128 _my_write_sv_bytes((pfd), (u8*)(&datas), 2, counter); \
129 } \
130 else if ((len) <= 0x00ffffff) { \
131 tag = (u8)0x83; \
132 _my_write_sv_bytes((pfd), (u8*)(&tag), 1, counter); \
133 _my_write_sv_bytes((pfd), (u8*)(&datas), 3, counter); \
134 } \
135 else if ((len) <= 0xffffffff) { \
136 tag = (u8)0x84; \
137 _my_write_sv_bytes((pfd), (u8*)(&tag), 1, counter); \
138 _my_write_sv_bytes((pfd), (u8*)(&datas), 4, counter); \
139 } \
140 } while(0)
141
142 /*
143 * _my_read_asn1_valn/_my_write_asn1_valn - 按照asn.1規(guī)范讀取/寫(xiě)入int,fd會(huì)自加;
144 * @pfd: 讀寫(xiě)地址，為buffer地址；
145 * @val: 讀取/寫(xiě)入的數(shù)據(jù)；
146 * @len: 數(shù)據(jù)長(zhǎng)度；
147 * @counter: 讀取/寫(xiě)入的字節(jié)計(jì)數(shù)器；
148 *
149 */
150 #define _my_read_asn1_valn(pfd, val, len, counter) \
151 do { \
152 u8 datas[5]; \
153 if ((len) == 1) { \
154 _my_read_sv_bytes((pfd), datas, 1, counter); \
155 (val) = *datas; \
156 } \
157 else if ((len) == 2) { \
158 _my_read_sv_bytes((pfd), datas, 2, counter); \
159 (val) = _my_btoh16((_my_getb16(datas))); \
160 } \
161 else if ((len) == 3) { \
162 datas[0] = 0x00; \
163 _my_read_sv_bytes((pfd), datas+1, 3, counter); \
164 (val) = _my_btoh32((_my_getb32(datas))); \
165 } \
166 else if ((len) == 4) { \
167 _my_read_sv_bytes((pfd), datas, 4, counter); \
168 (val) = _my_btoh32((_my_getb32(datas))); \
169 } \
170 } while(0)
171 #define _my_write_asn1_valn(pfd, val, len, counter) \
172 do { \
173 u32 datas; \
174 datas = _my_htob32(((u32)(val))); \
175 if ((len) == 1) { \
176 _my_write_sv_bytes((pfd), (u8*)(&datas), 1, counter); \
177 } \
178 else if ((len) == 2) { \
179 _my_write_sv_bytes((pfd), (u8*)(&datas), 2, counter); \
180 } \
181 else if ((len) == 3) { \
182 _my_write_sv_bytes((pfd), (u8*)(&datas), 3, counter); \
183 } \
184 else if ((len) == 4) { \
185 _my_write_sv_bytes((pfd), (u8*)(&datas), 4, counter); \
186 } \
187 } while(0)
188
189
190 /*
191 * _my_read_asn1_valb/_my_write_asn1_valb - 按照asn.1規(guī)范讀取/寫(xiě)入bytes,fd會(huì)自加;
192 * @pfd: 讀寫(xiě)地址，為buffer地址；
193 * @val: 讀取/寫(xiě)入的數(shù)據(jù)；
194 * @len: 數(shù)據(jù)長(zhǎng)度；
195 * @counter: 讀取/寫(xiě)入的字節(jié)計(jì)數(shù)器；
196 *
197 */
198 #define _my_read_asn1_valb(pfd, val, len, counter) \
199 _my_read_sv_bytes((pfd), (val), (len), counter);
200 #define _my_write_asn1_valb(pfd, val, len, counter) \
201 _my_write_sv_bytes((pfd), (val), (len), counter);
202
203
204 /*
205 * read_svpdu_lpdu_head - 取得鏈路層svpdu報(bào)文頭部信息,沒(méi)有讀到的數(shù)據(jù)為其原來(lái)的值
206 * @pfd: 輸入輸出參數(shù)，地址
207 * @len: 輸入?yún)?shù)，數(shù)據(jù)緩沖區(qū)長(zhǎng)度；
208 * @head: 輸出參數(shù)，svpdu_lpdu_head值
209 * @counter: 輸出參數(shù)，讀取的字節(jié)計(jì)數(shù)器；
210 *
211 * 讀成功返回當(dāng)前讀pfd地址，否則返回NULL；
212 *
213 */
214 _my_svpdu_ioptr read_svpdu_lpdu_head(_my_svpdu_ioptr pfd, int len, struct svpdu_lpdu_head *head, int *counter)
215 {
216 _my_svpdu_ioptr curr_pfd = pfd;
217
218 _my_assert(curr_pfd && head);
219
220 _my_assert( len > sizeof(struct svpdu_lpdu_head)); /* 最小長(zhǎng)度應(yīng)該大于 26 個(gè)字節(jié)，從協(xié)議計(jì)算*/
221 _my_read_sv_bytes(curr_pfd, head->des_mac, 6, *counter);
222 _my_read_sv_bytes(curr_pfd, head->src_mac, 6, *counter);
223 _my_read_asn1_valn(curr_pfd, head->tpid, 2, *counter);
224 if (head->tpid != SVPDU_LPDU_TPID_VLAN) { /* 有的報(bào)文里面沒(méi)有tpid和tci字段 不能比較 */
225 head->ether_type = head->tpid;
226 }
227 else {
228 _my_read_asn1_valn(curr_pfd, head->tci, 2, *counter);
229 _my_read_asn1_valn(curr_pfd, head->ether_type, 2, *counter);
230 }
231 _my_read_asn1_valn(curr_pfd, head->appid, 2, *counter);
232 _my_read_asn1_valn(curr_pfd, head->epdu_length, 2, *counter);
233 _my_read_asn1_valn(curr_pfd, head->reserve1, 2, *counter);
234 _my_read_asn1_valn(curr_pfd, head->reserve2, 2, *counter);
235
236 return curr_pfd;
237 }
238
239
240 /*
241 * read_svpdu_apdu_head - 取得svpdu報(bào)文中apdu頭部信息,沒(méi)有讀到的數(shù)據(jù)為其原來(lái)的值
242 * @pfd: 輸入輸出參數(shù)，地址
243 * @len: 輸入?yún)?shù)，數(shù)據(jù)緩沖區(qū)長(zhǎng)度；
244 * @head: 輸出參數(shù)，svpdu_lpdu_head值
245 * @counter: 輸出參數(shù)，讀取的字節(jié)計(jì)數(shù)器；
246 *
247 * 讀成功返回當(dāng)前讀pfd地址，否則返回NULL；
248 *
249 */
250 _my_svpdu_ioptr read_svpdu_apdu_head(_my_svpdu_ioptr pfd, int len, struct svpdu_apdu_head *head, int *counter)
251 {
252 u8 curr_tag = 0;
253 u32 curr_len = 0;
254 u32 index = 0;
255
256 _my_svpdu_ioptr curr_pfd = pfd;
257
258 _my_assert(curr_pfd && head);
259
260 _my_read_asn1_tag8(curr_pfd, head->apdu_tag, *counter);
261 _my_read_asn1_length(curr_pfd, head->apdu_length, *counter);
262 if (head->apdu_tag == SVPDU_APDU_TAG_91) {
263 _my_read_asn1_valn(curr_pfd, head->asdu_num_value, 2, *counter);
264 return curr_pfd;
265 }
266 else if (head->apdu_tag == SVPDU_APDU_TAG_92) {
267 for (index = 0; index < 3; index++) { /* 最多讀三遍，一般沒(méi)有SVPDU_SECURITY_TAG_92 */
268 _my_read_asn1_tag8(curr_pfd, curr_tag, *counter);
269 _my_read_asn1_length(curr_pfd, curr_len, *counter);
270 if (curr_tag == SVPDU_ASDUNUM_TAG_92) {
271 head->asdu_num_tag = curr_tag;
272 head->asdu_num_length = curr_len;
273 _my_read_asn1_valn(curr_pfd, head->asdu_num_value, curr_len, *counter);
274 }
275 else if (curr_tag == SVPDU_SECURITY_TAG_92) {
276 head->asdu_security_tag = curr_tag;
277 head->asdu_security_length = curr_len;
278 }
279 else if (curr_tag == SVPDU_SEQUENCE_TAG_92) {
280 head->asdu_sequence_tag = curr_tag;
281 head->asdu_sequence_length = curr_len;
282 break;
283 }
284 else {
285 _my_warn_info(1, "WARN: read unknown svpdu apdu head tag");
286 break;
287 }
288 }
289 return curr_pfd;
290 }
291 else {
292 _my_warn_info(1, "WARN: not a 9-1/9-2 packet ");
293 return 0;
294 }
295 }
296
297
298
299 /*
300 * read_svpdu_asdu_dat92 - 讀取9-2-asdu詳細(xì)值；
301 * @pfd: 輸入輸出參數(shù)，地址
302 * @len: 輸入?yún)?shù)，數(shù)據(jù)緩沖區(qū)長(zhǎng)度；
303 * @dat92: 輸出參數(shù)，asdu詳細(xì)值；
304 * @smpquality_enable: 是否有質(zhì)量信息;
305 * @counter: 輸出參數(shù)，讀取的字節(jié)計(jì)數(shù)器；
306 *
307 * 讀成功返回當(dāng)前讀pfd地址，否則返回NULL；
308 *
309 * 讀取過(guò)程中可能會(huì)利用動(dòng)態(tài)創(chuàng)建空間以保存svid_value、datset_value、smpdata_values、smpdata_qualitys數(shù)據(jù)；
310 *
311 */
312 _my_svpdu_ioptr read_svpdu_asdu_dat92(_my_svpdu_ioptr pfd, int len, struct svpdu_asdu_dat92 *dat92, int smpquality_enable, int *counter)
313 {
314 _my_svpdu_ioptr curr_pfd = pfd;
315
316 int begn_pos = 0;
317 u8 curr_tag = 0;
318 u32 curr_len = 0;
319 u32 index = 0;
320 u32 sizebuf = 0;
321 u8 succ_flag = 1;
322
323 _my_assert(curr_pfd && dat92);
324
325 _my_read_asn1_tag8(curr_pfd, dat92->asdu_tag, *counter);
326 _my_read_asn1_length(curr_pfd, dat92->asdu_length, *counter);
327
328 begn_pos = *counter;
329
330 if (dat92->asdu_tag != SVPDU_ASDU_TAG_92) {
331 _my_warn_info(1, "WARN: not a 9-2 asdu packet ");
332 return 0;
333 }
334
335 while ((u32)((*counter) - begn_pos) < dat92->asdu_length) {
336 _my_read_asn1_tag8(curr_pfd, curr_tag, *counter);
337 _my_read_asn1_length(curr_pfd, curr_len, *counter);
338 switch (curr_tag) {
339 case SVPDU_ASDU_SVID_TAG_92 :
340 dat92->svid_tag = curr_tag;
341 dat92->svid_length = curr_len;
342 if (dat92->svid_value != NULL) {
343 _my_buf_free(dat92->svid_value);
344 dat92->svid_value = NULL;
345 }
346 if (curr_len > 0) {
347 sizebuf = curr_len + 1;
348 dat92->svid_value = _my_buf_malloc(sizebuf);
349 memset(dat92->svid_value, 0, sizebuf);
350 _my_read_asn1_valb(curr_pfd, dat92->svid_value, curr_len, *counter);
351 }
352 break;
353 case SVPDU_ASDU_DATSET_TAG_92 :
354 dat92->datset_tag = curr_tag;
355 dat92->datset_length = curr_len;
356 if (dat92->datset_value != NULL) {
357 _my_buf_free(dat92->datset_value);
358 dat92->datset_value = NULL;
359 }
360 if (curr_len > 0) {
361 sizebuf = curr_len + 1;
362 dat92->datset_value = _my_buf_malloc(sizebuf);
363 memset(dat92->datset_value, 0, sizebuf);
364 _my_read_asn1_valb(curr_pfd, dat92->datset_value, curr_len, *counter);
365 }
366 break;
367 case SVPDU_ASDU_SMPCNT_TAG_92 :
368 dat92->smpcnt_tag = curr_tag;
369 dat92->smpcnt_length = curr_len;
370 _my_read_asn1_valn(curr_pfd, dat92->smpcnt_value, curr_len, *counter);
371 break;
372 case SVPDU_ASDU_CONFREV_TAG_92 :
373 dat92->confrev_tag = curr_tag;
374 dat92->confrev_length = curr_len;
375 _my_read_asn1_valn(curr_pfd, dat92->confrev_value, curr_len, *counter);
376 break;
377 case SVPDU_ASDU_REFRTM_TAG_92 :
378 dat92->refrtm_tag = curr_tag;
379 dat92->refrtm_length = curr_len;
380 _my_read_asn1_valn(curr_pfd, dat92->refrtm_value, curr_len, *counter);
381 break;
382 case SVPDU_ASDU_SMPSYNCH_TAG_92 :
383 dat92->smpsynch_tag = curr_tag;
384 dat92->smpsynch_length = curr_len;
385 _my_read_asn1_valn(curr_pfd, dat92->smpsynch_value, curr_len, *counter);
386 break;
387 case SVPDU_ASDU_SMPRATE_TAG_92 :
388 dat92->smprate_tag = curr_tag;
389 dat92->smprate_length = curr_len;
390 _my_read_asn1_valn(curr_pfd, dat92->smprate_value, curr_len, *counter);
391 break;
392 case SVPDU_ASDU_SMPDATA_TAG_92 :
393 dat92->smpdata_tag = curr_tag;
394 dat92->smpdata_length = curr_len;
395 dat92->smpdata_portnum = (u16)(curr_len / (smpquality_enable ? 8 : 4));
396 if (dat92->smpdata_values != NULL) {
397 _my_buf_free(dat92->smpdata_values);
398 dat92->smpdata_values = NULL;
399 }
400 if (dat92->smpdata_qualitys != NULL) {
401 _my_buf_free(dat92->smpdata_qualitys);
402 dat92->smpdata_qualitys = NULL;
403 }
404 if (dat92->smpdata_portnum > 0) {
405 sizebuf = dat92->smpdata_portnum * sizeof(s32);
406 dat92->smpdata_values = _my_buf_malloc(sizebuf);
407 memset(dat92->smpdata_values, 0, sizebuf);
408 dat92->smpdata_qualitys = _my_buf_malloc(sizebuf);
409 memset(dat92->smpdata_qualitys, 0, sizebuf);
410 }
411 for (index = 0; (index < dat92->smpdata_portnum); index++) {
412 _my_read_asn1_valn(curr_pfd, dat92->smpdata_values[index], 4, *counter);
413 _my_read_asn1_valn(curr_pfd, dat92->smpdata_qualitys[index], 4, *counter);
414 }
415 break;
416 default:
417 _my_warn_info(1, "WARN: not a 9-1/9-2 asdu item packet ");
418 succ_flag = 0;
419 break;
420 }
421 }
422
423 return succ_flag ? curr_pfd : 0;
424 }
425
426
427 /*
428 * init_svpdu_asdu_dat92 - 初始化Dat92結(jié)構(gòu)體；
429 * @dat92: 輸入輸出參數(shù)，asdu詳細(xì)值；
430 * @setdefaultval: 參數(shù)是否賦默認(rèn)值；
431 *
432 * 初始化成功返回當(dāng)前dat92結(jié)構(gòu)體地址，否則返回NULL；
433 *
434 */
435 struct svpdu_asdu_dat92 * init_svpdu_asdu_dat92(struct svpdu_asdu_dat92 *dat92, int setdefaultval)
436 {
437 struct svpdu_asdu_dat92 *dat = dat92;
438
439 if (dat == NULL) {
440 dat = (struct svpdu_asdu_dat92 *)_my_buf_malloc(sizeof(struct svpdu_asdu_dat92));
441 dat->svid_value = NULL;
442 dat->datset_value = NULL;
443 dat->smpdata_values = NULL;
444 dat->smpdata_qualitys = NULL;
445 }
446
447 memset(dat, 0, sizeof(struct svpdu_asdu_dat92));
448 if (dat->svid_value != NULL) {
449 _my_buf_free(dat->svid_value);
450 dat->svid_value = NULL;
451 }
452 if (dat->datset_value != NULL) {
453 _my_buf_free(dat->datset_value);
454 dat->datset_value = NULL;
455 }
456 if (dat->smpdata_values != NULL) {
457 _my_buf_free(dat->smpdata_values);
458 dat->smpdata_values = NULL;
459 }
460 if (dat->smpdata_qualitys != NULL) {
461 _my_buf_free(dat->smpdata_qualitys);
462 dat->smpdata_qualitys = NULL;
463 }
464
465 if (setdefaultval) {
466 dat->asdu_tag = SVPDU_ASDU_TAG_92;
467 dat->svid_tag = SVPDU_ASDU_SVID_TAG_92;
468 dat->datset_tag = SVPDU_ASDU_DATSET_TAG_92;
469 dat->smpcnt_tag = SVPDU_ASDU_SMPCNT_TAG_92;
470 dat->confrev_tag = SVPDU_ASDU_CONFREV_TAG_92;
471 dat->refrtm_tag = SVPDU_ASDU_REFRTM_TAG_92;
472 dat->smpsynch_tag = SVPDU_ASDU_SMPSYNCH_TAG_92;
473 dat->smprate_tag = SVPDU_ASDU_SMPRATE_TAG_92;
474 dat->smpdata_tag = SVPDU_ASDU_SMPDATA_TAG_92;
475 }
476
477 return dat;
478 }
479
480 /*
481 * free_svpdu_asdu_dat92 - 釋放Dat92結(jié)構(gòu)體；
482 * @dat92: 輸入輸出參數(shù)，asdu詳細(xì)值；
483 *
484 * 初始化成功返回返回NULL,否則返回當(dāng)前dat92結(jié)構(gòu)體地址；
485 *
486 */
487 struct svpdu_asdu_dat92 * free_svpdu_asdu_dat92(struct svpdu_asdu_dat92 *dat92)
488 {
489 struct svpdu_asdu_dat92 *dat = dat92;
490
491 if (dat != NULL) {
492 if (dat->svid_value != NULL) {
493 _my_buf_free(dat->svid_value);
494 dat->svid_value = NULL;
495 }
496 if (dat->datset_value != NULL) {
497 _my_buf_free(dat->datset_value);
498 dat->datset_value = NULL;
499 }
500 if (dat->smpdata_values != NULL) {
501 _my_buf_free(dat->smpdata_values);
502 dat->smpdata_values = NULL;
503 }
504 if (dat->smpdata_qualitys != NULL) {
505 _my_buf_free(dat->smpdata_qualitys);
506 dat->smpdata_qualitys = NULL;
507 }
508 _my_buf_free(dat);
509 dat = NULL;
510 }
511
512 return dat;
513 }
514
515
516
517
518 /*
519 * read_svpdu_asdu_dat91 - 讀取9-1-asdu詳細(xì)值；
520 * @pfd: 輸入輸出參數(shù)，地址
521 * @len: 輸入?yún)?shù)，數(shù)據(jù)緩沖區(qū)長(zhǎng)度；
522 * @dat91: 輸出參數(shù)，asdu詳細(xì)值；
523 * @counter: 輸出參數(shù)，讀取的字節(jié)計(jì)數(shù)器；
524 *
525 * 讀成功返回當(dāng)前讀pfd地址，否則返回NULL；
526 *
527 * 讀取過(guò)程中可能會(huì)利用動(dòng)態(tài)創(chuàng)建空間以保存smpdata_values數(shù)據(jù)；
528 *
529 */
530 _my_svpdu_ioptr read_svpdu_asdu_dat91(_my_svpdu_ioptr pfd, int len, struct svpdu_asdu_dat91 *dat91, int *counter)
531 {
532 _my_svpdu_ioptr curr_pfd = pfd;
533
534 u32 index = 0;
535 u32 sizebuf = 0;
536
537 _my_assert(curr_pfd && dat91);
538
539 _my_read_asn1_valn(curr_pfd, dat91->asdu_length, 2, *counter);
540
541 _my_assert(dat91->smpdata_portnum >= 20);
542
543 _my_read_asn1_valn(curr_pfd, dat91->ln_name, 1, *counter);
544 _my_read_asn1_valn(curr_pfd, dat91->dataset_name, 1, *counter);
545 _my_read_asn1_valn(curr_pfd, dat91->ld_name, 2, *counter);
546 _my_read_asn1_valn(curr_pfd, dat91->i_pp, 2, *counter);
547 _my_read_asn1_valn(curr_pfd, dat91->i_p0, 2, *counter);
548 _my_read_asn1_valn(curr_pfd, dat91->u_pp, 2, *counter);
549 _my_read_asn1_valn(curr_pfd, dat91->t_delay, 2, *counter);
550
551 dat91->smpdata_portnum = (dat91->asdu_length - 20) / 2;
552
553 _my_assert(dat91->smpdata_portnum >= 0);
554
555 if (dat91->smpdata_values != NULL) {
556 _my_buf_free(dat91->smpdata_values);
557 dat91->smpdata_values = NULL;
558 }
559 if (dat91->smpdata_portnum > 0) {
560 sizebuf = dat91->smpdata_portnum * sizeof(s16);
561 dat91->smpdata_values = _my_buf_malloc(sizebuf);
562 memset(dat91->smpdata_values, 0, sizebuf);
563 }
564
565 for (index=0; index<dat91->smpdata_portnum; index++) {
566 _my_read_asn1_valn(curr_pfd, dat91->smpdata_values[index], 2, *counter);
567 }
568
569 _my_read_asn1_valn(curr_pfd, dat91->status_word1, 2, *counter);
570 _my_read_asn1_valn(curr_pfd, dat91->status_word2, 2, *counter);
571 _my_read_asn1_valn(curr_pfd, dat91->smp_cnt, 2, *counter);
572 _my_read_asn1_valn(curr_pfd, dat91->smp_rate, 1, *counter);
573 _my_read_asn1_valn(curr_pfd, dat91->version, 1, *counter);
574
575 return curr_pfd;
576 }
577
578 /*
579 * init_svpdu_asdu_dat91 - 初始化Dat91結(jié)構(gòu)體；
580 * @dat92: 輸入輸出參數(shù)，asdu詳細(xì)值；
581 *
582 * 初始化成功返回當(dāng)前dat91結(jié)構(gòu)體地址，否則返回NULL；
583 *
584 */
585 struct svpdu_asdu_dat91 * init_svpdu_asdu_dat91(struct svpdu_asdu_dat91 *dat91)
586 {
587 struct svpdu_asdu_dat91 *dat = dat91;
588
589 if (dat == NULL) {
590 dat = (struct svpdu_asdu_dat91 *)_my_buf_malloc(sizeof(struct svpdu_asdu_dat91));
591 dat->smpdata_values = NULL;
592 }
593
594 memset(dat, 0, sizeof(struct svpdu_asdu_dat91));
595 if (dat->smpdata_values != NULL) {
596 _my_buf_free(dat->smpdata_values);
597 dat->smpdata_values = NULL;
598 }
599
600 return dat;
601 }
602
603 /*
604 * free_svpdu_asdu_dat91 - 釋放Dat91結(jié)構(gòu)體；
605 * @dat91: 輸入輸出參數(shù)，asdu詳細(xì)值；
606 *
607 * 初始化成功返回返回NULL,否則返回當(dāng)前dat91結(jié)構(gòu)體地址；
608 *
609 */
610 struct svpdu_asdu_dat91 * free_svpdu_asdu_dat91(struct svpdu_asdu_dat91 *dat91)
611 {
612 struct svpdu_asdu_dat91 *dat = dat91;
613
614 if (dat != NULL) {
615 if (dat->smpdata_values != NULL) {
616 _my_buf_free(dat->smpdata_values);
617 dat->smpdata_values = NULL;
618 }
619 _my_buf_free(dat);
620 dat = NULL;
621 }
622
623 return dat;
624 }
625
626
627
628
629 /*
630 * write_svpdu_lpdu_head - 寫(xiě)svpdu_lpdu_head到文件中
631 * @pfd: 輸入?yún)?shù)，寫(xiě)地址;
632 * @head：輸入?yún)?shù)，svpdu_lpdu_head結(jié)構(gòu)體；
633 * @counter: 輸出參數(shù)，成功寫(xiě)入的字節(jié)個(gè)數(shù)；
634 *
635 * 返回當(dāng)前pfd指針,寫(xiě)失敗返回NULL
636 *
637 */
638 _my_svpdu_ioptr write_svpdu_lpdu_head(_my_svpdu_ioptr pfd, struct svpdu_lpdu_head *head, int *counter)
639 {
640 _my_svpdu_ioptr curr_pfd = pfd;
641
642 _my_assert(curr_pfd && head);
643
644 _my_write_sv_bytes(curr_pfd, head->des_mac, 6, *counter);
645 _my_write_sv_bytes(curr_pfd, head->src_mac, 6, *counter);
646 _my_write_asn1_valn(curr_pfd, (u32)(head->tpid), 2, *counter);
647 _my_write_asn1_valn(curr_pfd, (u32)(head->tci), 2, *counter);
648 _my_write_asn1_valn(curr_pfd, (u32)(head->ether_type), 2, *counter);
649 _my_write_asn1_valn(curr_pfd, (u32)(head->appid), 2, *counter);
650 _my_write_asn1_valn(curr_pfd, (u32)(head->epdu_length), 2, *counter);
651 _my_write_asn1_valn(curr_pfd, (u32)(head->reserve1), 2, *counter);
652 _my_write_asn1_valn(curr_pfd, (u32)(head->reserve1), 2, *counter);
653
654 return curr_pfd;
655 }
656
657
658
659 /*
660 * write_svpdu_apdu_head - 寫(xiě)svpdu_apdu_head到文件中
661 * @pfd: 輸入?yún)?shù)，寫(xiě)地址;
662 * @head：輸入?yún)?shù)，svpdu_apdu_head結(jié)構(gòu)體；
663 * @counter: 輸出參數(shù)，成功寫(xiě)入的字節(jié)個(gè)數(shù)；
664 *
665 * 返回當(dāng)前pfd指針,寫(xiě)失敗返回NULL
666 *
667 */
668 _my_svpdu_ioptr write_svpdu_apdu_head(_my_svpdu_ioptr pfd, struct svpdu_apdu_head *head, int *counter)
669 {
670 _my_svpdu_ioptr curr_pfd = pfd;
671
672 _my_assert(curr_pfd && head);
673
674 _my_write_asn1_tag8(curr_pfd, head->apdu_tag, *counter);
675 _my_write_asn1_length(curr_pfd, head->apdu_length, *counter);
676
677 if (head->apdu_tag == SVPDU_APDU_TAG_92){
678 _my_write_asn1_tag8(curr_pfd, head->asdu_num_tag, *counter);
679 _my_write_asn1_length(curr_pfd, head->asdu_num_length, *counter);
680 }
681 _my_write_asn1_valn(curr_pfd, (u32)(head->asdu_num_value), 2, *counter);
682
683 if (head->apdu_tag == SVPDU_APDU_TAG_92){
684 if (head->asdu_security_tag != 0x00) {
685 _my_write_asn1_tag8(curr_pfd, head->asdu_security_tag, *counter);
686 _my_write_asn1_length(curr_pfd, head->asdu_security_length, *counter);
687 }
688 if (head->asdu_sequence_tag != 0x00) {
689 _my_write_asn1_tag8(curr_pfd, head->asdu_sequence_tag, *counter);
690 _my_write_asn1_length(curr_pfd, head->asdu_sequence_length, *counter);
691 }
692 }
693
694 return curr_pfd;
695 }
696
697
698 /*
699 * write_svpdu_asdu_dat92 - 寫(xiě)svpdu_asdu_dat92到文件中
700 * @pfd: 輸入?yún)?shù)，寫(xiě)地址;
701 * @dat92：輸入?yún)?shù)，svpdu_asdu_dat92結(jié)構(gòu)體；
702 * @counter: 輸出參數(shù)，成功寫(xiě)入的字節(jié)個(gè)數(shù)；
703 *
704 * 返回當(dāng)前pfd指針,寫(xiě)失敗返回NULL
705 *
706 */
707 _my_svpdu_ioptr write_svpdu_asdu_dat92(_my_svpdu_ioptr pfd, struct svpdu_asdu_dat92 *dat92, int *counter)
708 {
709 _my_svpdu_ioptr curr_pfd = pfd;
710
711 u32 index = 0;
712
713 _my_assert(curr_pfd && dat92);
714
715 _my_write_asn1_tag8(curr_pfd, dat92->asdu_tag, *counter);
716 _my_write_asn1_length(curr_pfd, dat92->asdu_length, *counter);
717
718 if (dat92->svid_tag == SVPDU_ASDU_SVID_TAG_92) {
719 _my_write_asn1_tag8(curr_pfd, dat92->svid_tag, *counter);
720 _my_write_asn1_length(curr_pfd, dat92->svid_length, *counter);
721 _my_write_asn1_valb(curr_pfd, dat92->svid_value, dat92->svid_length, *counter);
722 }
723 if (dat92->datset_tag == SVPDU_ASDU_DATSET_TAG_92) {
724 _my_write_asn1_tag8(curr_pfd, dat92->datset_tag, *counter);
725 _my_write_asn1_length(curr_pfd, dat92->datset_length, *counter);
726 _my_write_asn1_valb(curr_pfd, dat92->datset_value, dat92->datset_length, *counter);
727 }
728 if (dat92->smpcnt_tag == SVPDU_ASDU_SMPCNT_TAG_92) {
729 _my_write_asn1_tag8(curr_pfd, dat92->smpcnt_tag, *counter);
730 _my_write_asn1_length(curr_pfd, dat92->smpcnt_length, *counter);
731 _my_write_asn1_valn(curr_pfd, dat92->smpcnt_value, dat92->smpcnt_length, *counter);
732 }
733 if (dat92->confrev_tag == SVPDU_ASDU_CONFREV_TAG_92) {
734 _my_write_asn1_tag8(curr_pfd, dat92->confrev_tag, *counter);
735 _my_write_asn1_length(curr_pfd, dat92->confrev_length, *counter);
736 _my_write_asn1_valn(curr_pfd, dat92->confrev_value, dat92->confrev_length, *counter);
737 }
738 if (dat92->refrtm_tag == SVPDU_ASDU_REFRTM_TAG_92) {
739 _my_write_asn1_tag8(curr_pfd, dat92->refrtm_tag, *counter);
740 _my_write_asn1_length(curr_pfd, dat92->refrtm_length, *counter);
741 _my_write_asn1_valn(curr_pfd, dat92->refrtm_value, dat92->refrtm_length, *counter);
742 }
743 if (dat92->smpsynch_tag == SVPDU_ASDU_SMPSYNCH_TAG_92) {
744 _my_write_asn1_tag8(curr_pfd, dat92->refrtm_tag, *counter);
745 _my_write_asn1_length(curr_pfd, dat92->smpsynch_length, *counter);
746 _my_write_asn1_valn(curr_pfd, dat92->smpsynch_value, dat92->smpsynch_length, *counter);
747 }
748 if (dat92->smprate_tag == SVPDU_ASDU_SMPRATE_TAG_92) {
749 _my_write_asn1_tag8(curr_pfd, dat92->smprate_tag, *counter);
750 _my_write_asn1_length(curr_pfd, dat92->smprate_length, *counter);
751 _my_write_asn1_valn(curr_pfd, dat92->smprate_value, dat92->smprate_length, *counter);
752 }
753 if (dat92->smpdata_tag == SVPDU_ASDU_SMPDATA_TAG_92) {
754 _my_write_asn1_tag8(curr_pfd, dat92->smpdata_tag, *counter);
755 _my_write_asn1_length(curr_pfd, dat92->smpdata_length, *counter);
756 for (index = 0; (index < dat92->smpdata_portnum); index++) {
757 _my_write_asn1_valn(curr_pfd, dat92->smpdata_values[index], 4, *counter);
758 _my_write_asn1_valn(curr_pfd, dat92->smpdata_qualitys[index], 4, *counter);
759 }
760 }
761
762 return curr_pfd;
763 }
764
765
766 /*
767 * write_svpdu_asdu_dat91 - 寫(xiě)svpdu_asdu_dat91到文件中
768 * @pfd: 輸入?yún)?shù)，寫(xiě)地址;
769 * @dat91：輸入?yún)?shù)，svpdu_asdu_dat91結(jié)構(gòu)體；
770 * @counter: 輸出參數(shù)，成功寫(xiě)入的字節(jié)個(gè)數(shù)；
771 *
772 * 返回當(dāng)前pfd指針,寫(xiě)失敗返回NULL
773 *
774 */
775 _my_svpdu_ioptr write_svpdu_asdu_dat91(_my_svpdu_ioptr pfd, struct svpdu_asdu_dat91 *dat91, int *counter)
776 {
777 _my_svpdu_ioptr curr_pfd = pfd;
778
779 u32 index = 0;
780
781 _my_assert(curr_pfd && dat91);
782
783 _my_write_asn1_valn(curr_pfd, dat91->asdu_length, 2, *counter);
784 _my_write_asn1_valn(curr_pfd, dat91->ln_name, 1, *counter);
785 _my_write_asn1_valn(curr_pfd, dat91->dataset_name, 1, *counter);
786 _my_write_asn1_valn(curr_pfd, dat91->ld_name, 2, *counter);
787 _my_write_asn1_valn(curr_pfd, dat91->i_pp, 2, *counter);
788 _my_write_asn1_valn(curr_pfd, dat91->i_p0, 2, *counter);
789 _my_write_asn1_valn(curr_pfd, dat91->u_pp, 2, *counter);
790 _my_write_asn1_valn(curr_pfd, dat91->t_delay, 2, *counter);
791 for (index = 0; (index < dat91->smpdata_portnum); index++) {
792 _my_write_asn1_valn(curr_pfd, dat91->smpdata_values[index], 2, *counter);
793 }
794 _my_write_asn1_valn(curr_pfd, dat91->status_word1, 2, *counter);
795 _my_write_asn1_valn(curr_pfd, dat91->status_word2, 2, *counter);
796 _my_write_asn1_valn(curr_pfd, dat91->smp_cnt, 2, *counter);
797 _my_write_asn1_valn(curr_pfd, dat91->smp_rate, 1, *counter);
798 _my_write_asn1_valn(curr_pfd, dat91->version, 1, *counter);
799
800 return curr_pfd;
801 }
802
803 /*
804 * print_svpdu_lpdu_head - 打印數(shù)據(jù)
805 * @head: 數(shù)據(jù)包
806 *
807 */
808 void print_svpdu_lpdu_head(struct svpdu_lpdu_head * head) {
809 if ( head ) {
810 _my_printf("========= svpdu_lpdu_head ============\n");
811 _my_printf("des_mac:%02X:%02X:%02X:%02X:%02X:%02X\n",
812 head->des_mac[0], head->des_mac[1], head->des_mac[2],
813 head->des_mac[3], head->des_mac[4], head->des_mac[5]);
814 _my_printf("src_mac:%02X:%02X:%02X:%02X:%02X:%02X\n",
815 head->src_mac[0], head->src_mac[1], head->src_mac[2],
816 head->src_mac[3], head->src_mac[4], head->src_mac[5]);
817 _my_printf("tpid:%u [0x%04X]\n", head->tpid, head->tpid);
818 _my_printf("tci:%u [0x%04X]\n", head->tci, head->tci);
819 _my_printf("ether_type:%u [0x%04X]\n", head->ether_type, head->ether_type);
820 _my_printf("appid:%u [0x%04X]\n", head->appid, head->appid);
821 _my_printf("epdu_length:%u [0x%04X]\n", head->epdu_length, head->epdu_length);
822 _my_printf("reserve1:%u [0x%04X]\n", head->reserve1, head->reserve1);
823 _my_printf("reserve2:%u [0x%04X]\n", head->reserve2, head->reserve2);
824 _my_printf("=====================\n");
825 }
826 }
827
828 /*
829 * print_svpdu_apdu_head - 打印數(shù)據(jù)
830 * @head: 數(shù)據(jù)包
831 *
832 */
833 void print_svpdu_apdu_head(struct svpdu_apdu_head* head) {
834 if ( head ) {
835 _my_printf("========= svpdu_apdu_head ============\n");
836 _my_printf("apdu_tag:%u [0x%02X]\n", head->apdu_tag, head->apdu_tag);
837 _my_printf("apdu_length:%u [0x%08X]\n", head->apdu_length, head->apdu_length);
838 _my_printf("asdu_num_tag:%u [0x%02X]\n", head->asdu_num_tag, head->asdu_num_tag);
839 _my_printf("asdu_num_length:%u [0x%08X]\n", head->asdu_num_length, head->asdu_num_length);
840 _my_printf("asdu_num_value:%u [0x%04X]\n", head->asdu_num_value, head->asdu_num_value);
841 _my_printf("asdu_security_tag:%u [0x%02X]\n", head->asdu_security_tag, head->asdu_security_tag);
842 _my_printf("asdu_security_length:%u [0x%08X]\n", head->asdu_security_length, head->asdu_security_length);
843 _my_printf("asdu_sequence_tag:%u [0x%02X]\n", head->asdu_sequence_tag, head->asdu_sequence_tag);
844 _my_printf("asdu_sequence_length:%u [0x%08X]\n", head->asdu_sequence_length, head->asdu_sequence_length);
845 _my_printf("=====================\n");
846 }
847 }
848
849 /*
850 * print_svpdu_asdu_dat92 - 打印數(shù)據(jù)
851 * @dat92: 數(shù)據(jù)包
852 * @smpquality_enable: 是否包含質(zhì)量信息
853 *
854 */
855 void print_svpdu_asdu_dat92(struct svpdu_asdu_dat92* dat92, u8 smpquality_enable){
856 u32 index = 0;
857 if ( dat92 ) {
858 _my_printf("========= svpdu_asdu_dat92 ============\n");
859 _my_printf("asdu_tag:%u [0x%02X]\n", dat92->asdu_tag, dat92->asdu_tag);
860 _my_printf("asdu_length:%u [0x%08X]\n", dat92->asdu_length, dat92->asdu_length);
861 _my_printf("svid_tag:%u [0x%02X]\n", dat92->svid_tag, dat92->svid_tag);
862 _my_printf("svid_length:%u [0x%08X]\n", dat92->svid_length, dat92->svid_length);
863 _my_printf("svid_value:\n");
864 for (index = 0; index < dat92->svid_length; index++) {
865 if ((index % 16) == 0) {
866 _my_printf("\n");
867 }
868 _my_printf("%02X ", dat92->svid_value[index]);
869 }
870 _my_printf("\n");
871 _my_printf("datset_tag:%u [0x%02X]\n", dat92->datset_tag, dat92->datset_tag);
872 _my_printf("datset_length:%u [0x%08X]\n", dat92->datset_length, dat92->datset_length);
873 _my_printf("datset_value:\n");
874 for (index = 0; index < dat92->datset_length; index++) {
875 if ((index % 16) == 0) {
876 _my_printf("\n");
877 }
878 _my_printf("%02X ", dat92->datset_value[index]);
879 }
880 _my_printf("\n");
881 _my_printf("smpcnt_tag:%u [0x%02X]\n", dat92->smpcnt_tag, dat92->smpcnt_tag);
882 _my_printf("smpcnt_length:%u [0x%08X]\n", dat92->smpcnt_length, dat92->smpcnt_length);
883 _my_printf("smpcnt_value:%u [0x%04X]\n", dat92->smpcnt_value, dat92->smpcnt_value);
884 _my_printf("confrev_tag:%u [0x%02X]\n", dat92->confrev_tag, dat92->confrev_tag);
885 _my_printf("confrev_length:%u [0x%08X]\n", dat92->confrev_length, dat92->confrev_length);
886 _my_printf("confrev_value:%u [0x%08X]\n", dat92->confrev_value, dat92->confrev_value);
887 _my_printf("refrtm_tag:%u [0x%02X]\n", dat92->refrtm_tag, dat92->refrtm_tag);
888 _my_printf("refrtm_length:%u [0x%08X]\n", dat92->refrtm_length, dat92->refrtm_length);
889 _my_printf("refrtm_value:%u [0x%08X]\n", dat92->refrtm_value, dat92->refrtm_value);
890 _my_printf("smpsynch_tag:%u [0x%02X]\n", dat92->smpsynch_tag, dat92->smpsynch_tag);
891 _my_printf("smpsynch_length:%u [0x%08X]\n", dat92->smpsynch_length, dat92->smpsynch_length);
892 _my_printf("smpsynch_tag:%u [0x%02X]\n", dat92->smpsynch_tag, dat92->smpsynch_tag);
893 _my_printf("smprate_tag:%u [0x%02X]\n", dat92->smprate_tag, dat92->smprate_tag);
894 _my_printf("smprate_length:%u [0x%08X]\n", dat92->smprate_length, dat92->smprate_length);
895 _my_printf("smprate_value:%u [0x%04X]\n", dat92->smprate_value, dat92->smprate_value);
896 _my_printf("smpdata_tag:%u [0x%02X]\n", dat92->smpdata_tag, dat92->smpdata_tag);
897 _my_printf("smpdata_length:%u [0x%08X]\n", dat92->smpdata_length, dat92->smpdata_length);
898 _my_printf("smpdata_portnum:%u [0x%04X]\n", dat92->smpdata_portnum, dat92->smpdata_portnum);
899 _my_printf("smpdata_values:\n");
900 for (index = 0; index < dat92->smpdata_portnum; index++) {
901 if ((index % 8) == 0) {
902 _my_printf("\n");
903 }
904 _my_printf("%d[%08X] %lf ",
905 dat92->smpdata_values[index],
906 dat92->smpdata_values[index],
907 (double)(dat92->smpdata_values[index]));
908 }
909 _my_printf("\n");
910 if (smpquality_enable) {
911 _my_printf("smpdata_qualitys:\n");
912 for (index = 0; index < dat92->smpdata_portnum; index++) {
913 if ((index % 8) == 0) {
914 _my_printf("\n");
915 }
916 _my_printf("%d[%08X] ", dat92->smpdata_qualitys[index], dat92->smpdata_qualitys[index]);
917 }
918 _my_printf("\n");
919 }
920 _my_printf("=====================\n");
921 }
922 }
923
924
925 /*
926 * print_svpdu_asdu_dat91 - 打印數(shù)據(jù)
927 * @dat92: 數(shù)據(jù)包
928 * @smpquality_enable: 是否包含質(zhì)量信息
929 *
930 */
931 void print_svpdu_asdu_dat91(struct svpdu_asdu_dat91* dat91){
932 u32 index = 0;
933 if ( dat91 ) {
934 _my_printf("========= svpdu_asdu_dat91 ============\n");
935 _my_printf("asdu_length:%u [0x%04X]\n", dat91->asdu_length, dat91->asdu_length);
936 _my_printf("ln_name:%u [0x%02X]\n", dat91->ln_name, dat91->ln_name);
937 _my_printf("dataset_name:%u [0x%04X]\n", dat91->dataset_name, dat91->dataset_name);
938 _my_printf("ld_name:%u [0x%04X]\n", dat91->ld_name, dat91->ld_name);
939 _my_printf("i_pp:%u [0x%04X]\n", dat91->i_pp, dat91->i_pp);
940 _my_printf("i_p0:%u [0x%04X]\n", dat91->i_p0, dat91->i_p0);
941 _my_printf("u_pp:%u [0x%04X]\n", dat91->u_pp, dat91->u_pp);
942 _my_printf("t_delay:%u [0x%04X]\n", dat91->t_delay, dat91->t_delay);
943 _my_printf("smpdata_portnum:%u [0x%04X]\n", dat91->smpdata_portnum, dat91->smpdata_portnum);
944 _my_printf("smpdata_values:\n");
945 for (index = 0; index < dat91->smpdata_portnum; index++) {
946 if ((index % 6) == 0) {
947 _my_printf("\n");
948 }
949 _my_printf("%d[%04X] ",
950 dat91->smpdata_values[index],
951 dat91->smpdata_values[index]);
952 }
953 _my_printf("\n");
954 _my_printf("status_word1:%u [0x%04X]\n", dat91->status_word1, dat91->status_word1);
955 _my_printf("status_word2:%u [0x%04X]\n", dat91->status_word2, dat91->status_word2);
956 _my_printf("smp_cnt:%u [0x%04X]\n", dat91->smp_cnt, dat91->smp_cnt);
957 _my_printf("smp_rate:%u [0x%02X]\n", dat91->smp_rate, dat91->smp_rate);
958 _my_printf("version:%u [0x%02X]\n", dat91->version, dat91->version);
959 _my_printf("=====================\n");
960 }
961 }
962
963
964 #ifdef IEC61850SV_CONSOLE_DEMO
965
966 #include "pcap_protocol.h"
967
968 /*
969 * _my_pcap_openrb/_my_pcap_openwb/_my_pcap_openab/_my_pcap_close
970 * - 可以根據(jù)需要改寫(xiě)該接口，如重定義為網(wǎng)口的recv\send、串口r\w等
971 * @pfd: 文件地址、緩沖區(qū)地址、或者socket地址等
972 * @str: 文件路徑或者聯(lián)機(jī)ip或者串口地址或者共享內(nèi)存名稱
973 *
974 */
975 #ifdef PCAP_IOFILE
976 #define _my_pcap_openrb(str) (open((str), O_RDONLY | O_BINARY, S_IWRITE | S_IREAD))
977 #define _my_pcap_openwb(str) (open((str), O_CREAT | O_RDWR | O_BINARY, S_IWRITE | S_IREAD))
978 #define _my_pcap_openab(str) (open((str), O_CREAT | O_APPEND | O_RDWR | O_BINARY, S_IWRITE | S_IREAD))
979 #define _my_pcap_close(pfd) (close(pfd))
980 #else /* 定義其他的io*/
981 #endif
982
983 /*
984 * i92p_test_demo1 - 測(cè)試函數(shù)
985 * @pcap_pathname: pcap文件路徑
986 * @packet_pathname: pcaket文件路徑
987 *
988 */
989 void i92p_test_demo1(const char* pcap_pathname, u8 smpquality_enable) {
990 int pckt_count = 0;
991 int read_count = 0;
992 u8* ppd = 0;
993 struct pcap_file_head pfh;
994 struct pcap_packet_head pph;
995
996 _my_svpdu_ioptr curr_pdf = 0;
997 int bgn_pos = 0;
998 int end_pos = 0;
999
1000 int index = 0;
1001 int count = 0;
1002
1003 char chget;
1004
1005 _my_pcap_ioptr fdpcap = 0;
1006
1007 struct svpdu_lpdu_head lpdu_head;
1008 struct svpdu_apdu_head apdu_head;
1009 struct svpdu_asdu_dat92 asdu_dat92;
1010
1011 fdpcap = _my_pcap_openrb(pcap_pathname);
1012 if ( fdpcap ) {
1013 fdpcap = read_pcap_head(fdpcap, &pfh, &read_count);
1014 if (0 != fdpcap) {
1015 _tprintf("press [s] to break, any other keys to show pcap file header data.....\n");
1016 chget = getchar();
1017 if (chget == 's') {
1018 _my_pcap_close(fdpcap);
1019 return;
1020 }
1021 print_pcap_head(&pfh);
1022 while (!(chget == 's')) {
1023 _tprintf("press [s] to break, any other keys to continue showing pcap packet header data......\n");
1024 chget = getchar();
1025 if (chget == 's') {
1026 break;
1027 }
1028 fdpcap = read_pcap_packet_head(fdpcap, &pph, pfh.magic, &read_count);
1029 if (0 != fdpcap) {
1030 pckt_count++;
1031 _tprintf("pcap data packet header count %d\n", pckt_count);
1032 print_pcap_packet_head(&pph);
1033 _tprintf("press [s] to break, any other keys to continue showing pcap packet content data.......\n");
1034 chget = getchar();
1035 if (chget == 's') {
1036 break;
1037 }
1038 ppd = (u8 *)_my_malloc((size_t)(pph.caplen));
1039 fdpcap = read_pcap_packet_data(fdpcap, ppd, pph.caplen, &read_count);
1040 if ( 0 != fdpcap) {
1041 print_pcap_packet_data(ppd, pph.caplen);
1042
1043 curr_pdf = (_my_i92p_rwptr)ppd;
1044 curr_pdf = read_svpdu_lpdu_head(curr_pdf, pph.caplen, &lpdu_head, &read_count);
1045 if (0 == curr_pdf) {
1046 _tprintf("press [s] to break, read error...\n");
1047 chget = getchar();
1048 if (chget == 's') {
1049 break;
1050 }
1051 }
1052 else {
1053 print_svpdu_lpdu_head(&lpdu_head);
1054 _tprintf("press [s] to break, any other keys to continue...\n");
1055 // chget = getchar();
1056 if (chget == 's') {
1057 break;
1058 }
1059 }
1060
1061 curr_pdf = read_svpdu_apdu_head(curr_pdf, pph.caplen, &apdu_head, &read_count);
1062 if (0 == curr_pdf) {
1063 _tprintf("press [s] to break, read error...\n");
1064 chget = getchar();
1065 if (chget == 's') {
1066 break;
1067 }
1068 }
1069 else {
1070 print_svpdu_apdu_head(&apdu_head);
1071 _tprintf("press [s] to break, any other keys to continue...\n");
1072 chget = getchar();
1073 if (chget == 's') {
1074 break;
1075 }
1076 }
1077
1078 for (index = 0; index<apdu_head.asdu_num_value; index ++) {
1079 _tprintf("read asdu_dat92 %d\n", index);
1080 init_svpdu_asdu_dat92(&asdu_dat92);
1081 curr_pdf = read_svpdu_asdu_dat92(curr_pdf, pph.caplen, &asdu_dat92, smpquality_enable, &read_count);
1082 if (0 == curr_pdf) {
1083 _tprintf("press [s] to break, read error...\n");
1084 chget = getchar();
1085 if (chget == 's') {
1086 break;
1087 }
1088 }
1089 else {
1090 print_svpdu_asdu_dat92(&asdu_dat92, smpquality_enable);
1091 _tprintf("press [s] to break, any other keys to continue...\n");
1092 chget = getchar();
1093 if (chget == 's') {
1094 break;
1095 }
1096 }
1097 }//*/
1098
1099 free(ppd);
1100 ppd = 0;
1101 continue;
1102 }
1103 free(ppd);
1104 ppd = 0;
1105 }
1106 break;
1107 }
1108 }
1109 _my_pcap_close(fdpcap);
1110 }
1111 }
1112
1113
1114 /*
1115 * i92p_test_demo2 - 測(cè)試函數(shù),創(chuàng)建9-2包，并且讀出來(lái)
1116 * @pcap_pathname: pcap文件路徑
1117 * @packet_pathname: pcaket文件路徑
1118 *
1119 */
1120 void i92p_test_demo2(const char* pcap_pathname, u8 smpquality_enable)
1121 {
1122 int index = 0;
1123
1124 pcap_head pfh;
1125 pcap_packet_head pph;
1126
1127 svpdu_lpdu_head lpduh;
1128 svpdu_apdu_head apduh;
1129 svpdu_asdu_dat92 asdu92;
1130
1131 init_svpdu_asdu_dat92(&asdu92, true);
1132
1133 /*
1134 asdu92->asdu_tag =
1135 for (intdex = 0;)
1136
1137 _my_pcap_ioptr fdpcap = 0;
1138
1139 fdpcap = _my_pcap_openwb(pcap_pathname);
1140
1141 _my_svpdu_ioptr curr_pdf = 0;
1142
1143
1144 int pckt_count = 0;
1145 int write_count = 0;
1146
1147
1148 u8* ppd = 0;
1149 pcap_head pfh;
1150 pcap_packet_head pph;
1151
1152 _my_svpdu_ioptr curr_pdf = 0;
1153 int bgn_pos = 0;
1154 int end_pos = 0;
1155
1156 int index = 0;
1157 int count = 0;
1158
1159 char chget;
1160
1161 _my_pcap_ioptr fdpcap = 0;
1162
1163 svpdu_lpdu_head lpdu_head;
1164 svpdu_apdu_head apdu_head;
1165 svpdu_asdu_dat92 asdu_dat92;
1166
1167 fdpcap = _my_pcap_openrb(pcap_pathname);
1168 if ( fdpcap ) {
1169 fdpcap = read_pcap_head(fdpcap, &pfh, &read_count);
1170 if (0 != fdpcap) {
1171 _tprintf("press [s] to break, any other keys to show pcap file header data.....\n");
1172 chget = getchar();
1173 if (chget == 's') {
1174 _my_pcap_close(fdpcap);
1175 return;
1176 }
1177 */
1178 }
1179
1180
1181 /*
1182 * main - 測(cè)試main函數(shù)
1183 *
1184 */
1185 int main(int argc, char* argv[]) {
1186 char pcap_pathname[255];
1187
1188 char chget;
1189
1190 u8 smpquality_enable = 1;
1191 // while (1) {
1192 memset(pcap_pathname, 0, 255);
1193 _tprintf("please input pacp file full path name:\n");
1194 //gets(pcap_pathname);
1195
1196 //i92p_test_demo(pcap_pathname, smpquality_enable);
1197 i92p_test_demo1("D:/KRTV2_KF900/9-2lubo/09160016", smpquality_enable);
1198 //i92p_test_demo("D:/1.pcap", smpquality_enable);
1199
1200 printf("press [s] to break,any other keys to continue end.\n");
1201 chget = getchar();
1202 if (chget == 's') {
1203 // break;
1204 }
1205 // }
1206
1207 return 0;
1208 }
1209
1210 #endif /* I92P_CONSOLE_DEMO */
?
轉(zhuǎn)載于:https://www.cnblogs.com/lizhi0755/archive/2013/05/23/3095960.html
總結(jié)
以上是生活随笔為你收集整理的iec61850采样协议（9-1、9-2）解析(二)的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。
- 上一篇： 方法描述Mybatis使用之NEIS项目
- 下一篇： 文字或者图片连续滚动