本项目中使用了Zigbee模块（DRF1609H），作为无线数据传输使用，初始化DRF1609H主要涉及以下几个方面的内容：
1，设置节点的类型，可以设置为：Router、End Device。Zigbee网络有3种类型的节点：Coordinator、Router、End Device，Cordinator接在电脑上面收集数据，我们这里是采集节点，所以只设置为Router或End Device。
2，检测节点是否加入了网络
3，如果节点没有加入网络，则启动自动扫描加入网络
7 |! p9 V( Y2 r. |9 H
1，节点类型的设置：
首先读取DRF1609H的参数：G031向DRF1609H发送读取参数指令，发完参数后，有一个500MS的超时等待参数的回复，参数回复总共是53个字节，放在receiveConfigData里面。

1.         //--Read DRF1609H Configures --
   
2.         drf1609h_readModule();
   9 M% H9 d6 Z  L* h4 L
3.         HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );

复制代码

1. //------------------------------
   
2. void  drf1609h_readModule(void)
   
3. {
   
4.         drf1609h_sendedIns = sendIns_read;
   % x( d, e$ j0 }! ]
5.         HAL_UART_Transmit_DMA( &huart1, readIns, 9 );
   
6. }

复制代码

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

1.         //---If DRF1609H Error or Read Error ------
   
2.         while( readParameterProcess(receivedConfigData, 53) == 0 )
   - A0 I2 o# J6 q. }. i
3.         {
   ; ^( ^- v% O' R) T
4.                 drf1609h_readModule();
   * O6 O. t+ }  A  o
5.                 HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );
   
6.         }

复制代码

1. //------------------------------
   8 d$ H' a3 M. E, B; j
2. uint8_t  readParameterProcess(uint8_t  *inputData,  uint16_t  inputLen)
   
3. {
   
4.         uint8_t  result=0;
   # g! b3 {( E  L) a: ~
5. 
   3 N! X& _; w( |1 O  w4 A* T+ S
6.         uint8_t  tempXY=0;
   , N4 K% X4 l# I( S
7.         uint8_t  tempRight=0;
   ) |* [3 i9 |" T  }" q0 L6 y
8.         uint8_t  i=0;
   ! m. ^) T' v( R: C
9.         
   
10.         tempXY = getXY(inputData, inputLen);
    
11.         
    3 l1 N/ ]4 J& R) q! S0 [
12.         if(inputData[0]==0xFA) { tempRight++; }
    ) u5 K$ @( v- a- d) D- \) q
13.         if(inputData[1]==0x31) { tempRight++; }
    ! q' {; n4 F: j7 z+ ~" K) @
14.         if(inputData[2]==0x0A) { tempRight++; }
    
15.         if(inputData[inputLen-1]==tempXY) { tempRight++; }
    
