本项目中使用了Zigbee模块（DRF1609H），作为无线数据传输使用，初始化DRF1609H主要涉及以下几个方面的内容：
- x5 `, }1 E7 g- i3 [1，设置节点的类型，可以设置为：Router、End Device。Zigbee网络有3种类型的节点：Coordinator、Router、End Device，Cordinator接在电脑上面收集数据，我们这里是采集节点，所以只设置为Router或End Device。
2 V) R1 ~/ @- |7 ~2，检测节点是否加入了网络
) b6 i6 t7 B+ O; ^/ L4 z3，如果节点没有加入网络，则启动自动扫描加入网络

7 d( ~0 Y* D* I2 N9 e* H0 @1，节点类型的设置：
首先读取DRF1609H的参数：G031向DRF1609H发送读取参数指令，发完参数后，有一个500MS的超时等待参数的回复，参数回复总共是53个字节，放在receiveConfigData里面。

1.         //--Read DRF1609H Configures --
   6 V/ x% y8 n( R$ }; U
2.         drf1609h_readModule();
   & @) h1 o5 y3 c8 R
3.         HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );

复制代码

1. //------------------------------
   # K3 Z, N" _+ S
2. void  drf1609h_readModule(void)
   
3. {
   
4.         drf1609h_sendedIns = sendIns_read;
   
5.         HAL_UART_Transmit_DMA( &huart1, readIns, 9 );
   7 l5 M" J0 @% l/ P
6. }

复制代码

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

2 g2 s5 C! |9 q0 O3 U; ?: u% @

1.         //---If DRF1609H Error or Read Error ------
   
2.         while( readParameterProcess(receivedConfigData, 53) == 0 )
   
3.         {
   
4.                 drf1609h_readModule();
   ( U2 c$ u$ J9 o, |7 F
5.                 HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );
   / U. U) v# P$ q' f! v  h
6.         }

复制代码

1. //------------------------------
   
2. uint8_t  readParameterProcess(uint8_t  *inputData,  uint16_t  inputLen)
   
3. {
   2 \7 s; S  u' ^
4.         uint8_t  result=0;
   
5. 
   
6.         uint8_t  tempXY=0;
   
7.         uint8_t  tempRight=0;
   % g7 O* }& x# o9 L* Q1 E2 G; _4 `
8.         uint8_t  i=0;
   
9.         
   
10.         tempXY = getXY(inputData, inputLen);
    5 C+ |" r3 Z* l, G, m  O+ z( E
11.         
    
12.         if(inputData[0]==0xFA) { tempRight++; }
    ) q; u$ M" U2 [2 k# f' h# v
13.         if(inputData[1]==0x31) { tempRight++; }
    
14.         if(inputData[2]==0x0A) { tempRight++; }
    
15.         if(inputData[inputLen-1]==tempXY) { tempRight++; }
    
16.         
    6 t: G" K% u2 h$ X& @7 n& P
17.         if(tempRight==4)
    
18.         {
    # N# C: H( p1 m7 B9 k
19.                 //------
    
20.                 drf1609.pointType = inputData[readHeaderLen +0];
    # r  f8 F% e6 h  J# {
21.                 drf1609.PAN_ID = inputData[readHeaderLen +1]*256 + inputData[readHeaderLen +2];
    ; \! O0 _' Z) q$ }2 M" j2 a- v
22.                 drf1609.Channel = inputData[readHeaderLen +3];
    
23.                 drf1609.transferModel = inputData[readHeaderLen +4];
    8 z8 W% C4 g3 z9 C: b
24.                 drf1609.userAddress = inputData[readHeaderLen +5]*256 + inputData[readHeaderLen +6];
    
25.                 drf1609.X7X8 = inputData[readHeaderLen +7]*256 + inputData[readHeaderLen +8];
      O# ?  K8 C* c) v' W7 x
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];
    4 ?+ H% g2 k$ h( p+ V
31.                 drf1609.antennaSelect = inputData[readHeaderLen +15];
    
32.                
    
33.                 //-------
    
34.                 for(i=0; i<8; i++)
    
35.                 {
    
36.                         drf1609.macAddress<i> = inputData[readHeaderLen +16 +i];
    
37.                 </i>}
    
38.                
    
39.                 //--------
    * U- w3 a* c6 M+ P4 V, B" m# u8 K
40.                 drf1609.prePointType = inputData[readHeaderLen +24];
    / _7 z( a& V9 B2 o; s8 P
41.                 drf1609.prePAN_ID = inputData[readHeaderLen +25]*256 + inputData[readHeaderLen +26];
    
42.                 drf1609.preChannel = inputData[readHeaderLen +27];
    
43.                 drf1609.preTransferModel = inputData[readHeaderLen +28];
    
44.                 drf1609.preUserAddress = inputData[readHeaderLen +29]*256 + inputData[readHeaderLen +30];
    
45.                 drf1609.X31X32 = inputData[readHeaderLen +31]*256 + inputData[readHeaderLen +32];
    ( Y* c7 e+ _* J7 ]) r
46.                 drf1609.preUartBraudRate = inputData[readHeaderLen +33];
    , h) a& D8 y' H$ k: x) k( S
