本项目中使用了Zigbee模块（DRF1609H），作为无线数据传输使用，初始化DRF1609H主要涉及以下几个方面的内容：
1，设置节点的类型，可以设置为：Router、End Device。Zigbee网络有3种类型的节点：Coordinator、Router、End Device，Cordinator接在电脑上面收集数据，我们这里是采集节点，所以只设置为Router或End Device。
2，检测节点是否加入了网络
, d4 S- g: ]1 D+ I3 P# `: H/ N) t3，如果节点没有加入网络，则启动自动扫描加入网络
* T& a9 y1 D% S( ~6 Z6 `" x7 _" l( K2 K
1，节点类型的设置：
1 k, C& u6 Z7 n/ r! x首先读取DRF1609H的参数：G031向DRF1609H发送读取参数指令，发完参数后，有一个500MS的超时等待参数的回复，参数回复总共是53个字节，放在receiveConfigData里面。
2 O6 P7 z; f1 I  k  a6 I7 I
& k/ e) x* [5 m, W7 i

1.         //--Read DRF1609H Configures --
   3 o: q8 G; U& k( d9 |
2.         drf1609h_readModule();
   
3.         HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );

复制代码

1. //------------------------------
   % Q% {1 w" C) Z* X# h
2. void  drf1609h_readModule(void)
   
3. {
   
4.         drf1609h_sendedIns = sendIns_read;
   
5.         HAL_UART_Transmit_DMA( &huart1, readIns, 9 );
   5 g0 D1 _' P) P- A# k+ A
6. }

复制代码

读取参数完成后，把读取到的参数整理后放入drf1609这个结构体中：以后取用的时候就非常方便了，建议用户不要改这部分代码，直接拷贝使用就好了。
0 `) o4 m. y9 N3 V7 u/ c$ V- S
8 o" W& V+ x3 U6 a

1.         //---If DRF1609H Error or Read Error ------
   6 L% P; f& _2 r; s/ t* T
