本项目中使用了Zigbee模块（DRF1609H），作为无线数据传输使用，初始化DRF1609H主要涉及以下几个方面的内容：
1，设置节点的类型，可以设置为：Router、End Device。Zigbee网络有3种类型的节点：Coordinator、Router、End Device，Cordinator接在电脑上面收集数据，我们这里是采集节点，所以只设置为Router或End Device。
2，检测节点是否加入了网络
3，如果节点没有加入网络，则启动自动扫描加入网络

, r6 x9 X- [  ^- _7 q1，节点类型的设置：
首先读取DRF1609H的参数：G031向DRF1609H发送读取参数指令，发完参数后，有一个500MS的超时等待参数的回复，参数回复总共是53个字节，放在receiveConfigData里面。
) M5 N! }9 n7 S; B2 p  T0 b! [

1.         //--Read DRF1609H Configures --
   ! }3 W6 U$ N( p% v# I
2.         drf1609h_readModule();
   
3.         HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );

复制代码

1. //------------------------------
   0 |8 _9 ]/ ?; t9 a/ x
2. void  drf1609h_readModule(void)
   
3. {
   $ @% C7 G" }0 ]% {
4.         drf1609h_sendedIns = sendIns_read;
   # I$ I# H1 K8 B
5.         HAL_UART_Transmit_DMA( &huart1, readIns, 9 );
   
6. }

复制代码

读取参数完成后，把读取到的参数整理后放入drf1609这个结构体中：以后取用的时候就非常方便了，建议用户不要改这部分代码，直接拷贝使用就好了。

& s+ t2 Q/ h' k0 ]

1.         //---If DRF1609H Error or Read Error ------
   9 e+ L, _5 V# f' \! M" T# L* W
2.         while( readParameterProcess(receivedConfigData, 53) == 0 )
   ! S5 m+ T  F& G- f4 E; i/ Q" G
