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

1，节点类型的设置：
首先读取DRF1609H的参数：G031向DRF1609H发送读取参数指令，发完参数后，有一个500MS的超时等待参数的回复，参数回复总共是53个字节，放在receiveConfigData里面。
) \2 v/ d" z" K+ p" W

1.         //--Read DRF1609H Configures --
   % C3 V4 _) ]+ H3 ]0 l
2.         drf1609h_readModule();
   
3.         HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );

复制代码

1. //------------------------------
   
2. void  drf1609h_readModule(void)
   
3. {
   
4.         drf1609h_sendedIns = sendIns_read;
     r1 ~- t- l; x/ f
5.         HAL_UART_Transmit_DMA( &huart1, readIns, 9 );
   * i% x' K1 }6 }) n1 [- L: d
6. }

复制代码

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

1.         //---If DRF1609H Error or Read Error ------
   
2.         while( readParameterProcess(receivedConfigData, 53) == 0 )
     T) }+ \4 o  ]  [8 s  Q9 {
3.         {
   ; p9 t2 }: G7 ^" e
4.                 drf1609h_readModule();
   / t5 H- S# X4 N
5.                 HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );
   % R' I" y2 M* t# Z. J) _* E
6.         }

复制代码

1. //------------------------------
   
2. uint8_t  readParameterProcess(uint8_t  *inputData,  uint16_t  inputLen)
   
3. {
   
4.         uint8_t  result=0;
   8 N; V& H4 p% R, m! Z) T
5. 
   
6.         uint8_t  tempXY=0;
   % n- h* B, n/ |
7.         uint8_t  tempRight=0;
   + C6 M7 O; b, F. r( }
8.         uint8_t  i=0;
   
9.         
   
10.         tempXY = getXY(inputData, inputLen);
    
11.         
    & O7 W4 K/ o7 z
12.         if(inputData[0]==0xFA) { tempRight++; }
    
13.         if(inputData[1]==0x31) { tempRight++; }
    " H8 p6 }3 U9 y/ h
14.         if(inputData[2]==0x0A) { tempRight++; }
    
15.         if(inputData[inputLen-1]==tempXY) { tempRight++; }
    9 N, w2 t8 }! I# b! f; L/ O
16.         
    " r0 i/ b3 i5 _
17.         if(tempRight==4)
    ' M4 f$ s5 f$ B* m