16.         
    $ r! [. r/ {$ j) V
17.         if(tempRight==4)
    
18.         {
      l) o- |6 l0 v. C$ ~
19.                 //------
    ) R6 @. f, j/ H0 l: {3 t1 T
20.                 drf1609.pointType = inputData[readHeaderLen +0];
    
21.                 drf1609.PAN_ID = inputData[readHeaderLen +1]*256 + inputData[readHeaderLen +2];
    & c$ W# z+ V9 C5 D1 \
22.                 drf1609.Channel = inputData[readHeaderLen +3];
      z# a: ]2 I' o7 ]8 C% Q2 U. M9 T' B
23.                 drf1609.transferModel = inputData[readHeaderLen +4];
    
24.                 drf1609.userAddress = inputData[readHeaderLen +5]*256 + inputData[readHeaderLen +6];
    ; b8 U% Y: A0 s7 q3 k2 n/ h
25.                 drf1609.X7X8 = inputData[readHeaderLen +7]*256 + inputData[readHeaderLen +8];
    
26.                 drf1609.uartBraudRate = inputData[readHeaderLen +9];
    3 M1 i5 q/ w, T" y% U) V  w8 t
27.                 drf1609.uartDataBits = inputData[readHeaderLen +10];
    4 M% W% U, g4 M+ a
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];
    ; `4 N$ r* [) {+ h
32.                
    ! E7 K# p% l: {8 F# x8 i! g
33.                 //-------
    
34.                 for(i=0; i<8; i++)
    * G* f5 Y9 ~# W" Z
35.                 {
    7 m, g# N9 d/ c2 K
36.                         drf1609.macAddress<i> = inputData[readHeaderLen +16 +i];
    ! {1 j% ?' b( G/ Z
37.                 </i>}
    ! H: ~2 u+ V* J6 r# d3 S0 }. @& W
38.                
    
39.                 //--------
    9 D" ^6 J5 R5 R/ T  D+ e" W$ ]$ R
40.                 drf1609.prePointType = inputData[readHeaderLen +24];
    
41.                 drf1609.prePAN_ID = inputData[readHeaderLen +25]*256 + inputData[readHeaderLen +26];
    , @; e' I' w" |9 V
42.                 drf1609.preChannel = inputData[readHeaderLen +27];
    1 L0 l6 w; ?9 P- N  W
43.                 drf1609.preTransferModel = inputData[readHeaderLen +28];
    
44.                 drf1609.preUserAddress = inputData[readHeaderLen +29]*256 + inputData[readHeaderLen +30];
    $ ^3 C; B. N( N0 Q" C
45.                 drf1609.X31X32 = inputData[readHeaderLen +31]*256 + inputData[readHeaderLen +32];
    
46.                 drf1609.preUartBraudRate = inputData[readHeaderLen +33];
    
47.                 drf1609.preUartDataBits = inputData[readHeaderLen +34];
    / f) |" e8 ^8 [8 t
48.                 drf1609.preUartStopBits = inputData[readHeaderLen +35];
    
49.                 drf1609.preUartParity = inputData[readHeaderLen +36];
    
50.                 drf1609.X37X38 = inputData[readHeaderLen +37]*256 + inputData[readHeaderLen +38];
    
51.                 drf1609.preAntennaSelect = inputData[readHeaderLen +39];
    
52.                
    $ R' n6 ?1 Z, z
53.                 //-----------
    
54.                 drf1609.shortAddress = inputData[readHeaderLen +40]*256 + inputData[readHeaderLen +41];
    
55.                 drf1609.X42 = inputData[readHeaderLen +42];
    
56.                 drf1609.isSecurity = inputData[readHeaderLen +43];
    , f4 o% \/ e/ ~9 l3 K
57.                
    
58.                 for(i=0; i<4; i++)
    3 T& X; a( B9 b" p. c
59.                 {
    9 A6 P7 F& ~0 X1 L; b
60.                         drf1609.securityCode = inputData[readHeaderLen +44 +i];
    2 K( i0 U1 G  y1 u, Q$ {: K
61.                 }
    / o. X5 R% I! O" d- L% u
62. 
    2 t% {" J( X1 @6 Y1 j) a0 Y
63.                 result =1;
    ( N- O8 F# s  d; V# i" v
64.         }
    - _# I' i1 {* D. X
65. 
    $ q3 |& D6 k4 L/ ^  x
66.         return result;
    9 U& l( _1 o& @2 o/ q% j
67. }

复制代码

* O  G3 K: `; M9 Z% C( P* w接着比较读出来的节点类型与要设置的节点类型是否一致，如果不一致的话，就重新写入要设置的节点类型：  

1.   if( drf1609H_setPontType != drf1609H_readPointType )

复制代码

1 |: R# Y1 o/ y8 t6 _写的过程：
1，产生写入参数
* q. ^" [: B* p" X6 }2，写入
3，接收回复的参数，看看写入是否正确

1.                 getWriteIns(drf1609);
   
2. 
   
3.                 drf1609h_writeModule();
   ! ~' _( a9 D. D3 n4 @8 a
4.                 HAL_UART_Receive( &huart1, receivedConfigData, 5, 500 );

