本项目中使用了Zigbee模块（DRF1609H），作为无线数据传输使用，初始化DRF1609H主要涉及以下几个方面的内容：
$ c$ t/ N) G9 R1，设置节点的类型，可以设置为：Router、End Device。Zigbee网络有3种类型的节点：Coordinator、Router、End Device，Cordinator接在电脑上面收集数据，我们这里是采集节点，所以只设置为Router或End Device。
2，检测节点是否加入了网络
' V0 ~5 D8 ^5 x( Z' s0 u3，如果节点没有加入网络，则启动自动扫描加入网络
/ {9 y4 Q1 O2 i$ n  g: Z0 T
1，节点类型的设置：
& X4 G7 N$ N" J首先读取DRF1609H的参数：G031向DRF1609H发送读取参数指令，发完参数后，有一个500MS的超时等待参数的回复，参数回复总共是53个字节，放在receiveConfigData里面。

7 e5 n. E! h: Z

1.         //--Read DRF1609H Configures --
   0 l8 G' p5 O) N  z* A
2.         drf1609h_readModule();
   
3.         HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );

复制代码

1. //------------------------------
   
2. void  drf1609h_readModule(void)
   
3. {
   5 U" H( J7 G  ]; N6 b4 Z
4.         drf1609h_sendedIns = sendIns_read;
   
5.         HAL_UART_Transmit_DMA( &huart1, readIns, 9 );
   ' P! @% ~# P. j" T
6. }

复制代码

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

1.         //---If DRF1609H Error or Read Error ------
   ) N! \) B3 X1 m" t4 V3 y
2.         while( readParameterProcess(receivedConfigData, 53) == 0 )
   
3.         {
   
4.                 drf1609h_readModule();
   ' m7 M3 K8 A9 p! g
5.                 HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );
   
6.         }

复制代码

1. //------------------------------
   6 ?: W1 p( m  \! k+ z2 K- r
2. uint8_t  readParameterProcess(uint8_t  *inputData,  uint16_t  inputLen)
   
3. {
   
4.         uint8_t  result=0;
   0 o. g( f) G6 z/ B* U1 g
5. 
   : F0 R% \  F' ^' v1 S: o
6.         uint8_t  tempXY=0;
   
7.         uint8_t  tempRight=0;
   
8.         uint8_t  i=0;
   - [+ g* \! z) l5 D+ e3 W! }6 p8 c
9.         
   : G  b% }" _) H/ t* y+ j
10.         tempXY = getXY(inputData, inputLen);
    # d$ h1 Y& }/ O+ Q5 p
11.         
    . g" p) f# r& j. S. y) L- ?  k
12.         if(inputData[0]==0xFA) { tempRight++; }
    
13.         if(inputData[1]==0x31) { tempRight++; }
    
14.         if(inputData[2]==0x0A) { tempRight++; }
    ' _, q; N. Z+ l: s
15.         if(inputData[inputLen-1]==tempXY) { tempRight++; }
    
16.         
    : F0 g/ x+ A! R+ U. o2 w
17.         if(tempRight==4)
    