18.         {
    # ^& |- H4 ?* E5 m* K2 O2 |
19.                 //------
    
20.                 drf1609.pointType = inputData[readHeaderLen +0];
    
21.                 drf1609.PAN_ID = inputData[readHeaderLen +1]*256 + inputData[readHeaderLen +2];
    ; d% f$ s, h' s7 y* [2 L' @
22.                 drf1609.Channel = inputData[readHeaderLen +3];
    4 r( M, {" [' l. d6 O
23.                 drf1609.transferModel = inputData[readHeaderLen +4];
    
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];
    * R* v- A& |9 `$ Y4 ?: \
27.                 drf1609.uartDataBits = inputData[readHeaderLen +10];
    
28.                 drf1609.uartStopBits = inputData[readHeaderLen +11];
    
29.                 drf1609.uartParity = inputData[readHeaderLen +12];
    & Z% r0 N1 y" q% U  D+ y- M& Z. s
30.                 drf1609.X13X14 = inputData[readHeaderLen +13]*256 + inputData[readHeaderLen +14];
    
31.                 drf1609.antennaSelect = inputData[readHeaderLen +15];
    % B+ N: X( @4 g# }
32.                
    
33.                 //-------
    
34.                 for(i=0; i<8; i++)
    
35.                 {
    
36.                         drf1609.macAddress<i> = inputData[readHeaderLen +16 +i];
    
37.                 </i>}
    5 _8 f: K8 X3 V% r/ t# s+ S4 U
38.                
    
39.                 //--------
    
40.                 drf1609.prePointType = inputData[readHeaderLen +24];
    
41.                 drf1609.prePAN_ID = inputData[readHeaderLen +25]*256 + inputData[readHeaderLen +26];
    % [0 W# R, B5 `% ~. d4 W
42.                 drf1609.preChannel = inputData[readHeaderLen +27];
    , Z5 u( u2 A/ N- v1 a4 l+ R0 \
43.                 drf1609.preTransferModel = inputData[readHeaderLen +28];
    
44.                 drf1609.preUserAddress = inputData[readHeaderLen +29]*256 + inputData[readHeaderLen +30];
    - c( l! j3 \8 A# e, V, F) {
45.                 drf1609.X31X32 = inputData[readHeaderLen +31]*256 + inputData[readHeaderLen +32];
    
46.                 drf1609.preUartBraudRate = inputData[readHeaderLen +33];
    7 t- Y+ ^* h0 M, ~, ~
47.                 drf1609.preUartDataBits = inputData[readHeaderLen +34];
    
48.                 drf1609.preUartStopBits = inputData[readHeaderLen +35];
    
49.                 drf1609.preUartParity = inputData[readHeaderLen +36];
    + V4 D5 v6 d1 q1 @
50.                 drf1609.X37X38 = inputData[readHeaderLen +37]*256 + inputData[readHeaderLen +38];
    ( g7 ~* r5 S) c, }) I9 p8 g
51.                 drf1609.preAntennaSelect = inputData[readHeaderLen +39];
    1 D2 o! L+ w$ M# D+ l7 a
52.                
    
53.                 //-----------
    ( M! H1 v3 a/ q8 R9 R/ c
54.                 drf1609.shortAddress = inputData[readHeaderLen +40]*256 + inputData[readHeaderLen +41];
    * `$ J. n  V4 @* Y+ Z
55.                 drf1609.X42 = inputData[readHeaderLen +42];
    
56.                 drf1609.isSecurity = inputData[readHeaderLen +43];
    
57.                
    7 u; x  {9 i$ y: e
58.                 for(i=0; i<4; i++)
    " q4 D* d6 ]3 f- Y% y
59.                 {
    
60.                         drf1609.securityCode = inputData[readHeaderLen +44 +i];
    3 F. A6 q' m; B0 x3 H
61.                 }
    
62. 
    6 n# p. V6 m; M1 ~
63.                 result =1;
    
64.         }
    ' X/ F% Y4 h) u$ s( s( E
65. 
    5 Z% v. g8 V5 T4 G2 Q7 u
66.         return result;
    
67. }

复制代码

6 p% W* N" B: e( Q( I1 Q' R( o% d接着比较读出来的节点类型与要设置的节点类型是否一致，如果不一致的话，就重新写入要设置的节点类型：  

1.   if( drf1609H_setPontType != drf1609H_readPointType )

复制代码

: n, Q1 e9 q, e+ Y) L写的过程：
! N; ]4 t; E; `1，产生写入参数
2，写入
3，接收回复的参数，看看写入是否正确
* R% Y; o/ U) H; s$ L
& v- Y* `/ v  U% H7 ]$ ~

1.                 getWriteIns(drf1609);
   ! V. c4 q- D! i& o
2. 
   0 c" i5 s* b0 i. M0 b
3.                 drf1609h_writeModule();
   
4.                 HAL_UART_Receive( &huart1, receivedConfigData, 5, 500 );

复制代码

# i( K" ?: k6 m3 e% u1 ], Y* z8 b. i4 L写入正确以后，则重启模块（注意：DRF1609H的写入参数生效，都需要重启），这里是用一个IO口，控制DRF1609H的RESET脚拉低重启。

1. if( is_InsBack(receivedConfigData, 5) )
   
2.                 {
   2 m5 Z7 A" i  N4 J5 P9 E5 q0 _
3.                         if(receivedConfigData[2] == 0x0A)
   % L  N5 Q+ k7 n4 Y9 J
4.                         {
   
5.                                 drf1609h_reset();
   
6.                                 HAL_Delay(2000);
   
7.                                 drf1609h_status = drf1609h_powerOn;
   
8.                         }
   
9.                         else
   3 o4 {: I4 N/ b( _
10.                         {
    
11.                                 errorStart=1;
    
12.                         }
    
13.                 }
    
14.                 else
    
15.                 {
    
16.                         errorStart=1;
    - _8 ]; ?7 D7 d2 W# x' X+ d# o% C
17.                 }

复制代码

需要注意的是，getWriteIns(drf1609)，这个函数是把drf1609结构体，直接变换成写入指令，建议用户不要修改这部分，直接拷贝使用

1. //---------------------------------------------------
   
2. void  getWriteIns(_zigbeeParameters  inputParameter)
   9 u( u. T! a* g4 M- C, v# A" V0 n
3. {
   
4.         uint8_t   i=0;
   
5.         uint8_t  tempXY=0;
   6 l0 [7 t% C3 J. X0 Y/ t2 P) j
6.         
   
7.         writeIns[0]= 0xFC;
   * Z. U) l" V9 d0 M$ O
8.         writeIns[1]= 0x27;
   
9.         writeIns[2]= 0x07;
   5 V8 h& S" J; K: |9 U
10.         
    
11.         writeIns[writeHeaderLen +0]= inputParameter.pointType;
    ' z- F* e" N# C; V6 v. @+ D; f' ^, Q
12.         writeIns[writeHeaderLen +1]= (inputParameter.PAN_ID & 0xFF00)>>8;
    9 S1 S- I6 q1 `. m
13.         writeIns[writeHeaderLen +2]= inputParameter.PAN_ID & 0x00FF;
    9 G1 i8 O* i1 ?7 s* I6 P
14.         writeIns[writeHeaderLen +3]= inputParameter.Channel;
    
15.         writeIns[writeHeaderLen +4]= inputParameter.transferModel;
    3 }+ t! S3 R( y0 c- L' z2 R
16.         writeIns[writeHeaderLen +5]= (inputParameter.userAddress & 0xFF00)>>8;
    
17.         writeIns[writeHeaderLen +6]= inputParameter.userAddress & 0x00FF;
    
18.         writeIns[writeHeaderLen +7]= (inputParameter.X7X8 & 0xFF00)>>8;
    8 R2 c" m( I5 F7 l9 H
19.         writeIns[writeHeaderLen +8]= inputParameter.X7X8 & 0x00FF;
    
20.         writeIns[writeHeaderLen +9]= inputParameter.uartBraudRate;
    : h* x) p( k' ^* E% u4 A
21.         writeIns[writeHeaderLen +10]= inputParameter.uartDataBits;
    - {: M; ?( ^4 S$ k7 E% `( p4 q
22.         writeIns[writeHeaderLen +11]= inputParameter.uartStopBits;
    1 K3 _' ~2 h, u3 z# {. `
23.         writeIns[writeHeaderLen +12]= inputParameter.uartParity;
    
24.         writeIns[writeHeaderLen +13]= (inputParameter.X13X14 & 0xFF00)>>8;
    
25.         writeIns[writeHeaderLen +14]= inputParameter.X13X14 & 0x00FF;
    
26.         writeIns[writeHeaderLen +15]= inputParameter.antennaSelect;
    
27.         
    / Z& G9 f( J/ t
28.         writeIns[writeHeaderLen +16]= inputParameter.prePointType;
    4 N4 C; C& F) Y' a: J$ _
29.         writeIns[writeHeaderLen +17]= (inputParameter.prePAN_ID & 0xFF00)>>8;
    ( E# j3 Q. ?* q
30.         writeIns[writeHeaderLen +18]= inputParameter.prePAN_ID & 0x00FF;
    , L' A6 R. a5 I7 B
31.         writeIns[writeHeaderLen +19]= inputParameter.preChannel;
    
32.         writeIns[writeHeaderLen +20]= inputParameter.preTransferModel;
    
33.         writeIns[writeHeaderLen +21]= (inputParameter.preUserAddress & 0xFF00)>>8;
    ) R: c. |  c& d. [# g( F2 j
34.         writeIns[writeHeaderLen +22]= inputParameter.preUserAddress & 0x00FF;
    1 {/ z# h  B; K: f8 N/ R8 i
35.         writeIns[writeHeaderLen +23]= (inputParameter.X31X32 & 0xFF00)>>8;  //--AS ReadParameter's X31 X32
    5 @" _. B5 g& k2 x
36.         writeIns[writeHeaderLen +24]= inputParameter.X31X32 & 0x00FF;       //--AS ReadParameter's X31 X32
    
37.         writeIns[writeHeaderLen +25]= inputParameter.preUartBraudRate;
    7 s3 G9 Q1 Y5 j. f) i( a1 S
38.         writeIns[writeHeaderLen +26]= inputParameter.preUartDataBits;
    & T3 `& H: `; _, Y  W
39.         writeIns[writeHeaderLen +27]= inputParameter.preUartStopBits;
    
40.         writeIns[writeHeaderLen +28]= inputParameter.preUartParity;
    " e+ w; Z, K: S& i
41.         writeIns[writeHeaderLen +29]= (inputParameter.X37X38 & 0xFF00)>>8;  //--AS ReadParameter's X37 X38
    : s- i0 H; e  ?* D% X
42.         writeIns[writeHeaderLen +30]= inputParameter.X37X38 & 0x00FF;       //--AS ReadParameter's X37 X38
    
43.         writeIns[writeHeaderLen +31]= inputParameter.preAntennaSelect;
    + O! v) |' W2 n3 @
44.         writeIns[writeHeaderLen +32]= 0x1;
    . b. X8 P% D  ^0 `
45.         writeIns[writeHeaderLen +33]= inputParameter.isSecurity;
    
46.         
    & \& t: o: _0 E/ c6 g8 f  C5 r/ ?
47.         for(i=0; i<4; i++)
    # C& g+ \: S8 B: f8 w; C) |
48.         {
    7 S9 ^- ^3 l- @7 f6 {6 W
49.                 writeIns[writeHeaderLen +34 +i]= inputParameter.securityCode<span style="font-style: italic;"><span style="font-style: normal;">;
    - t' j- }7 D& Q( Q2 t+ W
50.         }
    
51.         
    : l+ w* J2 K# [
52.         tempXY = getXY(writeIns, writeInsLen);
    
53.         
    * t  r% w7 O0 K9 M4 `  M$ Y
54.         writeIns[writeInsLen-1]= tempXY;        
    ! C, t- v# q1 U4 @: {( a( d4 j
55. }</span></span>

复制代码

* L7 e+ x, b0 _  l; ]; e* M2，检测节点是否加入网络
检测节点是否加入网络，我们这里使用了读取DRF1609H节点信号强度指令，如果读取信号强度成功（回复的数据是正确的），则表明DRF1609H已经加入了网络并且与Coordinator通讯正常。
这个函数用来检测DRF1609H是否加入了网络，加入则回复1，没有则回复0：
3 U& R9 u( q/ h8 L5 X3 s: |) Y0 ^注意：这里是检测10次，没有加入也回复1，主要考虑在低功耗情况下，如果Coordinator没有开机，如果节点一直检测，则对耗电不利，用户应根据实际情况修改使用。
- ]  X( ?4 K  R% ^' ~

1. uint8_t  drf1609h_isJoinedNet()
   
2. 1
   0 N" N" V5 k# o$ E; _
3. //----------------------
   ! X9 T8 o/ ?  U; A- \5 r$ P. z% `
4. uint8_t  drf1609h_isJoinedNet()
   
5. {
   6 Y3 c6 c0 Y$ A* T, x  [. n
6.         uint8_t   result=0;
   3 h. X6 d' U5 ^; H3 N
7.         uint8_t   i=0;
   & t! m8 I+ X8 s1 G
8. 
   2 o: Y$ K6 i. F& _4 v- Z# B
9.         //MX_USART1_UART_Init();
   + @8 _- M" `3 J
10.         //HAL_Delay(10);
    " S, _; r+ V/ k0 d
11.         for(i=0; i<8; i++)
    
12.         {
    + Y% _$ T$ h" p; O2 O7 Q
13.                 receivedSignalData<span style="font-style: italic;"><span style="font-style: normal;">=0;
    
14.         }
    
15. 
    , m5 e9 }/ ~8 s  x0 w
16.         drf1609h_requestSignalIndex();
    , W2 P# z- k4 t. ^& D! L; ^  E$ I0 x; w
17.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
    
18.         HAL_Delay(1000);
    6 Y7 {8 a" G! B* m" m7 }. H# g  o
19. 
    
20.         if( checkSignalData(receivedSignalData, 8) )
    $ l) o4 c& n9 a9 ^$ m* n* t) S. D7 L