复制代码

  O$ {0 R# a" X( \; ~# m写入正确以后，则重启模块（注意：DRF1609H的写入参数生效，都需要重启），这里是用一个IO口，控制DRF1609H的RESET脚拉低重启。

1. if( is_InsBack(receivedConfigData, 5) )
   
2.                 {
   
3.                         if(receivedConfigData[2] == 0x0A)
   
4.                         {
   
5.                                 drf1609h_reset();
   ) z$ _' d/ ]2 S/ E3 s
6.                                 HAL_Delay(2000);
   + m$ Y: E6 R' d* G0 X" Y
7.                                 drf1609h_status = drf1609h_powerOn;
   
8.                         }
   ( d) R! H/ L# F
9.                         else
   " t2 H: _$ D3 P3 D7 l
10.                         {
      r# J( U$ ]+ @3 C
11.                                 errorStart=1;
    
12.                         }
    
13.                 }
    3 l0 o. i; u9 ]; l* v
14.                 else
    
15.                 {
    * k9 O( I3 i, ^- L/ w6 u; K" J! `
16.                         errorStart=1;
    
17.                 }

复制代码

) Z/ x3 l. k# k+ l# v7 y) h需要注意的是，getWriteIns(drf1609)，这个函数是把drf1609结构体，直接变换成写入指令，建议用户不要修改这部分，直接拷贝使用
" ?# V4 P* m# \7 X5 M* T

1. //---------------------------------------------------
   
2. void  getWriteIns(_zigbeeParameters  inputParameter)
   # t, C! {/ S2 ]8 Q3 n
3. {
   
4.         uint8_t   i=0;
   " m5 c# q" B* B. J
5.         uint8_t  tempXY=0;
   
6.         
   $ y2 N2 e+ R7 v! H4 G
7.         writeIns[0]= 0xFC;
   
8.         writeIns[1]= 0x27;
   - E9 a/ x6 Q" J, b7 W
9.         writeIns[2]= 0x07;
   
10.         
    
11.         writeIns[writeHeaderLen +0]= inputParameter.pointType;
    
12.         writeIns[writeHeaderLen +1]= (inputParameter.PAN_ID & 0xFF00)>>8;
    
13.         writeIns[writeHeaderLen +2]= inputParameter.PAN_ID & 0x00FF;
    
14.         writeIns[writeHeaderLen +3]= inputParameter.Channel;
    $ Q  U3 m/ ]5 ~4 f6 Z; m. e1 p* h
15.         writeIns[writeHeaderLen +4]= inputParameter.transferModel;
    . ^6 e  I  x+ C4 F
16.         writeIns[writeHeaderLen +5]= (inputParameter.userAddress & 0xFF00)>>8;
    4 R7 T  a# M& r( v
17.         writeIns[writeHeaderLen +6]= inputParameter.userAddress & 0x00FF;
    
18.         writeIns[writeHeaderLen +7]= (inputParameter.X7X8 & 0xFF00)>>8;
    8 s9 O0 r. p7 b2 ?5 p6 ?5 J8 l
19.         writeIns[writeHeaderLen +8]= inputParameter.X7X8 & 0x00FF;
    
20.         writeIns[writeHeaderLen +9]= inputParameter.uartBraudRate;
    