18.         {
    6 `( R0 r0 h& F2 {
19.                 //------
    
20.                 drf1609.pointType = inputData[readHeaderLen +0];
    2 w2 E' m: n. H/ a4 O: k
21.                 drf1609.PAN_ID = inputData[readHeaderLen +1]*256 + inputData[readHeaderLen +2];
    % A& J: R( H2 x* _0 B
22.                 drf1609.Channel = inputData[readHeaderLen +3];
    ) Q& N' N" H) D7 W
23.                 drf1609.transferModel = inputData[readHeaderLen +4];
    3 m4 L2 W+ o' {3 |
24.                 drf1609.userAddress = inputData[readHeaderLen +5]*256 + inputData[readHeaderLen +6];
    . p! h- e( R; k* o* x; M* Z
25.                 drf1609.X7X8 = inputData[readHeaderLen +7]*256 + inputData[readHeaderLen +8];
    
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];
    9 t& ?1 `! a4 M5 T1 d: `
32.                
    ' {* `8 P% _, W0 A
33.                 //-------
    
34.                 for(i=0; i<8; i++)
    
35.                 {
    # }9 U1 S- h( g7 J2 [
36.                         drf1609.macAddress<i> = inputData[readHeaderLen +16 +i];
    / E. |* N* N3 v* A  m
37.                 </i>}
    
38.                
    1 ~4 |) I1 d* C+ U: h. {
39.                 //--------
    & P( ^: g  b: Z4 k4 }6 Z5 f& g7 M9 a
40.                 drf1609.prePointType = inputData[readHeaderLen +24];
    4 O( J% J, Y" c3 [
41.                 drf1609.prePAN_ID = inputData[readHeaderLen +25]*256 + inputData[readHeaderLen +26];
    
42.                 drf1609.preChannel = inputData[readHeaderLen +27];
    $ y" i8 g$ D; e
43.                 drf1609.preTransferModel = inputData[readHeaderLen +28];
    
44.                 drf1609.preUserAddress = inputData[readHeaderLen +29]*256 + inputData[readHeaderLen +30];
    9 D- D4 Z' u- w! [3 L
45.                 drf1609.X31X32 = inputData[readHeaderLen +31]*256 + inputData[readHeaderLen +32];
    
46.                 drf1609.preUartBraudRate = inputData[readHeaderLen +33];
    
47.                 drf1609.preUartDataBits = inputData[readHeaderLen +34];
    - ?1 h  x4 K: J: d& `
48.                 drf1609.preUartStopBits = inputData[readHeaderLen +35];
    
49.                 drf1609.preUartParity = inputData[readHeaderLen +36];
    $ D! l& k3 f1 Q' ^
50.                 drf1609.X37X38 = inputData[readHeaderLen +37]*256 + inputData[readHeaderLen +38];
    8 T5 z" }, F. j, w' x% t+ ?
51.                 drf1609.preAntennaSelect = inputData[readHeaderLen +39];
    5 p/ X. A) E3 N- O7 @
52.                
    
53.                 //-----------
    $ Q/ u7 W" d' q
54.                 drf1609.shortAddress = inputData[readHeaderLen +40]*256 + inputData[readHeaderLen +41];
    : F: W$ B, j0 D% }+ s+ d) [
55.                 drf1609.X42 = inputData[readHeaderLen +42];
    
56.                 drf1609.isSecurity = inputData[readHeaderLen +43];
    5 p1 G3 F- V! Z& a$ V
57.                
    * V3 H0 I/ I# _9 l
58.                 for(i=0; i<4; i++)
    
59.                 {
    1 G! R8 ^) w, L+ o0 g; Z1 F
60.                         drf1609.securityCode = inputData[readHeaderLen +44 +i];
    4 ]; S) O: C3 F
61.                 }
    
62. 
    
63.                 result =1;
    ) ]; O  }9 y& p) U4 l5 u0 t# h
64.         }
    ! E  V. @8 @' v1 C( ^. z% ]
65. 
    
66.         return result;
    
67. }

复制代码

  K! J; I% Q  I& B7 y接着比较读出来的节点类型与要设置的节点类型是否一致，如果不一致的话，就重新写入要设置的节点类型：  

1.   if( drf1609H_setPontType != drf1609H_readPointType )

复制代码

% \# c9 M( [  J5 b- ]& W6 A写的过程：
6 k1 L0 @5 w: G: N7 b1，产生写入参数
2，写入
" K6 ?8 z7 R3 }! j3，接收回复的参数，看看写入是否正确
  Q5 a. }- r+ p) A! Z
9 l; w! P" h/ M4 \; F9 y6 K

1.                 getWriteIns(drf1609);
   % c3 y& q5 i. s5 `
2. 
   % I. N, Q2 q8 B3 H) T. u9 r0 ^+ ~
3.                 drf1609h_writeModule();
   ; c, n& p9 d6 K
4.                 HAL_UART_Receive( &huart1, receivedConfigData, 5, 500 );

复制代码

. V& r- D" S, d3 ^0 @4 w" e写入正确以后，则重启模块（注意：DRF1609H的写入参数生效，都需要重启），这里是用一个IO口，控制DRF1609H的RESET脚拉低重启。
) w( R/ s1 B* p  W

1. if( is_InsBack(receivedConfigData, 5) )
   
2.                 {
   7 Y1 [6 e5 n: h6 v$ g# x
3.                         if(receivedConfigData[2] == 0x0A)
   
4.                         {
   , L; k- g9 H# P1 t; ?* {. C! Y
5.                                 drf1609h_reset();
   
6.                                 HAL_Delay(2000);
   9 S+ N( w( h" I
7.                                 drf1609h_status = drf1609h_powerOn;
   
8.                         }
   * z) ?4 y3 T) f& Q, `( Z
9.                         else
   2 c: w+ e. v' e$ x9 q1 N
10.                         {
    1 `: [7 O$ }# ^6 I+ b# j( A
11.                                 errorStart=1;
    
12.                         }
    1 {6 b, \' @, J2 J2 Q
13.                 }
    
14.                 else
    
15.                 {
    
16.                         errorStart=1;
    
17.                 }

复制代码

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

( v3 ]5 C8 ~/ o4 c2 m3 U  J

1. //---------------------------------------------------
   
2. void  getWriteIns(_zigbeeParameters  inputParameter)
     {) ^( C6 d, F9 D: o
3. {
   " y# A3 m$ l* }! i9 u
4.         uint8_t   i=0;
   1 }# T! F" U. {& g/ \4 m: h* a
5.         uint8_t  tempXY=0;
   
6.         
   
7.         writeIns[0]= 0xFC;
   2 o+ u( ~( u3 `' ~
8.         writeIns[1]= 0x27;
   
9.         writeIns[2]= 0x07;
   
10.         
    
11.         writeIns[writeHeaderLen +0]= inputParameter.pointType;
    # y5 X+ c9 n7 ?, |4 x* q
12.         writeIns[writeHeaderLen +1]= (inputParameter.PAN_ID & 0xFF00)>>8;
    
13.         writeIns[writeHeaderLen +2]= inputParameter.PAN_ID & 0x00FF;
    
14.         writeIns[writeHeaderLen +3]= inputParameter.Channel;
    - j; c6 L! L( M+ w8 v; N
15.         writeIns[writeHeaderLen +4]= inputParameter.transferModel;
    1 Q# F* L; ?' x) ]5 f# a
16.         writeIns[writeHeaderLen +5]= (inputParameter.userAddress & 0xFF00)>>8;
    
17.         writeIns[writeHeaderLen +6]= inputParameter.userAddress & 0x00FF;
    
18.         writeIns[writeHeaderLen +7]= (inputParameter.X7X8 & 0xFF00)>>8;
    
19.         writeIns[writeHeaderLen +8]= inputParameter.X7X8 & 0x00FF;
    
20.         writeIns[writeHeaderLen +9]= inputParameter.uartBraudRate;
    
21.         writeIns[writeHeaderLen +10]= inputParameter.uartDataBits;
    - i0 ^2 [: S) m; }+ E
22.         writeIns[writeHeaderLen +11]= inputParameter.uartStopBits;
    
23.         writeIns[writeHeaderLen +12]= inputParameter.uartParity;
    3 {) j. K1 N# k. G' \5 H; ]% R% S# \
24.         writeIns[writeHeaderLen +13]= (inputParameter.X13X14 & 0xFF00)>>8;
    
25.         writeIns[writeHeaderLen +14]= inputParameter.X13X14 & 0x00FF;
    
26.         writeIns[writeHeaderLen +15]= inputParameter.antennaSelect;
    $ x( i. c3 q! {* O0 @
27.         
    . M+ [+ C6 n4 u
28.         writeIns[writeHeaderLen +16]= inputParameter.prePointType;
    ( [' m8 I/ {% H: l, b
29.         writeIns[writeHeaderLen +17]= (inputParameter.prePAN_ID & 0xFF00)>>8;
    
30.         writeIns[writeHeaderLen +18]= inputParameter.prePAN_ID & 0x00FF;
    ' K, _6 i- w& o
31.         writeIns[writeHeaderLen +19]= inputParameter.preChannel;
    * w/ @& X& R% K* T" r/ Y; A+ Q
32.         writeIns[writeHeaderLen +20]= inputParameter.preTransferModel;
    
33.         writeIns[writeHeaderLen +21]= (inputParameter.preUserAddress & 0xFF00)>>8;
    # V5 c1 N9 B% |
34.         writeIns[writeHeaderLen +22]= inputParameter.preUserAddress & 0x00FF;
    % }: z( @9 k" F0 ^9 r, m7 d
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
    ' w) ]6 K! D. v" u; M1 ~/ `' p0 D' U
37.         writeIns[writeHeaderLen +25]= inputParameter.preUartBraudRate;
    ' u2 j" g# w3 M* t
38.         writeIns[writeHeaderLen +26]= inputParameter.preUartDataBits;
    * \9 y" U0 n. _5 m* I2 \. v
39.         writeIns[writeHeaderLen +27]= inputParameter.preUartStopBits;
    
40.         writeIns[writeHeaderLen +28]= inputParameter.preUartParity;
    % K$ o1 x. S7 Z* {
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
    
43.         writeIns[writeHeaderLen +31]= inputParameter.preAntennaSelect;
    
44.         writeIns[writeHeaderLen +32]= 0x1;
    
45.         writeIns[writeHeaderLen +33]= inputParameter.isSecurity;
    : C. U* ]0 H8 k$ R! e% [
46.         
    
47.         for(i=0; i<4; i++)
    6 R6 ^* \' l) C+ s9 o1 |. C8 w1 X
48.         {
    
49.                 writeIns[writeHeaderLen +34 +i]= inputParameter.securityCode<span style="font-style: italic;"><span style="font-style: normal;">;
    5 E: l' S( K! X
50.         }
    ' f3 ^: [9 J- X. s) O
51.         
    
52.         tempXY = getXY(writeIns, writeInsLen);
    
53.         
    ) p0 V' K7 p; P* O2 \: Y# J
54.         writeIns[writeInsLen-1]= tempXY;        
    
55. }</span></span>

复制代码

" X0 j& x! n: x2，检测节点是否加入网络
检测节点是否加入网络，我们这里使用了读取DRF1609H节点信号强度指令，如果读取信号强度成功（回复的数据是正确的），则表明DRF1609H已经加入了网络并且与Coordinator通讯正常。
这个函数用来检测DRF1609H是否加入了网络，加入则回复1，没有则回复0：
) M# w1 V" S  B8 S9 _注意：这里是检测10次，没有加入也回复1，主要考虑在低功耗情况下，如果Coordinator没有开机，如果节点一直检测，则对耗电不利，用户应根据实际情况修改使用。
5 V8 X* w. T+ `% Q# x
& `+ d2 @+ v+ s  T3 L; }

1. uint8_t  drf1609h_isJoinedNet()
   
2. 1
   + [) d7 p; V! e: o) ^1 p; A
3. //----------------------
   9 _% V! v1 C! X
4. uint8_t  drf1609h_isJoinedNet()
   
5. {
   
6.         uint8_t   result=0;
   1 O7 G0 |0 \/ j0 f- `
7.         uint8_t   i=0;
   $ V6 K6 s+ f7 l+ b# ^) z
8. 
   5 v! v& Q0 m' g+ ]
9.         //MX_USART1_UART_Init();
   
10.         //HAL_Delay(10);
    
11.         for(i=0; i<8; i++)
    " T6 }3 X  O# _! R2 g3 M
12.         {
    " s8 D' ]3 u5 [$ `% v6 l+ W, H
13.                 receivedSignalData<span style="font-style: italic;"><span style="font-style: normal;">=0;
    
14.         }
    ) m3 |1 R. u) `" |
15. 
    
16.         drf1609h_requestSignalIndex();
    / x, j5 h3 }3 K2 P
17.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
    
18.         HAL_Delay(1000);
    . K& |) `3 I5 m$ `9 y3 U! K# u
19. 
    
20.         if( checkSignalData(receivedSignalData, 8) )
    
21.         {
    
22.                 result=1;
    8 L9 E2 L8 h2 `1 v