2.         while( readParameterProcess(receivedConfigData, 53) == 0 )
   ( A! a( Y! A! [2 C  v! H9 X/ x
3.         {
   
4.                 drf1609h_readModule();
   8 U6 `/ ?! z; n* M9 v
5.                 HAL_UART_Receive( &huart1, receivedConfigData, 53, 500 );
   
6.         }

复制代码

1. //------------------------------
   
2. uint8_t  readParameterProcess(uint8_t  *inputData,  uint16_t  inputLen)
   
3. {
   
4.         uint8_t  result=0;
   
5. 
   
6.         uint8_t  tempXY=0;
   & h. G5 a! b& `+ Y
7.         uint8_t  tempRight=0;
   
8.         uint8_t  i=0;
   
9.         
   
10.         tempXY = getXY(inputData, inputLen);
    
11.         
    " Z. `$ L, x% c/ G  S8 l
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.         
    8 P6 t* T; E& @) F2 g$ y
17.         if(tempRight==4)
    9 S& P2 {" y0 Q; q& Y9 c4 s
18.         {
    6 @$ \' x8 O" b2 b
19.                 //------
    % I! r: i. J( @$ v8 J+ ^9 ^
20.                 drf1609.pointType = inputData[readHeaderLen +0];
    8 U& ~% W, M  m9 K8 x( A6 q$ q" N
21.                 drf1609.PAN_ID = inputData[readHeaderLen +1]*256 + inputData[readHeaderLen +2];
    
22.                 drf1609.Channel = inputData[readHeaderLen +3];
    / Z% a* D6 j/ A4 s! d
23.                 drf1609.transferModel = inputData[readHeaderLen +4];
    & a! H& }/ \, x5 z
24.                 drf1609.userAddress = inputData[readHeaderLen +5]*256 + inputData[readHeaderLen +6];
    
25.                 drf1609.X7X8 = inputData[readHeaderLen +7]*256 + inputData[readHeaderLen +8];
    + ], `% G) A6 Z% D
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];
    6 n7 U! e; _& ]" f8 t& Y. E6 [) F
31.                 drf1609.antennaSelect = inputData[readHeaderLen +15];
    
32.                
    
33.                 //-------
    8 K8 J: V  ]" R/ ?8 @! j5 C
34.                 for(i=0; i<8; i++)
    ! q2 }# g3 [5 o0 b  N/ W0 Y# A
35.                 {
    " y1 A% U/ B, s0 m: m. l: t8 ]
36.                         drf1609.macAddress<i> = inputData[readHeaderLen +16 +i];
    # u: E% E; I# F7 o
37.                 </i>}
      W  S; l( M) Y/ i2 w
38.                
    4 G0 K3 {9 J/ \8 Q1 l7 X
39.                 //--------
    4 l4 F* r3 P9 ]8 E  W
40.                 drf1609.prePointType = inputData[readHeaderLen +24];
    1 g# Q6 _& u) d( f5 f" H' p* \
41.                 drf1609.prePAN_ID = inputData[readHeaderLen +25]*256 + inputData[readHeaderLen +26];
    , b4 t, a/ O5 E# a( e. [
42.                 drf1609.preChannel = inputData[readHeaderLen +27];
    
43.                 drf1609.preTransferModel = inputData[readHeaderLen +28];
    
44.                 drf1609.preUserAddress = inputData[readHeaderLen +29]*256 + inputData[readHeaderLen +30];
    ) O  k- c) X2 Z! `* l+ N( a
45.                 drf1609.X31X32 = inputData[readHeaderLen +31]*256 + inputData[readHeaderLen +32];
    ) h9 G" S5 o2 c1 i, W- D
46.                 drf1609.preUartBraudRate = inputData[readHeaderLen +33];
    + k5 ~# t% X/ q7 X
47.                 drf1609.preUartDataBits = inputData[readHeaderLen +34];
    
48.                 drf1609.preUartStopBits = inputData[readHeaderLen +35];
    
49.                 drf1609.preUartParity = inputData[readHeaderLen +36];
    , V/ X" m# o" R# F8 u$ p2 k
50.                 drf1609.X37X38 = inputData[readHeaderLen +37]*256 + inputData[readHeaderLen +38];
    
51.                 drf1609.preAntennaSelect = inputData[readHeaderLen +39];
    9 ]' }, `, K6 o2 v+ l
52.                
    
53.                 //-----------
    ( B, w$ z5 X* T" b$ X! Y5 R0 l
54.                 drf1609.shortAddress = inputData[readHeaderLen +40]*256 + inputData[readHeaderLen +41];
    ) ?' ]2 s/ P' }7 @9 g1 K* E6 Y6 `0 E
55.                 drf1609.X42 = inputData[readHeaderLen +42];
    
56.                 drf1609.isSecurity = inputData[readHeaderLen +43];
    
57.                
    
58.                 for(i=0; i<4; i++)
    
59.                 {
    / m* n9 S* \; U/ V$ M; X
60.                         drf1609.securityCode = inputData[readHeaderLen +44 +i];
    4 x; U3 w) |5 n& H2 O
61.                 }
    
62. 
    
63.                 result =1;
    
64.         }
    3 B7 F; R+ \( q1 L4 g/ `
65. 
    
66.         return result;
    
67. }

复制代码

/ U5 l( e/ [9 a' ~4 p接着比较读出来的节点类型与要设置的节点类型是否一致，如果不一致的话，就重新写入要设置的节点类型：  

1.   if( drf1609H_setPontType != drf1609H_readPointType )

复制代码

写的过程：
1 Y% y) L3 a& o8 {) q* T1，产生写入参数
2，写入
, Y. r& j: G" e3 j! r/ p9 J3，接收回复的参数，看看写入是否正确
* u  b% T5 ^$ n5 ?3 M$ `

1.                 getWriteIns(drf1609);
   0 x; K. M# Z" [* w$ `+ C
2. 
   
3.                 drf1609h_writeModule();
   
4.                 HAL_UART_Receive( &huart1, receivedConfigData, 5, 500 );

复制代码

) x6 [, D# ]( m+ ~' j# P写入正确以后，则重启模块（注意：DRF1609H的写入参数生效，都需要重启），这里是用一个IO口，控制DRF1609H的RESET脚拉低重启。

1. if( is_InsBack(receivedConfigData, 5) )
   2 m! S3 r+ C* g* @& `
2.                 {
   
3.                         if(receivedConfigData[2] == 0x0A)
   / P& G: @/ `+ |* j
4.                         {
   
5.                                 drf1609h_reset();
   
6.                                 HAL_Delay(2000);
   ' v9 F' V8 X+ n! U
7.                                 drf1609h_status = drf1609h_powerOn;
   
8.                         }
   % y/ L, f, a: w5 i' c
9.                         else
   
10.                         {
    
11.                                 errorStart=1;
    : v0 b* V$ ]9 x4 }
12.                         }
    9 Y9 e; {! r$ W' Q0 x# V1 m
13.                 }
    4 D" `: H1 c9 z( z7 i& G
14.                 else
    
15.                 {
    7 S6 u; b7 u$ g. d
16.                         errorStart=1;
    0 k/ B6 e2 p2 ?- K+ d& D
17.                 }

复制代码

需要注意的是，getWriteIns(drf1609)，这个函数是把drf1609结构体，直接变换成写入指令，建议用户不要修改这部分，直接拷贝使用
- i8 s! k  I6 v3 G- F  B
" r) `8 V2 N7 B- P. b

1. //---------------------------------------------------
   
2. void  getWriteIns(_zigbeeParameters  inputParameter)
   2 N7 D7 X$ m' c. @
3. {
   : f" `7 U2 U# l) }9 p6 B* X* A9 N4 g+ |
4.         uint8_t   i=0;
   ; C/ R& Y0 D# J8 u; b5 k4 r
5.         uint8_t  tempXY=0;
   / _7 s/ ]( a; y% ?0 b/ W" q
6.         
   + {" |2 D# m9 Z
7.         writeIns[0]= 0xFC;
   " b* I# m; K. @' }: q5 Z
8.         writeIns[1]= 0x27;
   
9.         writeIns[2]= 0x07;
   
10.         
    3 r+ y% N. T  a6 x0 `/ O
11.         writeIns[writeHeaderLen +0]= inputParameter.pointType;
    , m. k0 s& W$ S9 {! p. n
12.         writeIns[writeHeaderLen +1]= (inputParameter.PAN_ID & 0xFF00)>>8;
    % N+ ~- U4 D9 J) f# S  Z, Y
13.         writeIns[writeHeaderLen +2]= inputParameter.PAN_ID & 0x00FF;
    
14.         writeIns[writeHeaderLen +3]= inputParameter.Channel;
    4 E  F6 k  M6 z! u# e. l
15.         writeIns[writeHeaderLen +4]= inputParameter.transferModel;
    
16.         writeIns[writeHeaderLen +5]= (inputParameter.userAddress & 0xFF00)>>8;
    1 I3 T# d% I9 g' ^- u8 [7 A
17.         writeIns[writeHeaderLen +6]= inputParameter.userAddress & 0x00FF;
    . m3 X( G1 |3 @( E0 l2 ]5 K+ s# Y
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;
    
22.         writeIns[writeHeaderLen +11]= inputParameter.uartStopBits;
    
23.         writeIns[writeHeaderLen +12]= inputParameter.uartParity;
    * U" U- R. Q' S5 G+ I2 M. }2 _7 F5 @8 `
24.         writeIns[writeHeaderLen +13]= (inputParameter.X13X14 & 0xFF00)>>8;
    
25.         writeIns[writeHeaderLen +14]= inputParameter.X13X14 & 0x00FF;
    
26.         writeIns[writeHeaderLen +15]= inputParameter.antennaSelect;
    6 J* p" n; Z" k( f' N! d
27.         
    ; W+ y+ c9 C9 |, r
28.         writeIns[writeHeaderLen +16]= inputParameter.prePointType;
    5 W- x: k0 S$ v: @
29.         writeIns[writeHeaderLen +17]= (inputParameter.prePAN_ID & 0xFF00)>>8;
    
30.         writeIns[writeHeaderLen +18]= inputParameter.prePAN_ID & 0x00FF;
    ; A6 G6 I/ g$ n. }( J
31.         writeIns[writeHeaderLen +19]= inputParameter.preChannel;
    ) f0 x" P: G, C* p- U1 ~# x! ?
32.         writeIns[writeHeaderLen +20]= inputParameter.preTransferModel;
    
33.         writeIns[writeHeaderLen +21]= (inputParameter.preUserAddress & 0xFF00)>>8;
    & ^  L* X- ]* e+ M
34.         writeIns[writeHeaderLen +22]= inputParameter.preUserAddress & 0x00FF;
    . O/ U/ e: U& y. E5 d+ i9 W8 y7 c
35.         writeIns[writeHeaderLen +23]= (inputParameter.X31X32 & 0xFF00)>>8;  //--AS ReadParameter's X31 X32
    # V) f# v. n* \7 o$ I4 n3 k
36.         writeIns[writeHeaderLen +24]= inputParameter.X31X32 & 0x00FF;       //--AS ReadParameter's X31 X32
    
37.         writeIns[writeHeaderLen +25]= inputParameter.preUartBraudRate;
    + t7 E0 }! @/ Y! ^2 ]$ n# j
