本项目中使用了Zigbee模块（DRF1609H），作为无线数据传输使用，初始化DRF1609H主要涉及以下几个方面的内容：
7 P* N" x3 D+ b2 q/ Y' o1，设置节点的类型，可以设置为：Router、End Device。Zigbee网络有3种类型的节点：Coordinator、Router、End Device，Cordinator接在电脑上面收集数据，我们这里是采集节点，所以只设置为Router或End Device。
" p( \9 z  X, ^4 r! h2，检测节点是否加入了网络
  ]) K3 X- q# ^" l# {3，如果节点没有加入网络，则启动自动扫描加入网络
7 b3 \* X% c, O
& Z! H8 t4 K' A- l- @/ I1，节点类型的设置：
; E' i% f( x  b: \3 o- `- |首先读取DRF1609H的参数：G031向DRF1609H发送读取参数指令，发完参数后，有一个500MS的超时等待参数的回复，参数回复总共是53个字节，放在receiveConfigData里面。
( k  |+ N' ?7 ^5 [: e% \; b# a

1.         //--Read DRF1609H Configures --
   
2.         drf1609h_readModule();
   ! }8 g2 z6 y# U9 X1 d6 L
3.         HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );

复制代码

1. //------------------------------
   
2. void  drf1609h_readModule(void)
   
3. {
   
4.         drf1609h_sendedIns = sendIns_read;
   
5.         HAL_UART_Transmit_DMA( &huart1, readIns, 9 );
   ' Q2 u) i+ O5 c" @+ J2 u% v) r4 C
6. }

复制代码

读取参数完成后，把读取到的参数整理后放入drf1609这个结构体中：以后取用的时候就非常方便了，建议用户不要改这部分代码，直接拷贝使用就好了。
/ @& D, Z) A% K. ]4 c: b. R8 ~6 |

1.         //---If DRF1609H Error or Read Error ------
   
2.         while( readParameterProcess(receivedConfigData, 53) == 0 )
   
3.         {
   % O# j( `4 v( C, V, q) E& i
4.                 drf1609h_readModule();
   / c7 G/ o7 F# y3 t+ Q
5.                 HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );
   * N. ~( V: g" @, T
6.         }

复制代码

1. //------------------------------
   ' ?5 S  U: Q' g% \8 j* y
2. uint8_t  readParameterProcess(uint8_t  *inputData,  uint16_t  inputLen)
   
3. {
   + j0 F3 X. X$ ?) @
4.         uint8_t  result=0;
   
5. 
   
6.         uint8_t  tempXY=0;
   " C, W- }* }; I4 i8 S4 E& n
7.         uint8_t  tempRight=0;
   
8.         uint8_t  i=0;
   
9.         
   