47.                 drf1609.preUartDataBits = inputData[readHeaderLen +34];
    9 K" ^3 P) J0 F+ k- S
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.                
    
53.                 //-----------
    
54.                 drf1609.shortAddress = inputData[readHeaderLen +40]*256 + inputData[readHeaderLen +41];
    
55.                 drf1609.X42 = inputData[readHeaderLen +42];
    : l. U0 g+ j2 }7 j7 P7 v6 j
56.                 drf1609.isSecurity = inputData[readHeaderLen +43];
    
57.                
    ' |' b. f8 \7 p7 |
58.                 for(i=0; i<4; i++)
    
59.                 {
    
60.                         drf1609.securityCode = inputData[readHeaderLen +44 +i];
    8 [& j* a& A2 d# I
61.                 }
    
62. 
    
63.                 result =1;
    + ]; M4 U- q# O6 e! ]
64.         }
    0 o1 R$ I( \- f7 X  m- r1 }
65. 
    
66.         return result;
    
67. }

复制代码

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

1.   if( drf1609H_setPontType != drf1609H_readPointType )

复制代码

' }0 J, b0 x0 q  l写的过程：
* d8 f8 ^+ l( V8 g/ ]) N3 @1，产生写入参数
  d2 Q- E* z$ @" t2，写入
3，接收回复的参数，看看写入是否正确

1.                 getWriteIns(drf1609);
   , c& j" A9 b0 u+ ^2 i2 h) p, }
2. 
   # n( E$ }+ \" U
3.                 drf1609h_writeModule();
   
4.                 HAL_UART_Receive( &huart1, receivedConfigData, 5, 500 );

复制代码

- {- w4 V) M1 n- ?  Y- I8 D+ i3 M写入正确以后，则重启模块（注意：DRF1609H的写入参数生效，都需要重启），这里是用一个IO口，控制DRF1609H的RESET脚拉低重启。

1. if( is_InsBack(receivedConfigData, 5) )
   9 ]+ B  s& E. V8 x' O& k# A. v
2.                 {
   
3.                         if(receivedConfigData[2] == 0x0A)
   0 O+ `% J. Q$ g/ S
4.                         {
     y$ P9 s2 b7 J# w1 L/ }  Y3 [
5.                                 drf1609h_reset();
   ! i2 N. p# \' A. J5 a
6.                                 HAL_Delay(2000);
   ( `# O: W5 v, E
7.                                 drf1609h_status = drf1609h_powerOn;
   - C" }' ]: f; e; x
8.                         }
   
9.                         else
   # @0 Y0 T# J& U) i( h7 h. G
10.                         {
    1 x; {" z) T0 W9 i' C
11.                                 errorStart=1;
    
12.                         }
    
13.                 }
    
14.                 else
    " A9 w  Y: B* s# u