21.         writeIns[writeHeaderLen +10]= inputParameter.uartDataBits;
    9 H: _4 k2 _9 [
22.         writeIns[writeHeaderLen +11]= inputParameter.uartStopBits;
    & s7 y/ l# s) ^9 X
23.         writeIns[writeHeaderLen +12]= inputParameter.uartParity;
    ( ]+ d" r: V2 i6 F# f
24.         writeIns[writeHeaderLen +13]= (inputParameter.X13X14 & 0xFF00)>>8;
    2 P, j, J. O$ k" z  k4 n
25.         writeIns[writeHeaderLen +14]= inputParameter.X13X14 & 0x00FF;
    
26.         writeIns[writeHeaderLen +15]= inputParameter.antennaSelect;
    
27.         
    # h* a* Q( A% c$ G1 y5 z
28.         writeIns[writeHeaderLen +16]= inputParameter.prePointType;
    7 O2 b8 N( j# J. A* b& W, l
29.         writeIns[writeHeaderLen +17]= (inputParameter.prePAN_ID & 0xFF00)>>8;
    $ B7 V6 M9 P. u; p, |
30.         writeIns[writeHeaderLen +18]= inputParameter.prePAN_ID & 0x00FF;
    : [% K/ H3 t+ j
31.         writeIns[writeHeaderLen +19]= inputParameter.preChannel;
    
32.         writeIns[writeHeaderLen +20]= inputParameter.preTransferModel;
    : Y4 F, Z4 `* I; j
33.         writeIns[writeHeaderLen +21]= (inputParameter.preUserAddress & 0xFF00)>>8;
    
34.         writeIns[writeHeaderLen +22]= inputParameter.preUserAddress & 0x00FF;
    
35.         writeIns[writeHeaderLen +23]= (inputParameter.X31X32 & 0xFF00)>>8;  //--AS ReadParameter's X31 X32
    & W/ r) y( n* ?
36.         writeIns[writeHeaderLen +24]= inputParameter.X31X32 & 0x00FF;       //--AS ReadParameter's X31 X32
    
37.         writeIns[writeHeaderLen +25]= inputParameter.preUartBraudRate;
    - S9 b2 i: Q$ k
38.         writeIns[writeHeaderLen +26]= inputParameter.preUartDataBits;
    
39.         writeIns[writeHeaderLen +27]= inputParameter.preUartStopBits;
    
40.         writeIns[writeHeaderLen +28]= inputParameter.preUartParity;
      w' j4 t" E% x( K; j& F# @
41.         writeIns[writeHeaderLen +29]= (inputParameter.X37X38 & 0xFF00)>>8;  //--AS ReadParameter's X37 X38
    3 v# ]; R1 T+ M) O. d7 W1 z0 U
42.         writeIns[writeHeaderLen +30]= inputParameter.X37X38 & 0x00FF;       //--AS ReadParameter's X37 X38
    ) ~7 W& l$ ?! ?4 A" L
43.         writeIns[writeHeaderLen +31]= inputParameter.preAntennaSelect;
    
44.         writeIns[writeHeaderLen +32]= 0x1;
    2 b) n$ t- W9 i( b' N2 U: G0 W
45.         writeIns[writeHeaderLen +33]= inputParameter.isSecurity;
    : R. J) [( p! k
46.         
    8 k0 S- N+ B5 C
47.         for(i=0; i<4; i++)
    
48.         {
    0 B& ~0 G5 M; i4 `2 ~  l) ~; }
49.                 writeIns[writeHeaderLen +34 +i]= inputParameter.securityCode<span style="font-style: italic;"><span style="font-style: normal;">;
    
50.         }
    
51.         
    
52.         tempXY = getXY(writeIns, writeInsLen);
    
53.         
    ( J9 E* K: y) x
54.         writeIns[writeInsLen-1]= tempXY;        
    / j5 d9 {! e9 D1 y7 y
55. }</span></span>

复制代码

3 r% X# O: C) h: m2，检测节点是否加入网络
检测节点是否加入网络，我们这里使用了读取DRF1609H节点信号强度指令，如果读取信号强度成功（回复的数据是正确的），则表明DRF1609H已经加入了网络并且与Coordinator通讯正常。
; |+ q7 j  `& ?这个函数用来检测DRF1609H是否加入了网络，加入则回复1，没有则回复0：
" `6 v! M2 O0 Y8 V注意：这里是检测10次，没有加入也回复1，主要考虑在低功耗情况下，如果Coordinator没有开机，如果节点一直检测，则对耗电不利，用户应根据实际情况修改使用。