3.         {
   
4.                 drf1609h_readModule();
   / j2 @( {7 R5 t: Y
5.                 HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );
   
6.         }

复制代码

1. //------------------------------
   , m! f3 x+ q2 Y9 J+ K
2. uint8_t  readParameterProcess(uint8_t  *inputData,  uint16_t  inputLen)
   
3. {
   
4.         uint8_t  result=0;
   
5. 
   
6.         uint8_t  tempXY=0;
   
7.         uint8_t  tempRight=0;
   
8.         uint8_t  i=0;
   , H9 p2 ~7 \1 ^, H0 d5 @
9.         
   4 I7 x- U" |9 X  C; ?7 x
10.         tempXY = getXY(inputData, inputLen);
    
11.         
    
12.         if(inputData[0]==0xFA) { tempRight++; }
    
13.         if(inputData[1]==0x31) { tempRight++; }
    ; V+ {( I# x* G
14.         if(inputData[2]==0x0A) { tempRight++; }
    ; `" O" H3 T  d% M* [
15.         if(inputData[inputLen-1]==tempXY) { tempRight++; }
    
16.         
    , \$ X& [3 D: }4 q: f! \$ H
17.         if(tempRight==4)
    
18.         {
    
19.                 //------
      B$ b$ ^7 J; M3 \8 A
20.                 drf1609.pointType = inputData[readHeaderLen +0];
    
21.                 drf1609.PAN_ID = inputData[readHeaderLen +1]*256 + inputData[readHeaderLen +2];
    7 m5 z$ `* w) n4 ?' Y
22.                 drf1609.Channel = inputData[readHeaderLen +3];
    
23.                 drf1609.transferModel = inputData[readHeaderLen +4];
    ! d/ [0 ~, L: X6 v& S: R
24.                 drf1609.userAddress = inputData[readHeaderLen +5]*256 + inputData[readHeaderLen +6];
    
25.                 drf1609.X7X8 = inputData[readHeaderLen +7]*256 + inputData[readHeaderLen +8];
    
26.                 drf1609.uartBraudRate = inputData[readHeaderLen +9];
      W6 y/ P$ x7 Z7 y' ?, d) V) L# b
27.                 drf1609.uartDataBits = inputData[readHeaderLen +10];
    6 \- ^5 k/ v2 k* m5 e) m
28.                 drf1609.uartStopBits = inputData[readHeaderLen +11];
    
29.                 drf1609.uartParity = inputData[readHeaderLen +12];
    
30.                 drf1609.X13X14 = inputData[readHeaderLen +13]*256 + inputData[readHeaderLen +14];
    % k) [* e9 b& [# x/ _& W
31.                 drf1609.antennaSelect = inputData[readHeaderLen +15];
    1 L6 w" R- o( K
32.                
    ' N# _! [% Y( G! c7 {2 \7 P
33.                 //-------
    3 C, x* ?. A* n6 t, j9 H' w9 [
34.                 for(i=0; i<8; i++)
    
35.                 {
    
36.                         drf1609.macAddress<i> = inputData[readHeaderLen +16 +i];
    " Z$ @/ s. m3 A4 \
37.                 </i>}
    
38.                
    ; K4 |/ x* F: ^" d
39.                 //--------
    
40.                 drf1609.prePointType = inputData[readHeaderLen +24];
    
41.                 drf1609.prePAN_ID = inputData[readHeaderLen +25]*256 + inputData[readHeaderLen +26];
    5 {' ~# v9 b9 C' q: o5 J
42.                 drf1609.preChannel = inputData[readHeaderLen +27];
    . F* w. z& o; P+ u7 X  A' p1 x1 R
43.                 drf1609.preTransferModel = inputData[readHeaderLen +28];
    8 f2 a8 V) l/ c' U% n! X1 K+ p
44.                 drf1609.preUserAddress = inputData[readHeaderLen +29]*256 + inputData[readHeaderLen +30];
    : M: a: T( N' S# q0 K
45.                 drf1609.X31X32 = inputData[readHeaderLen +31]*256 + inputData[readHeaderLen +32];
    
46.                 drf1609.preUartBraudRate = inputData[readHeaderLen +33];
    
47.                 drf1609.preUartDataBits = inputData[readHeaderLen +34];
    
48.                 drf1609.preUartStopBits = inputData[readHeaderLen +35];
    : ?; @9 q8 L  @6 t' B7 H
49.                 drf1609.preUartParity = inputData[readHeaderLen +36];
    
50.                 drf1609.X37X38 = inputData[readHeaderLen +37]*256 + inputData[readHeaderLen +38];
    
51.                 drf1609.preAntennaSelect = inputData[readHeaderLen +39];
    
52.                
    8 r0 j+ l8 ?/ P7 v( B: V
53.                 //-----------
    1 N4 H" @" u; c& ~  C: r
54.                 drf1609.shortAddress = inputData[readHeaderLen +40]*256 + inputData[readHeaderLen +41];
    / K! L7 |/ |/ x& e* K
55.                 drf1609.X42 = inputData[readHeaderLen +42];
    - z/ [3 k5 g9 p2 G; p) \  n1 e- K
56.                 drf1609.isSecurity = inputData[readHeaderLen +43];
    # \0 [: c8 @6 h7 G4 z9 h
57.                
    
58.                 for(i=0; i<4; i++)
    
59.                 {
    7 K) |. p# i# V8 U! g
60.                         drf1609.securityCode = inputData[readHeaderLen +44 +i];
    9 ^' F% D- p3 q* i& a1 W+ w
61.                 }
    0 a& P4 n3 ?& d8 d
62. 
    - x5 ]. E- J' l. {3 D
63.                 result =1;
    
64.         }
    
65. 
    / P' z9 z/ J3 Z. k
66.         return result;
    
67. }

复制代码

7 g0 m5 S+ w) n% D, a0 U4 l6 s接着比较读出来的节点类型与要设置的节点类型是否一致，如果不一致的话，就重新写入要设置的节点类型：  

1.   if( drf1609H_setPontType != drf1609H_readPointType )

复制代码

写的过程：
0 C& r, o: a3 g/ p5 h1，产生写入参数
. Q, Q( @1 Z: ?. ?- [# a/ k6 F2，写入
( C# ]9 E" s- [4 c( n% H$ g. }" S8 @) F3，接收回复的参数，看看写入是否正确
: [) \6 ^4 s' B2 O* w$ P$ i. w
# L7 V$ l2 t) w* M! a9 M

1.                 getWriteIns(drf1609);
   
2. 
   : f& |9 e* e* A
3.                 drf1609h_writeModule();
   ; i! h0 ]2 k  d" ^3 T
4.                 HAL_UART_Receive( &huart1, receivedConfigData, 5, 500 );

复制代码

" c% d3 @! l1 R写入正确以后，则重启模块（注意：DRF1609H的写入参数生效，都需要重启），这里是用一个IO口，控制DRF1609H的RESET脚拉低重启。
- v7 X- u. ?6 s% X

1. if( is_InsBack(receivedConfigData, 5) )
   
2.                 {
   
3.                         if(receivedConfigData[2] == 0x0A)
   . m" ^- ]! M$ O/ x. P! |+ W, J
4.                         {
   6 A* B" e% m! Z2 G5 x/ U
5.                                 drf1609h_reset();
   
6.                                 HAL_Delay(2000);
   
7.                                 drf1609h_status = drf1609h_powerOn;
   
8.                         }
   " R$ g4 O* F# H- l2 {" ]
9.                         else
   / R% D7 f9 ~) }3 B$ Y9 P0 N$ Z
10.                         {
    
11.                                 errorStart=1;
    
12.                         }
    
13.                 }
    
14.                 else
    
15.                 {
    % K2 f* I" N/ s6 X- w
16.                         errorStart=1;
    9 X5 }! [  b8 x6 d  L2 Z( g
17.                 }

复制代码

* _& j" t: |) |* R! M( _需要注意的是，getWriteIns(drf1609)，这个函数是把drf1609结构体，直接变换成写入指令，建议用户不要修改这部分，直接拷贝使用
3 @( P5 r0 L) m. O, V( Y+ m

1. //---------------------------------------------------
   6 z9 s+ `5 Y( Y: H' Y$ M
2. void  getWriteIns(_zigbeeParameters  inputParameter)
   ! K% B! a1 J; n8 f% x1 K
3. {
   
4.         uint8_t   i=0;
   
5.         uint8_t  tempXY=0;
   & h8 C& K- x9 P% Q
6.         
   
7.         writeIns[0]= 0xFC;
   
8.         writeIns[1]= 0x27;
   
9.         writeIns[2]= 0x07;
   4 d# G; a5 J4 N8 A# ?0 c
10.         
    
11.         writeIns[writeHeaderLen +0]= inputParameter.pointType;
    
12.         writeIns[writeHeaderLen +1]= (inputParameter.PAN_ID & 0xFF00)>>8;
    0 K1 \0 c  |7 J# M3 V
13.         writeIns[writeHeaderLen +2]= inputParameter.PAN_ID & 0x00FF;
    7 ]' D2 D) ~5 J: T. k- i" _) N
14.         writeIns[writeHeaderLen +3]= inputParameter.Channel;
    
15.         writeIns[writeHeaderLen +4]= inputParameter.transferModel;
    ( |/ P, `* \- s. @1 }; D3 b7 H
16.         writeIns[writeHeaderLen +5]= (inputParameter.userAddress & 0xFF00)>>8;
    
17.         writeIns[writeHeaderLen +6]= inputParameter.userAddress & 0x00FF;
    . }6 {& f3 V, ]; o: r+ x4 ^
18.         writeIns[writeHeaderLen +7]= (inputParameter.X7X8 & 0xFF00)>>8;
    + {) J4 }  {. h& U. u
19.         writeIns[writeHeaderLen +8]= inputParameter.X7X8 & 0x00FF;
    " J6 z5 _& ?& X) k
20.         writeIns[writeHeaderLen +9]= inputParameter.uartBraudRate;
    
21.         writeIns[writeHeaderLen +10]= inputParameter.uartDataBits;
    8 {% U( W0 V3 R
22.         writeIns[writeHeaderLen +11]= inputParameter.uartStopBits;
    8 T" n2 z2 g% z6 x. e
23.         writeIns[writeHeaderLen +12]= inputParameter.uartParity;
    
24.         writeIns[writeHeaderLen +13]= (inputParameter.X13X14 & 0xFF00)>>8;
    6 ]2 @& n) `+ I5 t
25.         writeIns[writeHeaderLen +14]= inputParameter.X13X14 & 0x00FF;
    
26.         writeIns[writeHeaderLen +15]= inputParameter.antennaSelect;
    2 B7 M# }; _! F  R1 Y+ U
27.         
    : U$ x0 D9 `! S7 {. h
28.         writeIns[writeHeaderLen +16]= inputParameter.prePointType;
    
29.         writeIns[writeHeaderLen +17]= (inputParameter.prePAN_ID & 0xFF00)>>8;
    
30.         writeIns[writeHeaderLen +18]= inputParameter.prePAN_ID & 0x00FF;
    
31.         writeIns[writeHeaderLen +19]= inputParameter.preChannel;
    8 Y; l3 e# V% C6 v- w$ S/ e  K+ r
32.         writeIns[writeHeaderLen +20]= inputParameter.preTransferModel;
    ( }9 F% Q/ K/ ?0 d# z' S* D
33.         writeIns[writeHeaderLen +21]= (inputParameter.preUserAddress & 0xFF00)>>8;
    + d$ o( k1 J* }' j4 u
34.         writeIns[writeHeaderLen +22]= inputParameter.preUserAddress & 0x00FF;
    
35.         writeIns[writeHeaderLen +23]= (inputParameter.X31X32 & 0xFF00)>>8;  //--AS ReadParameter's X31 X32
    
36.         writeIns[writeHeaderLen +24]= inputParameter.X31X32 & 0x00FF;       //--AS ReadParameter's X31 X32
    8 }( ?2 K2 y; p5 {# z3 G
37.         writeIns[writeHeaderLen +25]= inputParameter.preUartBraudRate;
    
38.         writeIns[writeHeaderLen +26]= inputParameter.preUartDataBits;
      p  _5 Y! ?* g! `) L" B, v
39.         writeIns[writeHeaderLen +27]= inputParameter.preUartStopBits;
    
40.         writeIns[writeHeaderLen +28]= inputParameter.preUartParity;
    
41.         writeIns[writeHeaderLen +29]= (inputParameter.X37X38 & 0xFF00)>>8;  //--AS ReadParameter's X37 X38
    
42.         writeIns[writeHeaderLen +30]= inputParameter.X37X38 & 0x00FF;       //--AS ReadParameter's X37 X38
    , f% ]$ }+ O5 l- L
43.         writeIns[writeHeaderLen +31]= inputParameter.preAntennaSelect;
    ' m# k% u9 h3 v; K( E. E& J1 D* d
44.         writeIns[writeHeaderLen +32]= 0x1;
    
45.         writeIns[writeHeaderLen +33]= inputParameter.isSecurity;
    ( I- H5 o3 Q3 K+ |: d) [6 B0 w
46.         
    
47.         for(i=0; i<4; i++)
    7 k1 z  M' D. }- n- R; Q
48.         {
    0 y& m+ o' S# |  T6 s$ m2 D" F
49.                 writeIns[writeHeaderLen +34 +i]= inputParameter.securityCode<span style="font-style: italic;"><span style="font-style: normal;">;
    
50.         }
    
51.         
    
52.         tempXY = getXY(writeIns, writeInsLen);
    9 `) c9 F0 l2 U  i  G
53.         
    
54.         writeIns[writeInsLen-1]= tempXY;        
    
55. }</span></span>

复制代码

& m5 x/ u0 I8 B; O6 _2，检测节点是否加入网络
3 t4 E: {% @0 v/ D  O检测节点是否加入网络，我们这里使用了读取DRF1609H节点信号强度指令，如果读取信号强度成功（回复的数据是正确的），则表明DRF1609H已经加入了网络并且与Coordinator通讯正常。
这个函数用来检测DRF1609H是否加入了网络，加入则回复1，没有则回复0：
注意：这里是检测10次，没有加入也回复1，主要考虑在低功耗情况下，如果Coordinator没有开机，如果节点一直检测，则对耗电不利，用户应根据实际情况修改使用。
* W+ G2 J2 I' Y& L9 z# A9 F
8 u) Q4 G0 r) ?2 L