15.                 {
    
16.                         errorStart=1;
    0 w* B* K: r: i; I; {! ^: T, V( z
17.                 }

复制代码

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

1. //---------------------------------------------------
   5 p; o+ Y+ i: r. o5 C1 h" |
2. void  getWriteIns(_zigbeeParameters  inputParameter)
   2 Y; G4 ]( C4 X
3. {
   
4.         uint8_t   i=0;
   
5.         uint8_t  tempXY=0;
   % M' Y1 D2 d# |3 X) @1 U# k( `
6.         
   2 e" U8 L, V2 s& w
7.         writeIns[0]= 0xFC;
   
8.         writeIns[1]= 0x27;
   . J5 s' Y8 s8 M' w  @
9.         writeIns[2]= 0x07;
   ( C8 P: n+ s2 y3 J2 g' d$ E
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;
    8 x$ t. }3 ^6 d8 ^$ e7 ]
15.         writeIns[writeHeaderLen +4]= inputParameter.transferModel;
    
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;
    % e% u% u: Q+ i% L
20.         writeIns[writeHeaderLen +9]= inputParameter.uartBraudRate;
    
21.         writeIns[writeHeaderLen +10]= inputParameter.uartDataBits;
    
22.         writeIns[writeHeaderLen +11]= inputParameter.uartStopBits;
    
23.         writeIns[writeHeaderLen +12]= inputParameter.uartParity;
    ( y. a& }! c$ w) R3 j+ r7 e
24.         writeIns[writeHeaderLen +13]= (inputParameter.X13X14 & 0xFF00)>>8;
    
25.         writeIns[writeHeaderLen +14]= inputParameter.X13X14 & 0x00FF;
    
26.         writeIns[writeHeaderLen +15]= inputParameter.antennaSelect;
    
27.         
    
28.         writeIns[writeHeaderLen +16]= inputParameter.prePointType;
    
29.         writeIns[writeHeaderLen +17]= (inputParameter.prePAN_ID & 0xFF00)>>8;
    ( k* h6 g3 t# |
30.         writeIns[writeHeaderLen +18]= inputParameter.prePAN_ID & 0x00FF;
    ' ]2 e" g5 l: w) w
31.         writeIns[writeHeaderLen +19]= inputParameter.preChannel;
    
32.         writeIns[writeHeaderLen +20]= inputParameter.preTransferModel;
    - ]. q' F! w; p  ]1 Q  F/ f) _1 ^
33.         writeIns[writeHeaderLen +21]= (inputParameter.preUserAddress & 0xFF00)>>8;
      ]9 v9 \; y* V- m
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
    
37.         writeIns[writeHeaderLen +25]= inputParameter.preUartBraudRate;
    
38.         writeIns[writeHeaderLen +26]= inputParameter.preUartDataBits;
    3 M& G. R4 i2 E7 `
39.         writeIns[writeHeaderLen +27]= inputParameter.preUartStopBits;
    ; V2 G7 T3 H8 {% D. ^
40.         writeIns[writeHeaderLen +28]= inputParameter.preUartParity;
    
41.         writeIns[writeHeaderLen +29]= (inputParameter.X37X38 & 0xFF00)>>8;  //--AS ReadParameter's X37 X38
      B$ k9 V! |& C: u8 o$ E
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;
    
46.         
    
47.         for(i=0; i<4; i++)
    * j  N3 y/ J5 ]
48.         {
    4 z+ I# G5 |; j) |. U  ^
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.         
    1 |2 J: V: U8 B+ z" Q
54.         writeIns[writeInsLen-1]= tempXY;        
    , A  Y5 K$ ?5 d4 Z" ?: d& G& |
55. }</span></span>

复制代码

, Z6 s% X8 `! l6 z2，检测节点是否加入网络
检测节点是否加入网络，我们这里使用了读取DRF1609H节点信号强度指令，如果读取信号强度成功（回复的数据是正确的），则表明DRF1609H已经加入了网络并且与Coordinator通讯正常。
! W9 T  q/ z- R: r8 m9 J这个函数用来检测DRF1609H是否加入了网络，加入则回复1，没有则回复0：
$ \! o7 m# K6 w+ P% ^注意：这里是检测10次，没有加入也回复1，主要考虑在低功耗情况下，如果Coordinator没有开机，如果节点一直检测，则对耗电不利，用户应根据实际情况修改使用。