21.         {
    1 w9 y% M, W+ G2 ~9 ?$ p1 o5 M5 [
22.                 result=1;
    0 q6 S9 G7 p2 T4 B; D' Q0 n$ a
23.                 receivedSignalData[8] = drf1609.pointType;
    
24.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
    
25.         }
    0 A1 E0 h! j' Y' N& w: U% g6 X6 O" S
26.         else
    ' x# m/ t- p' o- Z% }& W) d; f
27.         {
    
28.                 haveTryToJoinTimers++;
    
29.                 if(haveTryToJoinTimers >= maxJoinTimers)
    
30.                 {
    ( u8 l3 \& ~4 s& ]# H
31.                         result=1;
    $ F$ w( Q% S, |1 m% D) I. R
32.                 }
    
33.                 else
    8 q: v& c/ T' h2 q1 U6 ^( N
34.                 {
    
35.                         result=0;
    
36.                 }
    
37.         }
    
38. 
    
39. 
    
40.         return   result;
    
41. }</span></span>

复制代码

检测的过程：
1，发送读取信号强度指令
2，等待接收回复数据
9 c  v) t' {  ]  s3，如果接收回复数据成功（已经加入网络），这里将收到的数据加上自己的节点类型发送给Coordinator，通知节点已经加入成功

4 \! L( L6 J  `; t: l2 y

1.         drf1609h_requestSignalIndex();
   
2.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   5 g7 \5 p! H5 A: m" H9 R1 B
3.         HAL_Delay(1000);
   
4. 
   
5.         if( checkSignalData(receivedSignalData, 8) )
   % [$ e' z& |' d* s" G: `
6.         {
   9 G9 P5 F* O: G- _6 D  W9 Q9 O; X
7.                 result=1;
   : n2 A" u2 L6 h' M' _9 @
8.                 receivedSignalData[8] = drf1609.pointType;
   
9.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
   
10.         }

复制代码

3，启动节点自动加入网络
) J4 e9 M$ w% d: H+ t' C2 r% `如果连按三次DRF1609H的Function按键，则开始自动扫描，如果扫描到Coordinator，则可以自动加入网络，并从Coordinator处获得“给Router预设的参数”，所以节点是不要设置的，我们节点的板子上也没有把DRF1609H的串口留出来，而是通过连按三次按键，自动加入网络，自动取得参数。
# [2 O- v" Y) J  |" `1，检测DRF1609H是否加入网络，用的是读取信号强度的指令
2，如果没有加入网络，则启动自动加入网络
3，启动后，等待12秒，再读取信号强度，判断是否加入了网络
& J$ S8 H7 l4 l# h% Q$ d( M注意，板子上有按键，如果是低功耗模式，建议不要启动这个功能，用按键手工加入网络，如果Coordinator没开机，一直扫描网络，会很快耗光电池。