1. uint8_t  drf1609h_isJoinedNet()
   - T5 y7 s7 M3 V7 w5 W( ]
2. 1
   7 g1 c" J; Y0 Q
3. //----------------------
   
4. uint8_t  drf1609h_isJoinedNet()
   ! {$ n1 a" H  m/ \6 S2 _$ z+ O
5. {
   - ]4 S5 |% @  F7 a
6.         uint8_t   result=0;
   
7.         uint8_t   i=0;
   
8. 
   * P" v* X+ D& x( K
9.         //MX_USART1_UART_Init();
   
10.         //HAL_Delay(10);
    # z# @1 K) G  b" Z! H3 a( x' b
11.         for(i=0; i<8; i++)
    5 @5 i8 k4 [$ Q1 y4 V: R; `9 j
12.         {
    , M1 k( _$ y  y
13.                 receivedSignalData<span style="font-style: italic;"><span style="font-style: normal;">=0;
    
14.         }
    
15. 
    
16.         drf1609h_requestSignalIndex();
    1 d% P- I& W! N9 p/ y
17.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
    
18.         HAL_Delay(1000);
    ) s. Z% ^0 k2 U( ^+ {
19. 
    2 l9 W1 R6 U) C8 e! ?
20.         if( checkSignalData(receivedSignalData, 8) )
    
21.         {
    4 A- h8 ^1 R: |7 @) [6 X
22.                 result=1;
      Y" F4 f6 q- e* g/ p) B5 F4 v
23.                 receivedSignalData[8] = drf1609.pointType;
    
24.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
    5 K0 B% A7 s+ o
25.         }
    
26.         else
    # R5 g- L; C, s1 \( e1 V; C& g0 e. J
27.         {
    0 N" z  V9 Z: b
28.                 haveTryToJoinTimers++;
    3 I( O; \, `/ }
29.                 if(haveTryToJoinTimers >= maxJoinTimers)
    ' v6 {7 H# v3 J3 R8 X- ]0 f
30.                 {
    7 P8 \: A: P  o' B
31.                         result=1;
    
32.                 }
    
33.                 else
      m! b4 B/ t. N$ D$ `
34.                 {
    3 t+ T& X4 P2 p, b7 M/ S0 s3 t
35.                         result=0;
    
36.                 }
    
37.         }
    # P  F: e/ n2 X2 O0 ?% b4 v
38. 
    
39. 
    0 l- e* ]9 q# U5 i8 s# f
40.         return   result;
    
41. }</span></span>

复制代码

4 g7 A" n5 a! E/ @0 f检测的过程：
1，发送读取信号强度指令
" S2 {/ q( v8 A* V! ^+ Q2，等待接收回复数据
3，如果接收回复数据成功（已经加入网络），这里将收到的数据加上自己的节点类型发送给Coordinator，通知节点已经加入成功
3 e9 i+ [7 i% g. F! d

1.         drf1609h_requestSignalIndex();
   
2.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   
3.         HAL_Delay(1000);
   
4. 
   
5.         if( checkSignalData(receivedSignalData, 8) )
   6 p% z6 Y3 D2 _9 J% l
6.         {
   
7.                 result=1;
   
8.                 receivedSignalData[8] = drf1609.pointType;
   # m  @5 [$ R7 L; Z' o
9.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
   
10.         }

复制代码

+ f" T2 \3 i" \3 ~# H- |. f3，启动节点自动加入网络
如果连按三次DRF1609H的Function按键，则开始自动扫描，如果扫描到Coordinator，则可以自动加入网络，并从Coordinator处获得“给Router预设的参数”，所以节点是不要设置的，我们节点的板子上也没有把DRF1609H的串口留出来，而是通过连按三次按键，自动加入网络，自动取得参数。
% ~9 w: b5 {+ N# l5 v1，检测DRF1609H是否加入网络，用的是读取信号强度的指令
" F! F1 f2 W7 T2，如果没有加入网络，则启动自动加入网络
3，启动后，等待12秒，再读取信号强度，判断是否加入了网络
注意，板子上有按键，如果是低功耗模式，建议不要启动这个功能，用按键手工加入网络，如果Coordinator没开机，一直扫描网络，会很快耗光电池。

1.         //-- Do 5 timers get Signal Index ----//
   ; W& x6 _$ W3 t/ M% E: p8 B! U
2.         for(i=0; i<5; i++)
   
3.         {
     d8 O3 r' c" j& E$ [
4.                 drf1609h_requestSignalIndex();
   & \( m  B$ A" V
5.                 HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   
6.                 HAL_Delay(500);
   ' ^9 e8 G9 z/ D* r$ M8 i: o9 g8 j
7. 
   
8.                 if( checkSignalData(receivedSignalData, 8) )
   
9.                 {
   8 H5 E! w) N7 {  Q
10.                         tempVal++;
    
11.                         i=5;
    & g/ w. _! c) |2 h: s! `+ w/ x3 d8 B5 @
12.                 }
    / `( y' B+ p. {- V% U1 f6 ~' a8 L
13.                 else
    1 s: h0 m* k/ K; e/ O
14.                 {
    6 ]' C8 r$ p4 Z7 c0 b; F
15.                         notGetSignalVal++;
    9 |# {" `! G) O$ K) K2 M/ m