1. uint8_t  drf1609h_isJoinedNet()
   # y( l# b7 l" H
2. 1
   
3. //----------------------
   
4. uint8_t  drf1609h_isJoinedNet()
   , j. F$ b# `; P! i) Q
5. {
   
6.         uint8_t   result=0;
   
7.         uint8_t   i=0;
   7 i" c, P' A6 w  M
8. 
   
9.         //MX_USART1_UART_Init();
   % A4 c( U* Q- }+ Y8 W* E
10.         //HAL_Delay(10);
    
11.         for(i=0; i<8; i++)
      Z5 o) {3 h/ T( ]& f
12.         {
    
13.                 receivedSignalData<span style="font-style: italic;"><span style="font-style: normal;">=0;
    $ N2 q4 D) k0 ^. J
14.         }
    
15. 
    5 t" l- P$ T% a+ p! M
16.         drf1609h_requestSignalIndex();
    
17.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
    : i/ l3 w& }- a0 X
18.         HAL_Delay(1000);
    
19. 
    
20.         if( checkSignalData(receivedSignalData, 8) )
    
21.         {
    3 t* S8 B7 Q; H) b9 C+ A4 h/ ?
22.                 result=1;
    
23.                 receivedSignalData[8] = drf1609.pointType;
    
24.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
    
25.         }
    