1. uint8_t  drf1609h_isJoinedNet()
   ( y* S. `4 {, u% t( m
2. 1
   
3. //----------------------
   
4. uint8_t  drf1609h_isJoinedNet()
   8 {5 {/ P1 g( L, O
5. {
   
6.         uint8_t   result=0;
   . w: y8 I. e5 e  L+ A- z) v' }# S3 P5 C
7.         uint8_t   i=0;
   ' x" r% A# g" X9 |( I" x1 s
8. 
   - \1 V' p  ?8 p5 g% A
9.         //MX_USART1_UART_Init();
   ! A) d( V3 n0 {. k$ E
10.         //HAL_Delay(10);
    0 h* r) T- j: H$ h5 I9 T
11.         for(i=0; i<8; i++)
    7 v* \" F2 Q; a7 ^6 g1 V5 y
12.         {
    - m6 N: Z  g* e8 g0 o+ E! ^  H8 h
13.                 receivedSignalData<span style="font-style: italic;"><span style="font-style: normal;">=0;
    
14.         }
    4 s/ I! t3 Q7 Z0 Z& p' J$ V' D
15. 
    
16.         drf1609h_requestSignalIndex();
    
17.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
    ' [' }; C& ^+ [
18.         HAL_Delay(1000);
    
19. 
    " w" u7 x8 [6 d- e
20.         if( checkSignalData(receivedSignalData, 8) )
    4 e9 N8 C$ d+ D! j1 a* p
21.         {
    ) k, t# ~* w: b7 m
22.                 result=1;
    
23.                 receivedSignalData[8] = drf1609.pointType;
    7 }9 l- u6 r0 C( z; L* M1 _: `
24.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
    * [1 f, q5 l+ U/ B" P  k; m" |1 H
25.         }
    
26.         else
    ' j! h4 J6 N( g% E8 c/ Q" T/ d
27.         {
    
28.                 haveTryToJoinTimers++;
    ( m& |1 i  g$ o4 C
29.                 if(haveTryToJoinTimers >= maxJoinTimers)
    
30.                 {
    
31.                         result=1;
    
32.                 }
    
33.                 else
    ; N8 j2 s+ c/ S% g9 K, G
34.                 {
    
35.                         result=0;
    
36.                 }
    $ t' d& o) P, K7 `
37.         }
    
38. 
    
39. 
    3 x' x$ Z) r$ f8 y
40.         return   result;
    
41. }</span></span>

复制代码

检测的过程：
5 h2 V) w! C2 h3 ?1，发送读取信号强度指令
  ~3 j8 {- q  t; ?+ ?  n: h2，等待接收回复数据
* e0 I) |0 Z7 y5 b# |3，如果接收回复数据成功（已经加入网络），这里将收到的数据加上自己的节点类型发送给Coordinator，通知节点已经加入成功
# K( o5 D) ^/ n1 A6 }5 I7 y6 h4 A
0 {  a! ?. U0 j" Z" }8 u

1.         drf1609h_requestSignalIndex();
   . D: z6 C$ p' E  ~4 T: u
2.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   , @$ x* c: Z' j
3.         HAL_Delay(1000);
   - r, I& Z1 N7 F  j
4. 
   
5.         if( checkSignalData(receivedSignalData, 8) )
   
6.         {
   
7.                 result=1;
   / w, d& [0 l! G$ o; d! y
8.                 receivedSignalData[8] = drf1609.pointType;
   , K7 I2 i) I5 u7 C" i' b/ ^4 b
9.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
   
10.         }

复制代码

3，启动节点自动加入网络
/ u4 E  e. }/ l6 E& o如果连按三次DRF1609H的Function按键，则开始自动扫描，如果扫描到Coordinator，则可以自动加入网络，并从Coordinator处获得“给Router预设的参数”，所以节点是不要设置的，我们节点的板子上也没有把DRF1609H的串口留出来，而是通过连按三次按键，自动加入网络，自动取得参数。
1，检测DRF1609H是否加入网络，用的是读取信号强度的指令
2，如果没有加入网络，则启动自动加入网络
3，启动后，等待12秒，再读取信号强度，判断是否加入了网络
注意，板子上有按键，如果是低功耗模式，建议不要启动这个功能，用按键手工加入网络，如果Coordinator没开机，一直扫描网络，会很快耗光电池。