23.                 receivedSignalData[8] = drf1609.pointType;
    % S" e3 a' I$ w9 O; l+ k5 b3 J
24.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
    
25.         }
    + u0 ^' {2 R( V, I: ~, f% B
26.         else
    
27.         {
    
28.                 haveTryToJoinTimers++;
    
29.                 if(haveTryToJoinTimers >= maxJoinTimers)
    
30.                 {
    5 V* e2 E: S! b* ~% N4 w
31.                         result=1;
    1 N) f0 @. X: I. d5 c
32.                 }
    & W7 c& n. v0 t; V3 {  C
33.                 else
    
34.                 {
    
35.                         result=0;
    : I' a7 q: a9 T5 m; ^3 R8 L
36.                 }
    
37.         }
    7 o* z5 s2 z' B( O8 O
38. 
    
39. 
    ) x2 R9 v3 x3 `; {
40.         return   result;
    
41. }</span></span>

复制代码

) M! j& t: w+ K  g检测的过程：
0 n5 I- m; p) z( J5 D1，发送读取信号强度指令
2，等待接收回复数据
9 a9 N9 F# n( f1 L5 \3，如果接收回复数据成功（已经加入网络），这里将收到的数据加上自己的节点类型发送给Coordinator，通知节点已经加入成功
& v! N) D3 a4 g/ ?+ C
1 @4 y* q/ r8 F& o/ ^" }

1.         drf1609h_requestSignalIndex();
   
2.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   
3.         HAL_Delay(1000);
   
4. 
   * N; r. w/ Q* H) k; z
5.         if( checkSignalData(receivedSignalData, 8) )
   8 e' _+ n, c2 N: c+ f
6.         {
   
7.                 result=1;
   
8.                 receivedSignalData[8] = drf1609.pointType;
   % A1 S9 i& o! U( p* R" I* S; W
9.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
   
10.         }

复制代码

9 [- m3 a6 r, V3，启动节点自动加入网络
2 G3 R7 C9 h, ^6 G; x" L, b如果连按三次DRF1609H的Function按键，则开始自动扫描，如果扫描到Coordinator，则可以自动加入网络，并从Coordinator处获得“给Router预设的参数”，所以节点是不要设置的，我们节点的板子上也没有把DRF1609H的串口留出来，而是通过连按三次按键，自动加入网络，自动取得参数。
1，检测DRF1609H是否加入网络，用的是读取信号强度的指令
; b4 r$ w2 E0 @5 a5 N' }2，如果没有加入网络，则启动自动加入网络
8 M4 E8 k! F; J0 Q3，启动后，等待12秒，再读取信号强度，判断是否加入了网络
3 [" p5 W$ I4 N& p, F; {注意，板子上有按键，如果是低功耗模式，建议不要启动这个功能，用按键手工加入网络，如果Coordinator没开机，一直扫描网络，会很快耗光电池。

( B2 }1 V: Z3 \' Z9 ]& o

1.         //-- Do 5 timers get Signal Index ----//
   / x3 [% z1 l/ [' X+ @* ]
2.         for(i=0; i<5; i++)
   
3.         {
   
4.                 drf1609h_requestSignalIndex();
   
5.                 HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   7 \! \: `- N2 v" ~& K( O( W, D9 _
6.                 HAL_Delay(500);
   