26.         else
    ) z0 l6 i( {4 P% H9 a( h
27.         {
    
28.                 haveTryToJoinTimers++;
    
29.                 if(haveTryToJoinTimers >= maxJoinTimers)
    
30.                 {
    9 F" H3 u/ m. I2 `% i
31.                         result=1;
    , c5 ^2 {/ x$ F6 R$ X* n# [
32.                 }
    
33.                 else
    
34.                 {
    ' @  r( ^8 H1 q7 l. |
35.                         result=0;
    
36.                 }
    
37.         }
    2 n8 N, @/ |9 a3 U- Q& N+ P
38. 
    
39. 
    
40.         return   result;
    
41. }</span></span>

复制代码

检测的过程：
1，发送读取信号强度指令
2，等待接收回复数据
% V5 A9 U2 t8 D3，如果接收回复数据成功（已经加入网络），这里将收到的数据加上自己的节点类型发送给Coordinator，通知节点已经加入成功

6 U( |7 y: X: @& m5 f

1.         drf1609h_requestSignalIndex();
   
2.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   1 d$ N. @& ]9 F( Q2 E
3.         HAL_Delay(1000);
   ! F3 w4 ]! q( Q8 `4 f+ v  y
4. 
   
5.         if( checkSignalData(receivedSignalData, 8) )
   
6.         {
   6 f; C: T' w6 Y: V* P
7.                 result=1;
   
8.                 receivedSignalData[8] = drf1609.pointType;
   
9.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
   
10.         }

复制代码

3，启动节点自动加入网络
: c% ^& Z$ n4 |+ @$ m5 k如果连按三次DRF1609H的Function按键，则开始自动扫描，如果扫描到Coordinator，则可以自动加入网络，并从Coordinator处获得“给Router预设的参数”，所以节点是不要设置的，我们节点的板子上也没有把DRF1609H的串口留出来，而是通过连按三次按键，自动加入网络，自动取得参数。
8 t% R9 x; e2 `8 F+ \" z5 M/ I1，检测DRF1609H是否加入网络，用的是读取信号强度的指令
2，如果没有加入网络，则启动自动加入网络
3，启动后，等待12秒，再读取信号强度，判断是否加入了网络
$ N' H  @" P; f+ c/ U, w注意，板子上有按键，如果是低功耗模式，建议不要启动这个功能，用按键手工加入网络，如果Coordinator没开机，一直扫描网络，会很快耗光电池。

- a1 V( p& K; e+ b/ Q  r  s

1.         //-- Do 5 timers get Signal Index ----//
   
2.         for(i=0; i<5; i++)
   
3.         {
   
4.                 drf1609h_requestSignalIndex();
   
5.                 HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   6 Z' r/ G: l! F. ]* _7 X3 t
6.                 HAL_Delay(500);
   
7. 
   1 z" T+ g( O4 I/ s5 }0 B. D0 L# P
8.                 if( checkSignalData(receivedSignalData, 8) )
   
9.                 {
   
10.                         tempVal++;
    6 [# o- n8 E" e, {. K, N
11.                         i=5;
    ) o0 R0 r$ f% D
12.                 }
    
13.                 else
    ' A7 v- ^. X& g  S$ `6 i
14.                 {
    
15.                         notGetSignalVal++;
    
16.                 }
    
17.         }

复制代码

1.             drf1609h_autoJoinNet_Start();
   6 B& k# @+ ^& Y: q
2.             HAL_Delay(12000);

复制代码

进去自动加入网络的代码看看，其实就是模拟三次按键：
5 v0 W/ G  [* D( d( R开始以后，DRF1609H上的2个灯会快闪，观察到一个灯灭，一个灯慢闪以后，说明已经加入网络。
+ Z$ v( k3 J3 P8 w  r" V2 ?, o- I

1. //---------------------------------------
   
2. /*   This Simulate Function Key to start
     Q+ t8 O' L: E/ _$ _0 R& E
3. *   point auto join net
   
4. *   ____    ______    ______    ______
   7 \1 s, L' n: I' I4 q: V' l" _
5. *       |__|      |__|      |__|
   . w1 l% ]* K& R% t, q1 [
6. *
   
7. *       120  200  120  200  120  200
   ; h- F( q* J$ t4 x0 C1 S
8. *
   
9. *   ----------------------------------*/
   
10. void  drf1609h_autoJoinNet_Start()
    , {! p) _, ?( i& x
11. {
    
12.         uint8_t  i=0;
    $ d  m. n$ J, |, A2 q+ v
13. 
    
14.         set_autoJoinNetPin_output();
    
15.         set_autoJoinNetPin_out_1();
    6 J+ z& _8 m8 B+ O& Q8 c( Y
16.         HAL_Delay(100);
      x& b+ t* @2 x! b! m
17. 
    0 H9 F8 b8 k0 e3 o5 G' n
18.         for(i=0; i<3; i++)
    
19.         {
    & H$ K3 n, b: }. T
20.                 set_autoJoinNetPin_out_0();
    4 }7 B4 v. M8 A4 Q' ~
21.                 HAL_Delay(120);
    2 \/ t! q. v/ _! \" @4 j
22. 
    
23.                 set_autoJoinNetPin_out_1();
    
24.                 HAL_Delay(200);
    ' L+ y0 C0 B6 V7 p* @. x5 R
25.         }
    
26. 
    ! P2 P3 W& s3 w
27.         set_autoJoinNetPin_input();
    , v! N! g+ ]+ i6 q1 f( R
28. }

复制代码

% q' A  k: m6 y& B4，DRF1609H的相关指令
主要有读取参数、读取信号强度、写入参数等指令，项目里面都已经列出来了
9 I' Q: |0 ?: N3 S8 `  [5 [如果需要增加其它的功能，要参考DRF1609H的说明书

7 O4 k$ m) N8 x

1. uint8_t    linkIns[9] = {0xFC, 0x06, 0x04, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x81};      //---INS01
   - l& `8 w) ?9 ^4 V* n, M* t8 \
2. uint8_t    restartIns[9] = {0xFC, 0x06, 0x06, 0x44, 0x54, 0x4B, 0xAA, 0xBB, 0x50};   //---INS02
   $ c0 I- i- T' v$ m4 w  I" F! a* ?
3. uint8_t    readIns[9] = {0xFC, 0x06, 0x0E, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x8B};      //---INS05
   
4. uint8_t    writeIns[42];   //--INS06
   
5. uint8_t    requestSignalIns[9] = {0xFC, 0x06, 0x0C, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x89};    //--INS08

复制代码

& }. m, A7 N4 e% S2 w* L

- I1 E: f* p- D* k