1.         //-- Do 5 timers get Signal Index ----//
   
2.         for(i=0; i<5; i++)
   ' F. o" j5 d, S. J( M
3.         {
   ; B! w( p3 E7 A! o
4.                 drf1609h_requestSignalIndex();
   
5.                 HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   . O4 p; @9 g3 X2 o9 `% {5 }  Q
6.                 HAL_Delay(500);
   2 a/ Z6 @/ W- n3 l1 I
7. 
   - V& b4 q5 h! o+ V( ], `' W
8.                 if( checkSignalData(receivedSignalData, 8) )
   
9.                 {
   " L8 `. Y# a% U4 N) z* {9 h
10.                         tempVal++;
    . D' U& U: b( T& g/ E
11.                         i=5;
    # c3 o1 A4 R) _+ H* ?+ A/ k
12.                 }
    
13.                 else
    + k, z2 H) D  Q/ j, E
14.                 {
    " T* B3 V3 j1 ]$ V! A+ z4 V
15.                         notGetSignalVal++;
    
16.                 }
    
17.         }

复制代码

1.             drf1609h_autoJoinNet_Start();
   - f: n3 I6 W5 n
2.             HAL_Delay(12000);

复制代码

进去自动加入网络的代码看看，其实就是模拟三次按键：
开始以后，DRF1609H上的2个灯会快闪，观察到一个灯灭，一个灯慢闪以后，说明已经加入网络。
8 D4 g& r$ H6 a& L% f
8 V  |2 S) v' [

1. //---------------------------------------
   
2. /*   This Simulate Function Key to start
     ?. l* F% C2 Z
3. *   point auto join net
   / M/ c& Z4 R  {# h, t
4. *   ____    ______    ______    ______
   6 H: {/ \& s7 ?% B& O
5. *       |__|      |__|      |__|
   . M# T0 O9 M* C
6. *
   
7. *       120  200  120  200  120  200
   
8. *
   5 S9 E3 o9 g, l* ?- W. T/ D
9. *   ----------------------------------*/
   
10. void  drf1609h_autoJoinNet_Start()
    + t: n( w! x$ n$ @+ v. B  h# t
11. {
    
12.         uint8_t  i=0;
    ; I/ L( o& w+ j8 C
13. 
    4 N, l+ M/ c' S% x$ ?- \0 h
14.         set_autoJoinNetPin_output();
    
15.         set_autoJoinNetPin_out_1();
    
16.         HAL_Delay(100);
    + e' h. m2 V2 O: F4 ?
17. 
    
18.         for(i=0; i<3; i++)
    3 u2 e1 w+ ]6 U9 I9 L  q$ G% K# J
19.         {
    
20.                 set_autoJoinNetPin_out_0();
    8 ?( z# h) }9 P: _) U
21.                 HAL_Delay(120);
    7 Q6 R& `6 ^) T6 ^) U! t  c
22. 
    % R! |9 V4 L/ F, O2 E( E+ g
23.                 set_autoJoinNetPin_out_1();
    
24.                 HAL_Delay(200);
    : b; b" \" m: b0 J9 p% e2 m; E
25.         }
    " d0 j& Z7 j$ ~8 W) [# i, q  A+ I) l
26. 
    ; w/ e) a* k9 R; ?- f2 N
27.         set_autoJoinNetPin_input();
    
28. }

复制代码

4，DRF1609H的相关指令
- i2 G7 u8 R+ f. w( K2 I主要有读取参数、读取信号强度、写入参数等指令，项目里面都已经列出来了
: l4 V3 c! D4 o4 v如果需要增加其它的功能，要参考DRF1609H的说明书

: [1 f0 s+ D2 i! c# {

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
   + M1 P# {9 O: x" w2 U, l& _& R
4. uint8_t    writeIns[42];   //--INS06
   " |- y- B4 l0 D& G
5. uint8_t    requestSignalIns[9] = {0xFC, 0x06, 0x0C, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x89};    //--INS08

复制代码