10.         tempXY = getXY(inputData, inputLen);
    5 Y$ ]7 O9 `8 X& a+ E3 m
11.         
    
12.         if(inputData[0]==0xFA) { tempRight++; }
    
13.         if(inputData[1]==0x31) { tempRight++; }
    
14.         if(inputData[2]==0x0A) { tempRight++; }
    
15.         if(inputData[inputLen-1]==tempXY) { tempRight++; }
    
16.         
    
17.         if(tempRight==4)
    
18.         {
    
19.                 //------
    5 a7 i: e% M2 [6 n
20.                 drf1609.pointType = inputData[readHeaderLen +0];
    
21.                 drf1609.PAN_ID = inputData[readHeaderLen +1]*256 + inputData[readHeaderLen +2];
    
22.                 drf1609.Channel = inputData[readHeaderLen +3];
    ! u7 L, K) p( {  Y- h5 m
23.                 drf1609.transferModel = inputData[readHeaderLen +4];
    0 m5 @5 I" Y7 n
24.                 drf1609.userAddress = inputData[readHeaderLen +5]*256 + inputData[readHeaderLen +6];
    
25.                 drf1609.X7X8 = inputData[readHeaderLen +7]*256 + inputData[readHeaderLen +8];
    3 `$ t2 T3 u3 v0 {% S3 g  H/ y
26.                 drf1609.uartBraudRate = inputData[readHeaderLen +9];
    
27.                 drf1609.uartDataBits = inputData[readHeaderLen +10];
    
28.                 drf1609.uartStopBits = inputData[readHeaderLen +11];
    
29.                 drf1609.uartParity = inputData[readHeaderLen +12];
    
30.                 drf1609.X13X14 = inputData[readHeaderLen +13]*256 + inputData[readHeaderLen +14];
    
31.                 drf1609.antennaSelect = inputData[readHeaderLen +15];
    
32.                
    % ?# z$ t8 j* l6 G4 `
33.                 //-------
    
34.                 for(i=0; i<8; i++)
    
35.                 {
    4 b- h* |+ q) d
36.                         drf1609.macAddress<i> = inputData[readHeaderLen +16 +i];
    , Q- J( X! q9 W2 [+ K
37.                 </i>}
    
38.                
    2 J9 U9 Z: z  n- }! H
39.                 //--------
    ; [. [, F4 [/ J
40.                 drf1609.prePointType = inputData[readHeaderLen +24];
    
41.                 drf1609.prePAN_ID = inputData[readHeaderLen +25]*256 + inputData[readHeaderLen +26];
    
42.                 drf1609.preChannel = inputData[readHeaderLen +27];
    . u( f$ I+ H8 G6 z! A  H
43.                 drf1609.preTransferModel = inputData[readHeaderLen +28];
    
44.                 drf1609.preUserAddress = inputData[readHeaderLen +29]*256 + inputData[readHeaderLen +30];
    : G6 h* I' E1 h. a- y; _! K
45.                 drf1609.X31X32 = inputData[readHeaderLen +31]*256 + inputData[readHeaderLen +32];
    ; [* @( ^+ K+ z0 ^; y
46.                 drf1609.preUartBraudRate = inputData[readHeaderLen +33];
    
47.                 drf1609.preUartDataBits = inputData[readHeaderLen +34];
    ! `4 T1 D& s9 h8 m; Z; k
48.                 drf1609.preUartStopBits = inputData[readHeaderLen +35];
    
49.                 drf1609.preUartParity = inputData[readHeaderLen +36];
    3 m4 J3 f* i" ^: ^/ [
50.                 drf1609.X37X38 = inputData[readHeaderLen +37]*256 + inputData[readHeaderLen +38];
    
51.                 drf1609.preAntennaSelect = inputData[readHeaderLen +39];
    
52.                
    8 |. @# @) C3 S4 F
53.                 //-----------
    
54.                 drf1609.shortAddress = inputData[readHeaderLen +40]*256 + inputData[readHeaderLen +41];
    
55.                 drf1609.X42 = inputData[readHeaderLen +42];
    
56.                 drf1609.isSecurity = inputData[readHeaderLen +43];
    
57.                
    
58.                 for(i=0; i<4; i++)
    / K! n) Q  t' x. \5 A% k& E
59.                 {
    
60.                         drf1609.securityCode = inputData[readHeaderLen +44 +i];
    ! w! u1 N# e" t: G% W" T
61.                 }
    
62. 
    
63.                 result =1;
    $ p1 L3 K: H/ }. i; e4 ~
64.         }
    
65. 
    
66.         return result;
    
67. }

复制代码

接着比较读出来的节点类型与要设置的节点类型是否一致，如果不一致的话，就重新写入要设置的节点类型：  

1.   if( drf1609H_setPontType != drf1609H_readPointType )

复制代码

写的过程：
3 Z3 E0 m3 ?% M# I- M1，产生写入参数
2，写入
3，接收回复的参数，看看写入是否正确
+ V3 G1 G8 d* J  ]8 z* ^7 J- H

1.                 getWriteIns(drf1609);
   
2. 
     N+ u/ V  I. ^# m- L
3.                 drf1609h_writeModule();
   
4.                 HAL_UART_Receive( &huart1, receivedConfigData, 5, 500 );

复制代码

写入正确以后，则重启模块（注意：DRF1609H的写入参数生效，都需要重启），这里是用一个IO口，控制DRF1609H的RESET脚拉低重启。

1. if( is_InsBack(receivedConfigData, 5) )
   
2.                 {
   9 t4 B* q: D+ {* c
3.                         if(receivedConfigData[2] == 0x0A)
   . n4 p$ u; ^# h* F. r9 l. l4 j
4.                         {
   5 V% w% _7 r6 I0 u- u, m
5.                                 drf1609h_reset();
   
6.                                 HAL_Delay(2000);
   
7.                                 drf1609h_status = drf1609h_powerOn;
   ' y0 L5 g4 E- x* i; ]
8.                         }
   ( K5 @( n! I# R) J- Z5 }
9.                         else
   7 G. s6 t- |9 [5 ~  J
10.                         {
    
11.                                 errorStart=1;
    
12.                         }
    , y! H" s: J' e
13.                 }
    
14.                 else
    
15.                 {
    * `9 G3 i3 [. R  H0 h- y
16.                         errorStart=1;
    
17.                 }

复制代码

需要注意的是，getWriteIns(drf1609)，这个函数是把drf1609结构体，直接变换成写入指令，建议用户不要修改这部分，直接拷贝使用
  e, v" q9 d, t5 k3 J( G
) E- g  L2 p% E5 W4 p3 U) h$ j) j

1. //---------------------------------------------------
   - x5 Y9 U0 N+ i" H( ~% a. u
2. void  getWriteIns(_zigbeeParameters  inputParameter)
   
3. {
   + V% L# p' Y4 t2 X6 ?9 m
4.         uint8_t   i=0;
   
5.         uint8_t  tempXY=0;
   
6.         
   
7.         writeIns[0]= 0xFC;
   
8.         writeIns[1]= 0x27;
   & e4 n& }( `. D5 A, {: \" W
9.         writeIns[2]= 0x07;
   , ^! Z6 r4 Y% D, ~$ _0 U
10.         
    1 x4 _! h$ i0 @2 F0 Q- T) r
11.         writeIns[writeHeaderLen +0]= inputParameter.pointType;
    3 F: B0 x: l* ?4 y+ w5 m3 |6 r
12.         writeIns[writeHeaderLen +1]= (inputParameter.PAN_ID & 0xFF00)>>8;
    : N! a1 q& c0 m4 O1 e
13.         writeIns[writeHeaderLen +2]= inputParameter.PAN_ID & 0x00FF;
    ; X: }: ~0 E6 `& p# V2 U
14.         writeIns[writeHeaderLen +3]= inputParameter.Channel;
    
15.         writeIns[writeHeaderLen +4]= inputParameter.transferModel;
    ' U! h3 W. F) Z- f
16.         writeIns[writeHeaderLen +5]= (inputParameter.userAddress & 0xFF00)>>8;
    
17.         writeIns[writeHeaderLen +6]= inputParameter.userAddress & 0x00FF;
    9 e1 p. R0 R  J
18.         writeIns[writeHeaderLen +7]= (inputParameter.X7X8 & 0xFF00)>>8;
    ( E% C: u- `: ~0 w9 r2 r. Q
19.         writeIns[writeHeaderLen +8]= inputParameter.X7X8 & 0x00FF;
    
20.         writeIns[writeHeaderLen +9]= inputParameter.uartBraudRate;
    
21.         writeIns[writeHeaderLen +10]= inputParameter.uartDataBits;
    8 t* h  s( H+ K. p4 y
22.         writeIns[writeHeaderLen +11]= inputParameter.uartStopBits;
    
23.         writeIns[writeHeaderLen +12]= inputParameter.uartParity;
    
24.         writeIns[writeHeaderLen +13]= (inputParameter.X13X14 & 0xFF00)>>8;
    6 l4 @" T* M# O0 f/ @; l
25.         writeIns[writeHeaderLen +14]= inputParameter.X13X14 & 0x00FF;
    
26.         writeIns[writeHeaderLen +15]= inputParameter.antennaSelect;
    , k: w4 S5 x( {. n5 k6 b! A8 z
27.         
      r) B' \7 L7 b5 {: D! s4 b$ i
28.         writeIns[writeHeaderLen +16]= inputParameter.prePointType;
    ( J7 W2 n" I* o& \' Z$ m) y! i
29.         writeIns[writeHeaderLen +17]= (inputParameter.prePAN_ID & 0xFF00)>>8;
    
30.         writeIns[writeHeaderLen +18]= inputParameter.prePAN_ID & 0x00FF;
    
31.         writeIns[writeHeaderLen +19]= inputParameter.preChannel;
    
32.         writeIns[writeHeaderLen +20]= inputParameter.preTransferModel;
    5 D; w+ _+ @8 F+ b8 N9 K* Z8 r
33.         writeIns[writeHeaderLen +21]= (inputParameter.preUserAddress & 0xFF00)>>8;
    ( [- I; B# F% g; Y
34.         writeIns[writeHeaderLen +22]= inputParameter.preUserAddress & 0x00FF;
    
35.         writeIns[writeHeaderLen +23]= (inputParameter.X31X32 & 0xFF00)>>8;  //--AS ReadParameter's X31 X32
    8 ]5 G9 d7 ^$ d0 V
36.         writeIns[writeHeaderLen +24]= inputParameter.X31X32 & 0x00FF;       //--AS ReadParameter's X31 X32
    / O1 g# L0 O( x: b* ~$ A; v
37.         writeIns[writeHeaderLen +25]= inputParameter.preUartBraudRate;
    
38.         writeIns[writeHeaderLen +26]= inputParameter.preUartDataBits;
    8 |  W: B; b# d' ^" T! _! b5 D
39.         writeIns[writeHeaderLen +27]= inputParameter.preUartStopBits;
    
40.         writeIns[writeHeaderLen +28]= inputParameter.preUartParity;
    6 c/ K& @9 Q  d: Q
41.         writeIns[writeHeaderLen +29]= (inputParameter.X37X38 & 0xFF00)>>8;  //--AS ReadParameter's X37 X38
    " s" P# m) Q3 c3 V/ M
42.         writeIns[writeHeaderLen +30]= inputParameter.X37X38 & 0x00FF;       //--AS ReadParameter's X37 X38
    : Y9 P! f. i+ b! a7 Q+ s
43.         writeIns[writeHeaderLen +31]= inputParameter.preAntennaSelect;
    
44.         writeIns[writeHeaderLen +32]= 0x1;
    
45.         writeIns[writeHeaderLen +33]= inputParameter.isSecurity;
    # [2 ~9 j% x6 F6 w/ v% E2 v$ @
46.         
    * V1 W" h# L* c  r; H  u- ~
47.         for(i=0; i<4; i++)
    6 _4 W( l+ e- f! J( t' N* M
48.         {
    
49.                 writeIns[writeHeaderLen +34 +i]= inputParameter.securityCode<span style="font-style: italic;"><span style="font-style: normal;">;
    
50.         }
    6 h2 f" X0 w' A& [/ _& n
51.         
    4 [* {+ V* Z7 R
52.         tempXY = getXY(writeIns, writeInsLen);
    
53.         
    
54.         writeIns[writeInsLen-1]= tempXY;        
    9 a, p2 i; M$ l5 K* G
55. }</span></span>

复制代码

$ m; K( B( D- W2，检测节点是否加入网络
+ D1 S1 x7 ^1 ~1 n# ^, i检测节点是否加入网络，我们这里使用了读取DRF1609H节点信号强度指令，如果读取信号强度成功（回复的数据是正确的），则表明DRF1609H已经加入了网络并且与Coordinator通讯正常。
: x* o* p9 b/ C* n2 S+ I这个函数用来检测DRF1609H是否加入了网络，加入则回复1，没有则回复0：
注意：这里是检测10次，没有加入也回复1，主要考虑在低功耗情况下，如果Coordinator没有开机，如果节点一直检测，则对耗电不利，用户应根据实际情况修改使用。
* M6 F: S9 ?5 K: K
" d, q6 V3 P# b+ Q

1. uint8_t  drf1609h_isJoinedNet()
     p% ]) i/ ]. b$ @
2. 1
   2 @8 j  b. h" r7 i5 [* S. A
3. //----------------------
   ) o& n1 H$ N) ~+ W
4. uint8_t  drf1609h_isJoinedNet()
   
5. {
   
6.         uint8_t   result=0;
   
7.         uint8_t   i=0;
   
8. 
   + ?8 m! I" ?( @& _
9.         //MX_USART1_UART_Init();
   
10.         //HAL_Delay(10);
    ) N$ I5 S) F8 L
11.         for(i=0; i<8; i++)
    
12.         {
    
13.                 receivedSignalData<span style="font-style: italic;"><span style="font-style: normal;">=0;
    
14.         }
    
15. 
    , Q! u9 I2 n  M4 v6 E1 T+ u- ?
16.         drf1609h_requestSignalIndex();
    
17.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
    , L1 T, ]1 ^9 U; a8 f/ F0 x
18.         HAL_Delay(1000);
    
19. 
    
20.         if( checkSignalData(receivedSignalData, 8) )
    
21.         {
    : S5 h" F( r* t7 i& |! D) B
22.                 result=1;
    % j+ i/ |7 s" c' B+ f
23.                 receivedSignalData[8] = drf1609.pointType;
    
24.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
    
25.         }
    . \- B8 ^# O. M# y) M- Y% c! F
26.         else
    
27.         {
    
28.                 haveTryToJoinTimers++;
    0 @9 A, t* o' L' i  R
29.                 if(haveTryToJoinTimers >= maxJoinTimers)
    7 G0 Y* t9 u: j* M; j, N& W; s/ Q# {
30.                 {
    " m$ }: q8 m9 H( T% i- @- j
31.                         result=1;
    , h  A6 T( t8 L7 w
32.                 }
    1 k) x+ ~; X$ g4 p' w
33.                 else
    " j# B$ e0 B/ V  y; f' B
34.                 {
    ; Q4 i0 [, M/ Z* A1 m/ ~
35.                         result=0;
    
36.                 }
    $ {$ k5 Z- l! _) j: r1 T
37.         }
    # l' w- h7 q( O( y) E+ h1 ^4 }
38. 
    
39. 
    5 o& ]. v9 l. \0 k5 A9 ?
40.         return   result;
    
41. }</span></span>

复制代码

8 Z7 X% p/ \  d$ n2 L- f检测的过程：
& J# S/ O+ ^, K) f0 F; F1，发送读取信号强度指令
% p' N5 Y3 L2 \  U  i; l2，等待接收回复数据
3，如果接收回复数据成功（已经加入网络），这里将收到的数据加上自己的节点类型发送给Coordinator，通知节点已经加入成功
2 H$ e0 w; n1 c: Y2 _0 ~( Z% x

1.         drf1609h_requestSignalIndex();
   ; V7 T0 \. [3 t! j
2.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   
3.         HAL_Delay(1000);
   
4. 
   . W7 ~8 v) g/ c9 X9 n" M0 d' H  t; N
5.         if( checkSignalData(receivedSignalData, 8) )
   ) i% ~* O. y9 f0 e! i
6.         {
   4 z& q! D! k  d2 Q# D8 a
7.                 result=1;
   4 r6 X, f2 c, L* A- s) u8 X
8.                 receivedSignalData[8] = drf1609.pointType;
   - O: k, t$ Y8 V  P
9.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
   $ _+ x3 [! R4 a, M$ e! ~  p
10.         }

复制代码

, N4 s$ ~! @- j% j3，启动节点自动加入网络
如果连按三次DRF1609H的Function按键，则开始自动扫描，如果扫描到Coordinator，则可以自动加入网络，并从Coordinator处获得“给Router预设的参数”，所以节点是不要设置的，我们节点的板子上也没有把DRF1609H的串口留出来，而是通过连按三次按键，自动加入网络，自动取得参数。
1，检测DRF1609H是否加入网络，用的是读取信号强度的指令
1 k2 x. j8 Z- G7 V$ C) [- v2 b# O$ m2，如果没有加入网络，则启动自动加入网络
3，启动后，等待12秒，再读取信号强度，判断是否加入了网络
注意，板子上有按键，如果是低功耗模式，建议不要启动这个功能，用按键手工加入网络，如果Coordinator没开机，一直扫描网络，会很快耗光电池。
) j' x$ e& ~6 ^
  }; H/ ~+ y$ M2 i7 m. j

1.         //-- Do 5 timers get Signal Index ----//
   # }; S* R& B; |' v0 ~) O, b4 T$ j
2.         for(i=0; i<5; i++)
   
3.         {
   
4.                 drf1609h_requestSignalIndex();
   
5.                 HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   " P. W& i2 K0 }+ S! p
6.                 HAL_Delay(500);
   
7. 
   4 k" h% y* c8 Y# L/ ?! v
8.                 if( checkSignalData(receivedSignalData, 8) )
   
9.                 {
   ( W. F4 H  R+ y& w" g  }, D  t
10.                         tempVal++;
    
11.                         i=5;
    
12.                 }
    
13.                 else
    
14.                 {
    
15.                         notGetSignalVal++;
    
16.                 }
    
17.         }

复制代码

1.             drf1609h_autoJoinNet_Start();
   - k: d( z( k) @; R
2.             HAL_Delay(12000);

复制代码

进去自动加入网络的代码看看，其实就是模拟三次按键：
开始以后，DRF1609H上的2个灯会快闪，观察到一个灯灭，一个灯慢闪以后，说明已经加入网络。
" C3 ~* S3 I$ E# h

1. //---------------------------------------
   
2. /*   This Simulate Function Key to start
   
3. *   point auto join net
   
4. *   ____    ______    ______    ______
   
5. *       |__|      |__|      |__|
   
6. *
   0 p$ q% x7 j6 l1 z+ Y$ C
7. *       120  200  120  200  120  200
   
8. *
   
9. *   ----------------------------------*/
   
10. void  drf1609h_autoJoinNet_Start()
    
11. {
    3 w: L& T$ L$ F
12.         uint8_t  i=0;
    
13. 
    # `9 w7 S+ g& H; X( r
14.         set_autoJoinNetPin_output();
    
15.         set_autoJoinNetPin_out_1();
    / L5 p0 s+ z, e
16.         HAL_Delay(100);
    / p% [& A, |, O6 x
17. 
    : b, m0 I: Q+ U- D& `
18.         for(i=0; i<3; i++)
      y5 |" C  s; T' k3 {
19.         {
    5 g9 |6 R1 p- h% `9 I+ Y( ^
20.                 set_autoJoinNetPin_out_0();
    
21.                 HAL_Delay(120);
    
22. 
    ; o% b( w7 p8 ]  A% D. e0 f2 m/ }& @
23.                 set_autoJoinNetPin_out_1();
    
24.                 HAL_Delay(200);
    
25.         }
    
26. 
    
27.         set_autoJoinNetPin_input();
    
28. }

复制代码

$ E3 u- T0 Z3 V$ c! {3 `6 L4，DRF1609H的相关指令
0 T1 H7 r# S! n$ A主要有读取参数、读取信号强度、写入参数等指令，项目里面都已经列出来了
7 k+ C+ w4 m! B- C2 X# t4 J如果需要增加其它的功能，要参考DRF1609H的说明书
" q$ P% T4 x3 y. O; e, n

1. uint8_t    linkIns[9] = {0xFC, 0x06, 0x04, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x81};      //---INS01
   
2. uint8_t    restartIns[9] = {0xFC, 0x06, 0x06, 0x44, 0x54, 0x4B, 0xAA, 0xBB, 0x50};   //---INS02
   % F  k- C) Q4 t
3. uint8_t    readIns[9] = {0xFC, 0x06, 0x0E, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x8B};      //---INS05
   4 D5 x6 A- Y- _7 r; P, ?
4. uint8_t    writeIns[42];   //--INS06
   
5. uint8_t    requestSignalIns[9] = {0xFC, 0x06, 0x0C, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x89};    //--INS08

复制代码