4 i1 g/ C# G: k' b

1.         //-- Do 5 timers get Signal Index ----//
   
2.         for(i=0; i<5; i++)
   $ ]1 c7 y8 l" h. W1 W/ d* ]; ~8 t
3.         {
   
4.                 drf1609h_requestSignalIndex();
   6 |7 i7 Z, S9 s* h% p( T- J! Y
5.                 HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   - R( `/ x/ U" g$ B7 P
6.                 HAL_Delay(500);
   
7. 
   3 |* i3 |0 x1 e6 f
8.                 if( checkSignalData(receivedSignalData, 8) )
   5 y* `% s$ P- B! h9 M3 o& m
9.                 {
   
10.                         tempVal++;
    ; o8 V  R, g+ L* F; o9 J
11.                         i=5;
    
12.                 }
    & R" n) G5 a  {7 T8 @
13.                 else
    
14.                 {
    
15.                         notGetSignalVal++;
    ) n7 _% W+ E6 M
16.                 }
    
17.         }

复制代码

1.             drf1609h_autoJoinNet_Start();
     }6 A8 d0 P) C, ~, V1 V# f) T
2.             HAL_Delay(12000);

复制代码

' a  g9 o  k1 S7 `# ~进去自动加入网络的代码看看，其实就是模拟三次按键：
0 {' l0 }/ M8 P, c7 G6 [开始以后，DRF1609H上的2个灯会快闪，观察到一个灯灭，一个灯慢闪以后，说明已经加入网络。

. F( k1 e# @5 t: }0 m. G

1. //---------------------------------------
   ( m2 ~6 S# O, Y# p, ]3 ]1 e, X
2. /*   This Simulate Function Key to start
   . k9 ^( A1 ^- i8 R. {+ z8 E6 |, _
3. *   point auto join net
   
4. *   ____    ______    ______    ______
   4 c4 I: K" v& u
5. *       |__|      |__|      |__|
   6 I9 A0 O- g$ Y& x) [2 n; e
6. *
   7 K; J' I9 ~. W5 {+ z8 u
7. *       120  200  120  200  120  200
   
8. *
   
9. *   ----------------------------------*/
   & E0 Q$ s5 J. n
10. void  drf1609h_autoJoinNet_Start()
    ( F: u/ T8 }, |1 r% y/ E
11. {
    $ ]+ f$ p5 p' B
12.         uint8_t  i=0;
    
13. 
    
14.         set_autoJoinNetPin_output();
    
15.         set_autoJoinNetPin_out_1();
    
16.         HAL_Delay(100);
    
17. 
    ! c) `3 F$ }& t! }
18.         for(i=0; i<3; i++)
    
19.         {
    % `: j* I0 o* V, t2 \7 |& M2 G' p. a8 _) @
20.                 set_autoJoinNetPin_out_0();
    / P- @! @6 I0 M8 }1 ^3 v
21.                 HAL_Delay(120);
    
22. 
    
23.                 set_autoJoinNetPin_out_1();
    7 J* g2 s, B8 `8 m: |
24.                 HAL_Delay(200);
    4 p4 v  B% V& ]
25.         }
    % _1 C. D: i) J  z; w- P; E9 ]( N
26. 
    / @$ `7 F' H1 [, E' S; e
27.         set_autoJoinNetPin_input();
    3 [, u+ y! ]9 _- B0 @" e! \
28. }

复制代码

4 k) c. c% a7 V# E3 K# o4，DRF1609H的相关指令
主要有读取参数、读取信号强度、写入参数等指令，项目里面都已经列出来了
如果需要增加其它的功能，要参考DRF1609H的说明书

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
   ) u5 `8 q, \5 @& s, d
3. uint8_t    readIns[9] = {0xFC, 0x06, 0x0E, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x8B};      //---INS05
   1 d/ Z/ |8 N# `: d  l
4. uint8_t    writeIns[42];   //--INS06
   4 W6 |5 k5 |, `
5. uint8_t    requestSignalIns[9] = {0xFC, 0x06, 0x0C, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x89};    //--INS08

复制代码

+ c% J( s" }) V

8 z, l& N2 g9 G  {5 x( ]