38.         writeIns[writeHeaderLen +26]= inputParameter.preUartDataBits;
    - r) S! Q0 }8 B/ I$ N+ C, f
39.         writeIns[writeHeaderLen +27]= inputParameter.preUartStopBits;
    
40.         writeIns[writeHeaderLen +28]= inputParameter.preUartParity;
    5 D, u' z' Q# ]; b) G
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
    7 o: D+ s; \0 C3 q
43.         writeIns[writeHeaderLen +31]= inputParameter.preAntennaSelect;
    
44.         writeIns[writeHeaderLen +32]= 0x1;
    + E) ?  ^/ s: z' ^* J2 g& ~
45.         writeIns[writeHeaderLen +33]= inputParameter.isSecurity;
    % X; J# G( ?# a7 K7 d/ j. a' q
46.         
    % n" N& D5 L3 M9 a: P! c0 h
47.         for(i=0; i<4; i++)
    0 N6 @1 R# v/ E: X
48.         {
    
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 E) [6 {+ p0 \, P! a& _
54.         writeIns[writeInsLen-1]= tempXY;        
    
55. }</span></span>

复制代码

& H' s* N! n! Q; k: p2，检测节点是否加入网络
7 A7 v' V' b' M. y  E检测节点是否加入网络，我们这里使用了读取DRF1609H节点信号强度指令，如果读取信号强度成功（回复的数据是正确的），则表明DRF1609H已经加入了网络并且与Coordinator通讯正常。
这个函数用来检测DRF1609H是否加入了网络，加入则回复1，没有则回复0：
注意：这里是检测10次，没有加入也回复1，主要考虑在低功耗情况下，如果Coordinator没有开机，如果节点一直检测，则对耗电不利，用户应根据实际情况修改使用。
5 Z8 O' n3 e+ k$ _, s& d4 P

1. uint8_t  drf1609h_isJoinedNet()
   8 b% S6 r* E! ^8 a' h6 q7 F
2. 1
   
3. //----------------------
   
4. uint8_t  drf1609h_isJoinedNet()
   " M, N* ~% S/ ]
5. {
   
6.         uint8_t   result=0;
   
7.         uint8_t   i=0;
   . I8 q" F6 U" {- @# L0 a1 p5 }& b
8. 
   
9.         //MX_USART1_UART_Init();
   8 r  o" p: O; K) B
10.         //HAL_Delay(10);
    & j" }- G6 i7 X; ]$ h0 O! O7 c
11.         for(i=0; i<8; i++)
    
12.         {
    - h2 n0 ^3 L  l% q5 c( s
13.                 receivedSignalData<span style="font-style: italic;"><span style="font-style: normal;">=0;
    " T" s3 u' ^* c
14.         }
    
15. 
    
16.         drf1609h_requestSignalIndex();
    
17.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
    
18.         HAL_Delay(1000);
    . b5 c/ D6 X( K9 L
19. 
    
20.         if( checkSignalData(receivedSignalData, 8) )
    
21.         {
    
22.                 result=1;
    4 z; m  D: b, ~& I$ J
23.                 receivedSignalData[8] = drf1609.pointType;
    
24.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
      u' O9 \; t/ j  t
25.         }
    ) D' l7 N+ E" l6 e& a+ Y# F+ v
26.         else
    " [: g/ y; D5 v* O9 H
27.         {
    7 l0 v7 {6 Y" L
28.                 haveTryToJoinTimers++;
    ) Z  w% R( |- G  {0 S9 T4 Q
29.                 if(haveTryToJoinTimers >= maxJoinTimers)
    % \! ]4 S6 h  l! c  N, P
30.                 {
    % ^/ l3 s- W4 P2 p2 h3 x; d
31.                         result=1;
    
32.                 }
    
33.                 else
    3 B. ^/ }& u5 {6 p1 u  g. h
34.                 {
    + ]4 Z4 V; {7 K2 K& H
35.                         result=0;
    
36.                 }
    % g+ l9 W9 X5 t/ f( J0 |
37.         }
    
38. 
    3 t- {5 l8 t8 \1 F6 p/ O7 t
39. 
    : j) M: E5 E% V# T# v
40.         return   result;
    
41. }</span></span>

复制代码

' A1 a' R0 R# K, s' J8 X检测的过程：
1，发送读取信号强度指令
" J- ?' i# H4 L8 N5 k8 @+ g7 I2，等待接收回复数据
3，如果接收回复数据成功（已经加入网络），这里将收到的数据加上自己的节点类型发送给Coordinator，通知节点已经加入成功

1.         drf1609h_requestSignalIndex();
   
2.         HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   % m0 W* Y6 \0 p% h; X% _: D' @- W
3.         HAL_Delay(1000);
   1 h9 \! x1 R. r9 `7 S: Y0 z2 [
4. 
   
5.         if( checkSignalData(receivedSignalData, 8) )
   
6.         {
   
7.                 result=1;
   
8.                 receivedSignalData[8] = drf1609.pointType;
   
9.                 HAL_UART_Transmit_DMA( &huart1, receivedSignalData, 9 );
   - L7 s$ s( c% s6 s, Z
10.         }

复制代码

3，启动节点自动加入网络
0 j, Q. k' B" o5 A. E如果连按三次DRF1609H的Function按键，则开始自动扫描，如果扫描到Coordinator，则可以自动加入网络，并从Coordinator处获得“给Router预设的参数”，所以节点是不要设置的，我们节点的板子上也没有把DRF1609H的串口留出来，而是通过连按三次按键，自动加入网络，自动取得参数。
1，检测DRF1609H是否加入网络，用的是读取信号强度的指令
* _9 K4 Q1 H! d" T2，如果没有加入网络，则启动自动加入网络
3，启动后，等待12秒，再读取信号强度，判断是否加入了网络
注意，板子上有按键，如果是低功耗模式，建议不要启动这个功能，用按键手工加入网络，如果Coordinator没开机，一直扫描网络，会很快耗光电池。
; ]7 w: L" F$ D  @6 X+ W
6 Y3 y! n: R! E" ~2 }) J) Z! w

1.         //-- Do 5 timers get Signal Index ----//
   - u% l' |% A7 \9 w8 D
2.         for(i=0; i<5; i++)
     L5 q4 x3 L' v, d4 L' ?% Z% V
3.         {
   
4.                 drf1609h_requestSignalIndex();
   
5.                 HAL_UART_Receive( &huart1, receivedSignalData, 8, 500 );
   
6.                 HAL_Delay(500);
   9 ], }- c- f3 ]3 M) n" q9 {
7. 
   
8.                 if( checkSignalData(receivedSignalData, 8) )
   
9.                 {
   
10.                         tempVal++;
    8 I  o; t: f$ x' D  a% c+ o
11.                         i=5;
    1 Z$ Z) q3 i, T8 D1 F
12.                 }
    
13.                 else
    
14.                 {
    / C0 ^+ Y' N/ P* B6 A' ^( [
15.                         notGetSignalVal++;
    
16.                 }
    
17.         }

复制代码

1.             drf1609h_autoJoinNet_Start();
   ; K$ m- `. ?7 n2 p$ J
2.             HAL_Delay(12000);

复制代码

$ i6 G) b2 R3 Z, F' M( A9 c进去自动加入网络的代码看看，其实就是模拟三次按键：
! g! b: c3 h- V* ^开始以后，DRF1609H上的2个灯会快闪，观察到一个灯灭，一个灯慢闪以后，说明已经加入网络。
3 _) Q. H* x) `8 d; e
/ c% p/ w. k3 N+ L: U7 {% h

1. //---------------------------------------
   
2. /*   This Simulate Function Key to start
   
3. *   point auto join net
   " o- e3 u- j7 {8 D8 k! {' f9 \( i1 O
4. *   ____    ______    ______    ______
   7 j" U" I8 q: K: i. @
5. *       |__|      |__|      |__|
   
6. *
   % w4 q4 M: O* A* X$ e! p0 \; o
7. *       120  200  120  200  120  200
   
8. *
   
9. *   ----------------------------------*/
   / o! }8 B, p& o  P3 t
10. void  drf1609h_autoJoinNet_Start()
    & k9 N, ^3 }& I! w  h8 V
11. {
    
12.         uint8_t  i=0;
    $ W+ ?' W! D: a* B
13. 
    
14.         set_autoJoinNetPin_output();
    
15.         set_autoJoinNetPin_out_1();
    
16.         HAL_Delay(100);
    
17. 
    
18.         for(i=0; i<3; i++)
    
19.         {
    
20.                 set_autoJoinNetPin_out_0();
    * l% v5 j9 F  I5 F9 t: A
21.                 HAL_Delay(120);
    ' ~2 N3 Z+ x. ]% S3 G
22. 
    
23.                 set_autoJoinNetPin_out_1();
    
24.                 HAL_Delay(200);
    : q5 c  f9 L. N" M5 v; f
25.         }
    
26. 
    ) U( i, v, X5 ^( p8 P
27.         set_autoJoinNetPin_input();
    5 w. a# d* G# w; l
28. }

复制代码

4，DRF1609H的相关指令
主要有读取参数、读取信号强度、写入参数等指令，项目里面都已经列出来了
7 q0 U5 j( P. W3 v如果需要增加其它的功能，要参考DRF1609H的说明书

1. uint8_t    linkIns[9] = {0xFC, 0x06, 0x04, 0x44, 0x54, 0x4B, 0x52, 0x46, 0x81};      //---INS01
   + s1 z2 p2 e1 R- }
2. uint8_t    restartIns[9] = {0xFC, 0x06, 0x06, 0x44, 0x54, 0x4B, 0xAA, 0xBB, 0x50};   //---INS02
   ( t% _! A! W7 ^4 t
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

复制代码

7 M9 I1 D. W9 U) s