7. 
   - K: N3 J9 m, Y) I0 f" a4 i+ n& T
8.                 if( checkSignalData(receivedSignalData, 8) )
   
9.                 {
   
10.                         tempVal++;
    4 n+ J: q6 e# t7 q
11.                         i=5;
    . C# R( A( E9 c4 k
12.                 }
    4 U5 C$ f8 \4 R& H
13.                 else
    
14.                 {
    $ w" q+ c! y5 s1 d' D- `, [
15.                         notGetSignalVal++;
    
16.                 }
    
17.         }

复制代码

1.             drf1609h_autoJoinNet_Start();
   % i& p9 C: |2 e9 F/ J  M9 K$ s' ?
2.             HAL_Delay(12000);

复制代码

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

# n# B% u; U, z5 ?

1. //---------------------------------------
   
2. /*   This Simulate Function Key to start
   ' B' Q: p" w' ?5 O- [
3. *   point auto join net
   
4. *   ____    ______    ______    ______
   / `& `, |& B1 i+ i4 d4 W
5. *       |__|      |__|      |__|
   ! F( ^/ D8 p+ u6 o" S( R
6. *
   
7. *       120  200  120  200  120  200
   - X4 g! L" P+ I. }/ C" _0 l
8. *
   
9. *   ----------------------------------*/
   3 _$ ?# n& q( X6 O  W; h