16.                 }
    
17.         }

复制代码

1.             drf1609h_autoJoinNet_Start();
   1 E; p1 B- Q8 X& S' t
2.             HAL_Delay(12000);

复制代码

- R: U6 a* h5 t3 S7 U; s进去自动加入网络的代码看看，其实就是模拟三次按键：
开始以后，DRF1609H上的2个灯会快闪，观察到一个灯灭，一个灯慢闪以后，说明已经加入网络。
, ?* V. W6 r5 u% q
0 j1 v/ ?8 J5 h8 G

1. //---------------------------------------
   
2. /*   This Simulate Function Key to start
   ; L$ j1 N3 j# e6 ~- }& z
3. *   point auto join net
   
4. *   ____    ______    ______    ______
   
5. *       |__|      |__|      |__|
   
6. *
   ) R1 M  V/ T3 Q! [
7. *       120  200  120  200  120  200
   
8. *
   4 q$ ~/ U. l5 z7 ]
9. *   ----------------------------------*/
   
10. void  drf1609h_autoJoinNet_Start()
    6 u% O- z. {  e
11. {
    ' C2 g: O  S- x' r4 S2 e$ K
12.         uint8_t  i=0;
    
13. 
    
14.         set_autoJoinNetPin_output();
    % H7 |& J, m: G2 k" [
15.         set_autoJoinNetPin_out_1();
    : h" a6 p' F  e; p+ s6 K8 x0 Y; b
16.         HAL_Delay(100);
    # @6 u& J1 e, B) a& ^' F% A# V
17. 
    
18.         for(i=0; i<3; i++)
    3 g' j) G( A3 m  Q
19.         {
    
20.                 set_autoJoinNetPin_out_0();
    
21.                 HAL_Delay(120);
    
22. 
    
23.                 set_autoJoinNetPin_out_1();
    . Y5 c2 G4 f# \
24.                 HAL_Delay(200);
    
25.         }
    - f. ^5 Y/ |; Z. O$ [* X
26. 
    1 _/ g; }* [/ F' j
27.         set_autoJoinNetPin_input();
    0 V/ Y* S, t* ?) m
28. }

复制代码

4，DRF1609H的相关指令
7 Y! s3 c/ N% Z$ S主要有读取参数、读取信号强度、写入参数等指令，项目里面都已经列出来了
如果需要增加其它的功能，要参考DRF1609H的说明书

8 c; x$ x, x' v8 f

1. uint8_t    linkIns[9] = {0xFC, 0x06, 0x04, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x81};      //---INS01
   " [& I5 X8 B5 I6 U; m0 [0 }' K
2. uint8_t    restartIns[9] = {0xFC, 0x06, 0x06, 0x44, 0x54, 0x4B, 0xAA, 0xBB, 0x50};   //---INS02
   & x" C$ q, N* {! [- |: m7 n. Z' d
3. uint8_t    readIns[9] = {0xFC, 0x06, 0x0E, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x8B};      //---INS05
   
4. uint8_t    writeIns[42];   //--INS06
   5 l( ^0 P; |" R' g% P+ F+ [4 @
5. uint8_t    requestSignalIns[9] = {0xFC, 0x06, 0x0C, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x89};    //--INS08

复制代码