10. void  drf1609h_autoJoinNet_Start()
    
11. {
    6 g* a: q5 R0 x( O( t' o3 R1 }5 t! p
12.         uint8_t  i=0;
    
13. 
    
14.         set_autoJoinNetPin_output();
    ) |8 O, r7 [( \# M' ~: d
15.         set_autoJoinNetPin_out_1();
    
16.         HAL_Delay(100);
    1 G# s* W  S  r4 q% U) m8 w
17. 
    
18.         for(i=0; i<3; i++)
    
19.         {
    3 V; _$ ~, e: |) f! z
20.                 set_autoJoinNetPin_out_0();
    
21.                 HAL_Delay(120);
    % d$ U# I( P+ @
22. 
    
23.                 set_autoJoinNetPin_out_1();
    & o% F& q' p% |2 ]: M2 J" r; o1 w
24.                 HAL_Delay(200);
    ; E9 P4 {3 w$ o* z7 b: B  \
25.         }
    
26. 
    
27.         set_autoJoinNetPin_input();
    " u, r' k6 s! m7 m  G( ~$ n% P
28. }

复制代码

4，DRF1609H的相关指令
( M7 G1 Y) L0 G4 b" ~; X( B& E主要有读取参数、读取信号强度、写入参数等指令，项目里面都已经列出来了
0 z1 _3 y( |8 @' }如果需要增加其它的功能，要参考DRF1609H的说明书
/ D' |4 P* q3 v8 d

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
   
3. uint8_t    readIns[9] = {0xFC, 0x06, 0x0E, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x8B};      //---INS05
   
4. uint8_t    writeIns[42];   //--INS06
   ( G7 Y2 ?1 k# E
5. uint8_t    requestSignalIns[9] = {0xFC, 0x06, 0x0C, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x89};    //--INS08

复制代码