一、WK2168介绍
: g& y: G7 A9 p7 n2 iWK2168是首款具备256级FIFO的低功耗并支持 UART/SPITM/IIC/8位并行总线接口的
4通道UART器件。可以通过模式选择使得该芯片工作于以上任何一种主接口模式，将选
定的主接口扩展为4个增强功能的UART。
扩展的子通道的UART具备如下功能特点：
6 r& [6 o1 t# A' _) w8 U8 o$ w: _1.每个子通道UART的波特率、字长、校验格式可以独立设置，最高可以提供2Mbps
的通信速率。
2.每个子通道可以独立设置工作在IrDA红外通信、 RS-485自动收发控制、 9位网络
# E: N& p6 _0 }, q4 M" [: n) m! g地址自动识别、软件/硬件自动流量控制等高级工作模式下。
0 b; k0 [4 D! N3.每个子通道具备收/发独立的256 级FIFO， FIFO的中断可按用户需求进行编程触
6 w, K, E3 S1 i& I* N: }2 k6 c发点且具备超时中断功能。
WK2168采用LQFP48绿色环保的无铅封装，可以工作在2.5～5.0V的宽工作电压范围，
- ^: J1 D$ n8 H+ D, _8 M8 K5 O9 q9 Z- ~具备可配置自动休眠/唤醒功能
二、硬件连接
( c3 h; r! }1 c1 M# |; O


# U( i6 U6 p# R) n2 ^! z3 t6 i$ E

, a! I. |: V7 ?3 X7 T* B0 q7 i三、驱动代码
6 C9 `5 R/ M  x. H+ Xmain.c

  e: H0 `- c2 N% O$ {( L1 ]/ c

1. #include "sys.h"
   ( ~' s2 c+ V/ f- L2 `. i
2. #include "delay.h"
   2 Z7 U) \1 u2 m) T" o9 B
3. #include "usart.h"
   
4. #include "led.h"
   
5. #include "wk2168.h"
   3 N- @: {7 ~/ w! w
6. 
   
7. 
   
8. 
   1 D' m2 D: }* o' ~: V$ ]
9. 
   1 Q9 y# i9 W8 J0 n
10. 
    * i4 I9 B0 k6 q
11. int main(void)
    
12. {        
    
13.         //wk2xxx相关定义
    3 Q/ I$ l+ j; A1 n
14.         u8 sendTimeCnt;
    
15.         u16 ledCnt;
    $ j) }7 r: p3 k% h, g8 C1 r2 ^) N
16.         u8 dat1;
    / w( P: I1 B. t! ~$ E. m
17.         u8 sendData[5]={0x01,0x02,0x03,0x04,0x05};
    3 |+ L5 U  s$ i5 C
18.         
    5 W$ h3 W' W/ b/ T% Y
19.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
    
20.         delay_init();        
    
21.         uart_init(115200);
    ' T4 [: f7 @* q! @$ ]) w
22.         led_init();        
    8 `3 b1 u4 V- \, A* _3 w
23.         wk2168_init();        
    , j9 t7 c% S5 `* A
24.         wk2168_exit_init();
    ; d! h  r! t. t  T* b) @3 l5 l2 i
25. 
    
26. /*读写GNEA，测试主接口通信是否成功*/
    ( s. d( V7 u" a( G# J
27.         dat1=wk2168_read_g_reg(WK2XXX_GENA);
    
28.         printf("gena=0x%x.\r\n",dat1);
    % R& b* z5 \- e2 v
29. 
    ; }$ J# a7 ^) X' a
30. 
    
31.         /*初始化子串口*/
    5 T) o/ {( h# j- Z: }8 Q
32.         wk2168_sub_uart_init(1);
    / |$ N# b! e' E
33.         wk2168_sub_uart_init(2);
    
34.         wk2168_sub_uart_init(3);
    
35.         wk2168_sub_uart_init(4);
    
36.         /*设置子串口波特率*/
    9 i+ I- _7 i5 a# f. s6 ?
37.         wk2168_set_baudrate(1,B9600);
    0 ^1 W2 e" y; J
38.         wk2168_set_baudrate(2,B9600);
    
39.         wk2168_set_baudrate(3,B9600);
    7 f1 M# x& D$ V8 |8 O2 R6 M6 @
40.         wk2168_set_baudrate(4,B9600);
    
41.         /*使能485*/
    
42.         wk2168_set_rs485(1);
    
43.         wk2168_set_rs485(2);
    * G0 X/ f( G6 e, o4 ~! W! _: E
44.         wk2168_set_rs485(3);
    * u3 k+ `/ \+ I  }2 `* ]2 R
45.         wk2168_set_rs485(4);
    ' P, @9 t% ~! t' Z6 p  m- E
46. 
    2 O6 x1 m3 U1 P% I# i
47.         
    8 o1 m( Y* B, u7 }  f- N
48.         while(1)
    
49.         {
    
50.                
    
51.                 sendTimeCnt++;
    
52.                 if(sendTimeCnt>=100)
    
53.                 {
    
54.                         sendTimeCnt=0;
    
55.                         wk2168_exti_disable();               
    - [) _6 k+ p/ `
56.                         wk2168_write_s_fifo(1,sendData,sizeof(sendData));
    
57.                         wk2168_write_s_fifo(2,sendData,sizeof(sendData));
    % G/ n- P) i9 Z& H* t. H1 u
58.                         wk2168_write_s_fifo(3,sendData,sizeof(sendData));
      w! u. c9 O2 o* ]3 E
59.                         wk2168_write_s_fifo(4,sendData,sizeof(sendData));
    
60.                         wk2168_exti_enable();                                
    4 o5 V, F) u1 C0 Z  ^
61.                         
      ]+ F8 x9 f( ^5 y# K% M" u6 `: K
62.                 }
    
63.         
    
64.                
    
65.                 ledCnt++;
    5 m5 T* U; I& D3 ~/ `1 D
66.                 if(ledCnt>=50)
    $ O5 `. |3 C# i& \% Y% M
67.                 {
    4 S7 j4 X9 C  w. W( F/ K8 }
68.                         ledCnt=0;
    
69.                         turn_prog_led();
    
70.                 }
    " z6 `8 X) V! D& E9 d% y
71.                
    
72.                 delay_ms(10);
    - ]# o6 I& ]( ?3 [  ^
73.         }
    
74. }
    3 `7 y" [% |: d# y1 \+ e2 L

复制代码

0 G: J% [- N6 g2 s/ Owk2168.c
" {- ^6 w- ]" A0 L4 I: v
* f% [5 j/ Y* S" J, |

1. #include "wk2168.h"
   
2. #include "delay.h"
   . ^! ^% N7 B6 p# P
3. 
   2 p- c  q' B5 q9 ]; X4 d  ~5 t6 {
4. 
   
5. void wk2168_init(void)
   + g& n" |/ Z9 G; G" e: J, r9 A
6. {
   " s% v# T( X9 [8 q* m! I
7.         GPIO_InitTypeDef GPIO_InitStructure;
   
8.         SPI_InitTypeDef SPI_InitStructure;
   ; ^- r- o' Z/ F! L# y  W
9.         
   : g4 e! t/ F9 W! R6 o$ f% }
10.         RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB | RCC_APB2Periph_SPI1, ENABLE );        
    - t, }! y' }& s1 v# U8 [
11.         
    
12.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;//PA0--INT#
    ) `2 I6 i' Y4 y( s* F
13.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;        
    
14.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;        
    ( \3 f) L" P: P  T/ {- @: O
15.         GPIO_Init( GPIOB, &GPIO_InitStructure );
    . `) Z" M- A7 {- Q; W$ N
16.         
    * F- n/ {, P' C- v- g
17.         
    
18.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;//SPI1_RST
    
19.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;        
    ( {  ^8 h7 W4 \' I( S8 b9 R
20.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;        
    
21.         GPIO_Init( GPIOB, &GPIO_InitStructure );
    
22.         GPIO_SetBits(GPIOB,GPIO_Pin_0);
    7 |" h3 K8 O* w4 O& [  D# R
23.         
    
24.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;//SPI1_CS
    9 O1 J1 C* _1 a3 k" z
25.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;        
    ( q% ^5 e' T- l; ?: }' ~
26.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;        
    + p  E8 w: C$ w) p! j/ ^
27.         GPIO_Init( GPIOA, &GPIO_InitStructure );
    
28.         GPIO_SetBits(GPIOA,GPIO_Pin_4);
    
29.         
    
30.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;//SPI1_SCK
    
31.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        
    " |- }6 _9 i6 Y7 Q' E; Q& ~
32.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
33.         GPIO_Init( GPIOA, &GPIO_InitStructure );        
    
34. 
    
35.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;//SPI1_MISO
    
36.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;               
    
37.         GPIO_Init( GPIOA, &GPIO_InitStructure );        
    $ m4 ]8 z/ `1 Z7 o" s3 i
38.         
    9 i; z+ g( i$ Y+ E3 m" _
39.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;//SPI1_MOSI
    3 K# H$ I  s" T- |% H* z* T
40.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;               
    
41.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    9 L; e4 H& Y4 h  d7 }: L6 V8 j
42.         GPIO_Init( GPIOA, &GPIO_InitStructure );
    
43.         
    
44.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;        
    
45.         
    # J; u* X5 \% ?* u( K3 z) d0 e
46.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;        
    . E7 y8 D7 G1 `" I$ N6 b
47. 
    8 v, i! A, J2 _2 o( H$ @
48.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;        
    
49.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;        
    
50.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;        
    
51.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;        
    
52.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
    
53.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        
    
54.         SPI_InitStructure.SPI_CRCPolynomial = 7;
    
55.         SPI_Init( SPI1, &SPI_InitStructure );
    ; K! A, A9 J; C' t! k5 a1 y* V
56. 
    
57.         SPI_Cmd( SPI1, ENABLE );
    
58.         
    ( R7 Q% s$ ~7 {7 B8 K# A
59. 
    ' l% \: P( d$ _2 v% z) F) h8 j8 h
60.         wk2168_rst=0;
    9 D' Z# p2 m- @; @, f# P4 r% u) [
61.         delay_ms(50);
    
62.         wk2168_rst=1;
    8 ]  m4 x: \! t  K8 C' G/ @
63.         delay_ms(10);
    
64.         
    
65. }
    ' }8 e6 z' {6 ~/ _( @9 ]* n
66. 
    
67. void wk2168_exit_init()
    
68. {
    
69.          EXTI_InitTypeDef EXTI_InitStructure;
    # P" m4 I1 w# B# W: ?9 t" T
70.          NVIC_InitTypeDef NVIC_InitStructure;
    ) H0 \) ~0 L+ ]
71. 
    2 ?$ ]  F# f% X" y4 Z
72.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);        //使能复用功能时钟
    0 d5 Z$ k5 E* I& f
73. 
    
74. 
    
75.           GPIO_EXTILineConfig(GPIO_PortSourceGPIOB,GPIO_PinSource1);//下降沿触发
    / ^. c2 f* [. B3 w8 p( x
76. 
    $ R7 v! N& g7 z; v
77.           EXTI_InitStructure.EXTI_Line=EXTI_Line1;        
    ; r! C! G& q" B4 E& D& C
78.           EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;        
    - P; g& Y/ F; J# ]! o/ N- l+ S
79.           EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
    
80.           EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    5 Q7 g- F! G" c) s% Q
81.           EXTI_Init(&EXTI_InitStructure);                 //根据EXTI_InitStruct中指定的参数初始化外设EXTI寄存器
    
82. 
    
83.     NVIC_InitStructure.NVIC_IRQChannel = EXTI1_IRQn;                        //使能按键KEY2所在的外部中断通道
    ) W' n* T2 O  T+ k+ O) ~
84.           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;        //抢占优先级2，
    
85.           NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;                                        //子优先级2
    . d, ^! ?  B. `, A6 D
86.           NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                                                                //使能外部中断通道
    5 y; b% U2 Z2 E0 O1 O
87.           NVIC_Init(&NVIC_InitStructure);        
    
88. }
    9 K' b; V1 P5 E, o% \# a; G% ]5 Y
89. void wk2168_exti_enable(void)
    
90. {
    & W$ ?' W4 Q4 f* s" X+ J$ B
91.         NVIC_InitTypeDef NVIC_InitStructure;
    
92.         
    
93.         NVIC_InitStructure.NVIC_IRQChannel = EXTI1_IRQn;                        //使能按键KEY2所在的外部中断通道
    2 J- x5 J4 z# b" F* {  W" R
94.           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;        //抢占优先级2，
    
95.           NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00;                                        //子优先级2
    8 X1 m% c; [3 F, Q. M' |3 d: {
96.           NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                                                                //使能外部中断通道
    4 S7 g, \0 k: s; G6 |: X; _" U
97.           NVIC_Init(&NVIC_InitStructure);
    % {7 U% t  e+ l, `, @( Z
98. }
    
99. 
    . V/ P6 x, k. o. Z) D
100. void wk2168_exti_disable(void)
     
101. {
     4 [2 {8 R; W' B( m" _% ~
102.         NVIC_InitTypeDef NVIC_InitStructure;
     
103.         
     
104.         NVIC_InitStructure.NVIC_IRQChannel = EXTI1_IRQn;                        //使能按键KEY2所在的外部中断通道
     , v# E* [; ]% d
105.           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;        //抢占优先级2，
     $ g* W2 w# L' s6 t: i
106.           NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00;                                        //子优先级2
     3 a7 d0 U2 G- f1 O4 M! A
107.           NVIC_InitStructure.NVIC_IRQChannelCmd = DISABLE;                                                                //使能外部中断通道
     
108.           NVIC_Init(&NVIC_InitStructure);
     
109. }
     5 ~9 D9 b5 Z: |) U6 N. q6 p; V2 z
110. //外部中断0服务程序
     
111. void EXTI1_IRQHandler(void)
     * K2 S, `9 k! }/ `' w
112. {
     
113.         u8 gifr,rxbuf[256];
     
114.         int rxlen;        
     0 e' \5 F! f3 J6 p: f
115.         if(EXTI_GetFlagStatus(EXTI_Line1)!= RESET)
     
116.         {
     3 s  a* B& I% {1 y5 R/ R( u
117.                 gifr=wk2168_read_g_reg(WK2XXX_GIFR);/**/
     5 Z; T4 V8 h% M& m- e
118.                 do{
     
119.                         if(gifr&WK2XXX_UT1INT)//判断子串口1是否有中断
     
120.                         {
     : [! z3 y+ b# _: D+ ~6 Y2 O$ Y8 O
121.                                 /*数据处理*/
     2 _9 M6 l+ b9 [& m. V
122.                                 /*数据接收*/
     
123.                                 rxlen=wk2168_rec_data(1,rxbuf);//一次接收的数据不会超过256Byte
     
124.                                 /*数据发送*/
     
125.                                 //把接收的数据发送出去
       t7 c5 f; H1 \
126.                                 wk2168_send_data(1,rxlen,rxbuf);
     
127. 
     8 v" S2 c3 z3 N3 y& v
128.                         }
     . ^5 U1 S" I! ^9 q4 h& o
129.                         
     
130.                         if(gifr&WK2XXX_UT2INT)//判断子串口2是否有中断
     * Q/ k6 J: ]. C* k
131.                         {
     
132.                                 /*数据接收*/
     * n- j3 o4 x5 w% _$ R% |$ t
133.                                 rxlen=wk2168_rec_data(2,rxbuf);//一次接收的数据不会超过256Byte
     4 ^( b. s+ F/ }8 i% B
134.                                 /*数据发送*/
     5 `) C! |. G1 C4 i3 Q2 ^7 ]
135.                                 //把接收的数据发送出去
     / d; m5 q; c, I6 D6 t
136.                                 wk2168_send_data(2,rxlen,rxbuf);
     
137.                         
     
138.                           }
     
139.                         if(gifr&WK2XXX_UT3INT)//判断子串口3是否有中断
     
140.                         {
     7 k( P$ ?$ T* Q
141.                                 /*数据接收*/
     8 @; d) A1 i# w1 Q4 I" S) R
142.                                 rxlen=wk2168_rec_data(3,rxbuf);//一次接收的数据不会超过256Byte
     
143.                                 /*数据发送*/
     1 T* k# J1 ?' \$ S/ h5 Y
144.                                 //把接收的数据发送出去
     4 p' D9 s  x1 O) q8 N5 l- q" d
145.                                 wk2168_send_data(3,rxlen,rxbuf);
     + v8 A% C- M. \- n- n8 z
146.                                 // printf("port!!!!\n");
     5 O0 ~, t5 e& M1 g0 U' t
147.                         }
     
148.                         if(gifr&WK2XXX_UT4INT)//判断子串口4是否有中断
     
149.                         {
     
150.                                 /*数据接收*/
     : Q" x' R7 Q# Z7 w! G$ |, _: i
151.                                 rxlen=wk2168_rec_data(4,rxbuf);//一次接收的数据不会超过256Byte
     
152.                                 /*数据发送*/
     
153.                                 //把接收的数据发送出去
     . j5 w1 Y3 X  Z' W
154.                                 wk2168_send_data(4,rxlen,rxbuf);
     3 F# y9 A7 T9 e2 S) q7 M
155.                         }
     & {1 m6 O0 S8 u0 B
156.                         
     
157.                         gifr=wk2168_read_g_reg(WK2XXX_GIFR);
     
158.                         //printf("IN EXTI2_IRQ GIFR:0X%X !!!\n",gifr);
     8 g0 w# C* o; f5 w/ f
159.                 }while(gifr&0x0f);                                       
     , C) b5 g! N! D4 Q$ t8 X5 x
160.                 EXTI_ClearITPendingBit(EXTI_Line1); //清除LINE0上的中断标志位  
     , x& `, @9 J& J" x/ d( ^
161.         }
     
162. }
     
163. /* SPI交换一个字节接口 */
     " z& L( M1 c: [" X4 ^0 L
164. u8 wk2168_spi_read_write_byte(u8 TxData)
     + q' e% ]! W1 e( h$ M5 K
165. {
     
166.         u8 retry=0;                                         
     ( x  c3 y. w3 u" k! s* _
167.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
     # Q* d4 X- e; h* O% z! i$ u
168.         {
     
169.                 retry++;
     ! W0 K& v& [8 I+ ^5 F7 i: a  {3 J
170.                 if(retry>200)return 0;
     
171.         }                          
     ( S2 G# `3 P; R. u  g+ H( f/ q
172.         SPI_I2S_SendData(SPI1, TxData); //通过外设SPIx发送一个数据
     ; J, M1 K/ M0 x+ X% M: R! l* a2 ]
173.         retry=0;
     
174. 
     
175.         while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
     5 O! {8 T# K9 O- F# C4 z, d" b
176.         {
     
177.                 retry++;
     
178.                 if(retry>200)return 0;
     
179.         }                                                              
     
180.         return SPI_I2S_ReceiveData(SPI1); //返回通过SPIx最近接收的数据        
     5 V, M5 K  K  `/ E' G& P7 h; i
181. }
     
182. 
     2 J0 e! ]1 m8 K1 f
183. /*************************************************************************/
     
184. //函数功能：设置CS信号为高电平
     9 D* r7 O1 j5 h9 M% y
185. /*************************************************************************/
     
186. void wk2168_cs_high(void)
     
187. {
     : K8 n- f3 g$ J8 r6 f7 K
188.         GPIO_SetBits(GPIOA,GPIO_Pin_4);
     
189. }
     
190. /*************************************************************************/
     0 p: X( ]7 m; Q+ U
191. //函数功能：设置CS信号为低电平
     
192. /*************************************************************************/
     
193. void wk2168_cs_low(void)
     $ R& K1 D( V. a( j0 ]8 H$ A" F
194. {
     ( k" T! K/ |, e1 D+ l3 q+ S
195.         GPIO_ResetBits(GPIOA,GPIO_Pin_4);
     
196. }
     
197. /***************************wk2168_write_g_reg***********************************/
     
198. //函数功能：写全局寄存器函数（前提是该寄存器可写，
     
199. //某些寄存器如果你写1，可能会自动置1，具体见数据手册)
     $ M" R' e- y7 _" D: J0 b: ?
200. //参数：
     4 h/ t/ j' t+ T3 {: p2 M
201. //      greg:为全局寄存器的地址
     
202. //      dat:为写入寄存器的数据
     
203. //***********************************************************************/
     
204. void wk2168_write_g_reg(unsigned char greg,unsigned char dat)
     
205. {         
     
206.         u8 cmd;
     ) U  B; h8 J. z- t" F; s) Z
207.         cmd=0|greg;
     ) t' e8 {; P2 O' E' ?, H
208.         wk2168_cs_low();//拉低cs信号
     
209.         wk2168_spi_read_write_byte(cmd);        //写指令，对于指令的构成见数据手册
     1 E) m) [, W' ~1 A
210.         wk2168_spi_read_write_byte(dat);//写数据
     
211.         wk2168_cs_high();//拉高cs信号
     5 o6 ~+ U- K4 ~/ }
212. }
     ' O% R3 x& H6 f& U
213. /****************************wk2168_read_g_reg***********************************/
     9 \; r3 m# y8 q. t5 z7 R
214. //函数功能：读全局寄存器
       Y' G8 s& b6 S' M
215. //参数：
     
216. //      greg:为全局寄存器的地址
     
217. //      rec:返回的寄存器值
     
218. //***********************************************************************/
     ; z# P( D9 c! j' N
219. u8 wk2168_read_g_reg(unsigned char greg)
     
220. {         
     
221.         u8 cmd,rec;
     
222.         cmd=0x40|greg;
     
223.         wk2168_cs_low();//拉低cs信号
     
224.         wk2168_spi_read_write_byte(cmd);        //写指令，对于指令的构成见数据手册
     . F  j2 j$ J: c6 Y) ]+ E* W' b
225.         rec=wk2168_spi_read_write_byte(0);//写数据
     
226.         wk2168_cs_high();//拉高cs信号                                                        
     ( K6 g' Z9 B# T- @( H4 }1 i
227.         return rec;
     - e; ]! M" |& I4 F; e+ f6 Z2 B
228. }
     
229. 
     : E" T' k4 O( s/ G7 I
230. /**************************wk2168_write_s_reg***********************************/
     
231. //函数功能:
     * j7 C$ _( O+ o! S
232. //参数：port:为子串口
     9 |4 P8 |1 ~4 [0 o7 ?8 m
233. //      sreg:为子串口寄存器
     5 q, ^6 Y( {  w1 ]
234. //      dat:为写入寄存器的数据
     6 R" [" i+ Q& A- _& E: O
235. //注意：在子串口被打通的情况下，向FDAT写入的数据会通过TX引脚输出
     ! c0 K5 f/ E! }' N9 c+ l7 g
236. //**********************************************************************/
     
237. void wk2168_write_s_reg(u8 port,u8 sreg,u8 dat)
     
238. {         
     : ]: F5 E9 F3 W# [0 I1 N0 M$ ?# P0 r# e
239.         u8 cmd;
     ; c$ y" x( r! Y
240.         cmd=0x0|((port-1)<<4)|sreg;
     " d- h& E# N! m2 `9 z0 B4 l9 H6 y. a
241.         wk2168_cs_low();//拉低cs信号
     $ t& c& d; D: v* O' U
242.         wk2168_spi_read_write_byte(cmd);        //写指令，对于指令的构成见数据手册
     # L: j# L% p7 }  j( r: @! G+ d
243.         wk2168_spi_read_write_byte(dat);//写数据
     
244.         wk2168_cs_high();//拉高cs信号
     1 q4 a3 }) M8 p, I; M
245. }
     
246. 
     ; I2 ]) g) ^& t3 F. b; f) u1 E. g
247. /**************************wk2168_read_s_reg***********************************/
     2 _' d% w' ?5 o; i" V* s% q
248. //函数功能：读子串口寄存器
     
249. //参数：port为子串口端口号
     / W! U; u: H: h
250. //      sreg:为子串口寄存器地址
     
251. //      rec:返回的寄存器值
     
252. //**********************************************************************/
     % a' j4 R! B4 J6 m5 {( |
253. u8 wk2168_read_s_reg(u8 port,u8 sreg)
     
254. {         
     
255.         u8 cmd,rec;
     + j3 a# F# U8 D1 h% n
256.         cmd=0x40|((port-1)<<4)|sreg;
     % G( j7 p% R( ]  h( O% {0 Z
257.         wk2168_cs_low();//拉低cs信号
     
258.         wk2168_spi_read_write_byte(cmd);        //写指令，对于指令的构成见数据手册
     
259.         rec=wk2168_spi_read_write_byte(0);//写数据
     3 \* N  j; M' ?
260.         wk2168_cs_high();        //拉高cs信号                                                        
     
261.         return rec;
     
262. }
     
263. /************************wk2168_write_s_fifo***********************************/
     
264. //函数功能:向子串口fifo写入需要发送的数据
     / E) k, I2 Z6 ]8 r9 k: d
265. //参数：port:为子串口
     
266. //      *dat:写入数据
     $ J9 T' A- ~8 z  K+ }% a4 H% P' n
267. //      num：为写入数据的个数，单次不超过256
     6 j% m8 b: b# E: O: ~3 ~0 K" P0 O
268. //注意：通过该方式写入的数据，被直接写入子串口的缓存FIFO，然后被发送
     
269. //*********************************************************************/
     
270. void wk2168_write_s_fifo(u8 port,u8 *dat,int num)
     0 \8 F3 S& X" B' F8 T, x
271. {         
     
272.         u8 cmd;
     
273.         int i;
     
274.         cmd=0x80|((port-1)<<4);
     9 G5 A% |- i0 d3 x
275.         if(num>0)
     
276.         {
     
277.                 wk2168_cs_low();//拉低cs信号
     / R# t! k- H. q3 `$ V
278.                 wk2168_spi_read_write_byte(cmd); //写指令,对于指令构成见数据手册
     
279.                 for(i=0;i<num;i++)
     " c$ O* U% ]4 t- X; U: k
280.                 {
     
281.                         wk2168_spi_read_write_byte( *(dat+i));//写数据
     1 w# {6 Q. ]! X: \6 o0 l
282.                 }
     - f5 q$ ?: r5 a1 S6 _
283.                 wk2168_cs_high();//拉高cs信号
     
284.         }
     & z( d" {+ I, y* N0 H+ O$ I
285. }
     5 b: v4 h/ v* T! R
286. 
     
287. /************************wk2168_read_s_fifo***********************************/
     
288. //函数功能:从子串口的fifo中读出接收到的数据
     " h- v/ U8 E1 C# n  v" q
289. //参数：port:为子串口
     
290. //      *rec：接收到的数据
     $ b2 R) Z. t8 ]( s5 h+ R
291. //      num：读出的数据个数。
     9 L- u# w  a: }: A: M
292. //注意：通过该方式读出子串口缓存中的数据。单次不能超过256
     * R  [0 |7 G  b/ I
293. //*********************************************************************/
     
294. void wk2168_read_s_fifo(u8 port,u8 *rec,int num)
     1 d9 {2 j- l! W. h! r
295. {
     1 k! T: {) j( b
296.         u8 cmd;
     ( v6 k2 n& p& X3 }! \, @
297.         int n;
     
298.         cmd=0xc0|((port-1)<<4);
     # c/ k# p4 a" z. @: V
299.         if(num>0)
     * s- u9 N& }/ B
300.         {
     
301.                 wk2168_cs_low();//拉低cs信号
     
302.                 wk2168_spi_read_write_byte(cmd);
     % M0 g, i: b3 r1 x
303.                 for(n=0;n<num;n++)
     # j, s! F% V2 Z* k' E# r8 k
304.                 {        
     
305.                         *(rec+n)=wk2168_spi_read_write_byte(0);        
     
306.                 }
     
307.                 wk2168_cs_high();//拉高cs信号
     8 Z+ L# Z( P, Z
308.         }
     - K8 z6 }! E( g7 L% i
309. }
     
310. 
     
311. 
     
312. /*******WkInit*******************************************/
     4 O. ]/ J6 q- m$ W' q
313. //函数功能：初始化子串口
     . {( Z1 p$ ]6 e# @3 G& i
314. /*******************************************************/
     , U! _1 E+ Z. z* r% j! ~8 I
315. void wk2168_sub_uart_init(u8 port)
     - \3 H- d! Y% t- Y/ L) h! {$ @
316. {
     ) k; V( M, W8 K3 P% P1 Y3 l
317.         u8 gena,grst,gier,sier,scr;
     
318.         //使能子串口时钟
     
319.         gena=wk2168_read_g_reg(WK2XXX_GENA);
     * o+ B; R) v8 H, d
320.         gena=gena|(1<<(port-1));
     + D1 g' g$ ~" G. b
321.         wk2168_write_g_reg(WK2XXX_GENA,gena);
     ! k) h4 T! E4 }3 w3 |" V
322.         //软件复位子串口
     
323.         grst=wk2168_read_g_reg(WK2XXX_GRST);
     
324.         grst=grst|(1<<(port-1));
     ; a4 k" ]% a! f* ~
325.         wk2168_write_g_reg(WK2XXX_GRST,grst);
     
326.         //使能串口总中断
     ' V+ {; u3 T, ~5 O
327.         gier=wk2168_read_g_reg(WK2XXX_GIER);
     
328.         gier=gier|(1<<(port-1));
     
329.         wk2168_write_g_reg(WK2XXX_GIER,gier);
     
330.         //使能子串口接收触点中断和超时中断
     
331.         sier=wk2168_read_s_reg(port,WK2XXX_SIER);
     
332.         sier |= WK2XXX_RFTRIG_IEN|WK2XXX_RXOUT_IEN;
     
333.         wk2168_write_s_reg(port,WK2XXX_SIER,sier);
     , M4 l5 z0 X% ]4 C# D1 j$ E( E$ |
334.         //初始化FIFO和设置固定中断触点
     
335.         wk2168_write_s_reg(port,WK2XXX_FCR,0XFF);  
     ; q% J: p8 T4 F' x  k
336.         //设置任意中断触点，如果下面的设置有效，
     
337.         //那么上面FCR寄存器中断的固定中断触点将失效
     
338.         wk2168_write_s_reg(port,WK2XXX_SPAGE,1);//切换到page1
     
339.         wk2168_write_s_reg(port,WK2XXX_RFTL,0X40);//设置接收触点为64个字节
     4 r3 s" l. ?9 @5 f0 |. U7 x* Q" C
340.         wk2168_write_s_reg(port,WK2XXX_TFTL,0X10);//设置发送触点为16个字节
     
341.         wk2168_write_s_reg(port,WK2XXX_SPAGE,0);//切换到page0
     * z6 t9 L4 T* Q" F
342.         //使能子串口的发送和接收使能
     , A) ]" `# b3 K/ i. {: V/ A8 b
343.         scr=wk2168_read_s_reg(port,WK2XXX_SCR);
     
344.         scr|=WK2XXX_TXEN|WK2XXX_RXEN;
     9 e$ W$ [) m/ L, U7 h
345.         wk2168_write_s_reg(port,WK2XXX_SCR,scr);                          
     
346. }
     & P  q. i0 @$ [3 v* b  q3 g
347. 
     4 z6 a$ h: x+ K
348. /******************************wk2168_sub_uart_deinit*******************************************/
     
349. //函数功能：初始化子串口
     
350. /*********************************************************************************/
     
351. void wk2168_sub_uart_deinit(u8 port)
     
352. {
     % J7 s' }) x4 _( R, `' T9 w
353.         u8 gena,grst,gier;
     / i( |  W' s, S( A
354.         //关闭子串口总时钟
     
355.         gena=wk2168_read_g_reg(WK2XXX_GENA);
     3 ]7 Q/ @6 O% ?" T
356.         gena=gena&(~(1<<(port-1)));
     7 _/ X' }* w5 k4 Y2 @  b0 e, l
357.         wk2168_write_g_reg(WK2XXX_GENA,gena);
     
358.         //使能子串口总中断
     - @- G) i3 S; u7 ]9 \2 b+ h( u/ F
359.         gier=wk2168_read_g_reg(WK2XXX_GIER);
     
360.         gier=gier&(~(1<<(port-1)));
     ! H$ C. i" T  q) b
361.         wk2168_write_g_reg(WK2XXX_GIER,gier);
     2 i8 }! T) ?/ ]8 n! |  B1 m# ^% ~) h  D
362.         //软件复位子串口
     
363.         grst=wk2168_read_g_reg(WK2XXX_GRST);
     
364.         grst=grst|(1<<(port-1));
     4 F6 p* M. a9 U
365.         wk2168_write_g_reg(WK2XXX_GRST,grst);
     
366.         
     
367. }
     
368. 
     
369. /**************************wk2168_set_baudrate*******************************************************/
     # i# L  ?% Z( O7 z2 o* l
370. //函数功能：设置子串口波特率函数、此函数中波特率的匹配值是根据11.0592Mhz下的外部晶振计算的
     
371. // port:子串口号
     $ Q6 Y5 H0 i0 o# O
372. // baud:波特率大小.波特率表示方式，
     % S* u# E" H8 o' p
373. /**************************Wk2114SetBaud*******************************************************/
     
374. void wk2168_set_baudrate(u8 port,enum WKBaud baud)
     
375. {  
     
376.         unsigned char baud1,baud0,pres,scr;
     # R+ _" J2 g& s, @9 ~, x3 S! G( b
377.         //如下波特率相应的寄存器值，是在外部时钟为11.0592mhz的情况下计算所得，如果使用其他晶振，需要重新计算
     ; K% [' {3 @+ T. p3 ?1 S! _
378.         switch (baud)
     ' d0 N- R$ m( s) q
379.         {
     ) ^: F4 K% ]" J+ A: O0 r' t; c
380.                 case B600:
     
381.                         baud1=0x4;
     
382.                         baud0=0x7f;
     2 k$ o! W" d6 j# e4 X$ E1 z
383.                         pres=0;
     
384.                         break;
     
385.                 case B1200:
     3 p( q: {0 z+ I/ X+ B* j
386.                         baud1=0x2;
     ; b( l, j/ ]) T9 D1 E5 D* `0 W
387.                         baud0=0x3F;
     " E* z) J; ~9 F
388.                         pres=0;
     
389.                         break;
     
390.                 case B2400:
     
391.                         baud1=0x1;
     
392.                         baud0=0x1f;
     $ j- Y$ D5 S; `( c/ t
393.                         pres=0;
     
394.                         break;
     
395.                 case B4800:
     7 Q( t& a2 M: H6 Q, l- M
396.                         baud1=0x00;
     
397.                         baud0=0x8f;
     
398.                         pres=0;
     
399.                         break;
     
400.                 case B9600:
     , ]. e& d4 p( i
401.                         baud1=0x00;
     
402.                         baud0=0x47;
     " p' a% q: M$ r4 ~
403.                         pres=0;
     
404.                         break;
     6 n7 F: m( |! M
405.                 case B19200:
     8 \5 F& E7 U: ?& u  d' r6 {4 h7 W
406.                         baud1=0x00;
     % A( C3 o# v/ F0 X# Z: E0 [3 s
407.                         baud0=0x23;
     
408.                         pres=0;
     
409.                         break;
     . ^. {# i3 y* b0 l7 V7 m1 W
410.                 case B38400:
     / R. y& w0 E' ~
411.                         baud1=0x00;
     : m9 i% g7 y+ h- Q6 Z. v0 k# E
412.                         baud0=0x11;
       d% ]" E' H1 Z! c$ @, y
413.                         pres=0;
     5 Y  v& y8 n  L
414.                         break;
     1 P3 I& o' l! a$ R- W
415.                 case B76800:
     : M, f. r5 M$ `% n) d' }5 P
416.                         baud1=0x00;
     2 U+ o: N) u8 f8 ^; l% H) V
417.                         baud0=0x08;
     
418.                         pres=0;
     
419.                         break;        
     
420.                 case B1800:
     
421.                         baud1=0x01;
     
422.                         baud0=0x7f;
     , H& I7 z" B+ |- U6 \
423.                         pres=0;
     
424.                         break;
     1 R/ v6 q# s) v2 {" J" M
425.                 case B3600:
     
426.                         baud1=0x00;
     
427.                         baud0=0xbf;
     ' U* ^# Y5 F1 g8 R
428.                         pres=0;
     & \5 V" o9 C3 R5 S& j6 V
429.                         break;
     
430.                 case B7200:
     
431.                         baud1=0x00;
     + W6 D2 J5 N# F# U* }8 \
432.                         baud0=0x5f;
     
433.                         pres=0;
     + H7 _8 ]7 |# c9 s7 D3 k8 \: `
434.                         break;
       M$ e2 c4 e& p" O* f8 A
435.                 case B14400:
     7 Q7 t/ s" o8 C% ~' b  z% Y
436.                         baud1=0x00;
     + I' l* |& A+ j8 d
437.                         baud0=0x2f;
     
438.                         pres=0;
     * F* q: D( Y* ^( b7 ?: x+ r
439.                         break;
     / o9 x5 C/ r. v8 I/ @8 [
440.                 case B28800:
     9 s5 P3 R( c# c$ R8 n7 j
441.                         baud1=0x00;
     
442.                         baud0=0x17;
     
443.                         pres=0;
     2 i" @& J; `5 N* ~
444.                         break;
     
445.                 case B57600:
     
446.                         baud1=0x00;
     
447.                         baud0=0x0b;
     
448.                         pres=0;
     
449.                         break;
       u% e; I4 ~. N, t* X) t
450.                 case B115200:
     8 W! i+ e, g9 s0 l! `
451.                         baud1=0x00;
     4 s  P9 O, a" A
452.                         baud0=0x05;
     6 K. A. H' W+ T8 }& r1 t4 x* X
453.                         pres=0;
     
454.                         break;
     + T5 {4 u% f: E) x, x# y, }
455.                 case B230400:
     
456.                         baud1=0x00;
     
457.                         baud0=0x02;
     
458.                         pres=0;
     
459.                         break;
     , g# @8 i, |) v" z. p
460.                 default:
     
461.                         baud1=0x00;
     
462.                         baud0=0x00;
     5 J, c( m8 r+ H/ Y& |
463.                         pres=0;
     $ i" f- ?: S6 `5 M# ]3 j6 m
464.     }
     
465.         //关掉子串口收发使能
     
466.         scr=wk2168_read_s_reg(port,WK2XXX_SCR);
     5 n$ ]6 Q7 ^9 a# |; O3 W; X5 D
467.         wk2168_write_s_reg(port,WK2XXX_SCR,0);
     4 p" J0 O" ^- ?! p# X' x, R
468.         //设置波特率相关寄存器
     ( D0 U: ]! G6 u+ D3 K0 j8 G
469.         wk2168_write_s_reg(port,WK2XXX_SPAGE,1);//切换到page1
     
470.         wk2168_write_s_reg(port,WK2XXX_BAUD1,baud1);
     
471.         wk2168_write_s_reg(port,WK2XXX_BAUD0,baud0);
     ; T. N. C) D- f/ p1 S
472.         wk2168_write_s_reg(port,WK2XXX_PRES,pres);
     
473.         wk2168_write_s_reg(port,WK2XXX_SPAGE,0);//切换到page0
     ( z* V! W% V, b+ F; f, C
474.         //使能子串口收发使能
     
475.         wk2168_write_s_reg(port,WK2XXX_SCR,scr);
     
476. }
     
477. /**************************wk2168_get_tx_len*******************************************/
     
478. //函数功能:获取子串口发送FIFO剩余空间长度
     
479. // port:端口号
     
480. // 返回值：发送FIFO剩余空间长度
     
481. /**************************WK_Len********************************************/
     
482. int wk2168_get_tx_len(u8 port)
     3 A+ [5 U+ M$ V4 f) m
483. {
     9 C8 a7 R" b2 k5 L
484.         u8 fsr,tfcnt;
     % Z& G4 z: N2 d5 |* o
485.         int len=0;
     
486.         fsr  =wk2168_read_s_reg(port,WK2XXX_FSR);
     
487.         tfcnt=wk2168_read_s_reg(port,WK2XXX_TFCNT);
     . D6 U* u1 T* I* k5 N  t0 o
488.         if(fsr& WK2XXX_TFULL)
     
489.         {
     # p* c6 k7 J7 c* P8 t
490.                 len=0;
     , t- y' a  b7 m5 E
491.         }
     
492.         else
     0 \6 S8 |$ x. H/ ^, V: }; [
493.         {
     
494.                 len=256-tfcnt;
     + u- ^! R, h: h1 b4 K2 ~7 M
495.         }
     
496.         return len;
     
497. }
     3 ]4 ]- `& j% W4 ?
498. 
     
499. /**************************wk2168_send_data*******************************************/
     & e- X* _- R) O5 ^
500. //函数功能:通过子串口发送固定长度数据
     
501. // port:端口号
     
502. // len:单次发送长度不超过256
     # t. o5 S# `/ A7 Y3 q: ?; k3 v
503. //
     / C# M' E% z( I& J8 I& v2 O
504. /**************************wk2168_send_data********************************************/
     
505. int wk2168_send_data(u8 port,int len,u8 *sendbuf)
     
506. {
     
507.         
     
508. #if 1
     6 Z) k- N5 V' @3 D) L( l- b
509.         wk2168_write_s_fifo(port,sendbuf,len);//通过fifo方式发送数据
     
510. #else
     
511.         int num=len;
     
512.         for(num=0;num<len;num++)
     
513.         {
     2 r- S8 i6 Y) z& i$ ]
514.                 wk2168_write_s_reg(port,WK2XXX_FDAT,*(sendbuf+num));
     
515.         }
     ! V0 L6 S+ y' D0 j, }
516. #endif        
     
517.         return 0;
     7 v; M0 Y# m: n/ O- m7 W; i
518. }
     
519. 
     * ?( K: G/ b0 F+ ?" |" A
520. /**************************wk2168_rec_data*******************************************/
       }, z3 }$ [' a8 {- m+ q
521. //函数功能:读取子串口fifo中的数据
     2 \4 ~3 i: |# ^+ ~3 }0 o
522. // port:端口号
     ( a( [9 g" i2 e2 i$ i$ }( a+ v
523. // recbuf:接收到的数据
     
524. // 返回值：接收数据的长度
     * e" [1 d& d" Z( t0 c1 T' |
525. /**************************wk2168_rec_data********************************************/
     1 h! M, U1 s3 s9 j
526. int wk2168_rec_data(u8 port,u8 *recbuf)
     4 y: `: c- H8 P  @$ o7 A' K
527. {
     1 A: e; O+ ~: i# g5 C( P" Y; a
528.         u8  fsr=0,rfcnt=0,rfcnt2=0,sifr=0;
     
529.         int len=0;
     8 N# A& N, ]( ^" c  `& I& h
530.         sifr=wk2168_read_s_reg(port,WK2XXX_SIFR);
     ' @% O3 R: I0 _( i
531.         
     
532. 
     " ?0 e, c/ y, k3 |, G( t  @. A
533.         if((sifr&WK2XXX_RFTRIG_INT)||(sifr&WK2XXX_RXOVT_INT))//有接收中断和接收超时中断
     $ `8 N, f& Z7 A+ t' ~& c4 w1 D9 v
534.         {
     
535.                 fsr  =wk2168_read_s_reg(port,WK2XXX_FSR);
     . k% T, ~1 |4 h+ \, }3 G
536.                 rfcnt=wk2168_read_s_reg(port,WK2XXX_RFCNT);
     * K3 `: |& K- \2 M( v. Q/ b
537.                 rfcnt2=wk2168_read_s_reg(port,WK2XXX_RFCNT);
     
538.                 //printf("rfcnt=0x%x.\n",rfcnt);
     
539.                 /*判断fifo中数据个数*/
     
540.                 if(fsr& WK2XXX_RDAT)
     0 J7 |8 \- n! _# Y8 b
541.                 {
     
542.                         if(!(rfcnt2>=rfcnt))
     3 Y' E- p4 y& H1 T0 x5 U
543.                         {
     
544.                                 rfcnt=rfcnt2;
     1 Z  N( n( o1 {# l! A
545.                         }
     $ H4 C3 b8 u& L5 ~
546.                         len=(rfcnt==0)?256:rfcnt;
     
547.                 }
     
548. #if 1
     
549.                 wk2168_read_s_fifo(port,recbuf,len);
     5 m" g! i; a/ g" a" ~/ u, E3 f4 `
550. #else
     
551.                 for(n=0;n<len;n++)
     
552.                  *(recbuf+n)=wk2168_read_s_reg(port,WK2XXX_FDAT);
     
553. #endif        
     
554.                 return len;
     
555.         }
     
556.         else
     5 ~3 E( N- v0 @  O7 f3 [/ d, Y
557.         {
     
558.                 len=0;
     : h# D, g4 T$ ^8 e) \: j
559.                 return len;
     
560.         }
     
561. }
     + T' R4 ^# l3 j: p4 \- s
562. 
     # J8 T6 i& @; e) \9 h
563. /**************************wk2168_set_rs485*******************************************************/
     
564. //函数功能:设置子串口RS485的收发转换函数，使用RTS引脚控制485电平转换芯片的收发
     9 A4 _0 {5 U8 n1 Y& W
565. // port:子串口号
     ; b& z/ W1 v% D+ x
566. //
     9 N0 F7 F; E4 \9 c6 Y
567. //注意：只有WK2168/WK2204支持该功能
     ' G3 g5 r( H1 J7 A$ z- f; I" }
568. /**************************wk2168_set_rs485*******************************************************/
       A) C- j/ c1 k; W! u  s0 M& w/ n' B
569. void wk2168_set_rs485(u8 port)
     
570. {   
     
571.         wk2168_write_s_reg(port,WK2XXX_RS485,0x02);//
     
572.         //wk2168_write_s_reg(port,WK2XXX_RS485,0x03);//
     
573.         wk2168_write_s_reg(port,WK2XXX_SPAGE,1);//切换到page1
     $ a3 |; |# i3 Z" q/ g& u% X
574.         wk2168_write_s_reg(port,WK2XXX_RTSDLY,0x01);
     
575.         wk2168_write_s_reg(port,WK2XXX_SPAGE,0);//切换到page0
     - E/ e! ]' X4 V' D" q/ x1 J. \
576. }
     : Q( i) A* j! F0 P4 g
577. /**************************wk2168_rts_cts*******************************************************/
     
578. //函数功能:硬件自动流量控制，需要子设备的支持
     
579. // port:子串口号
     
580. //
     ) j" ]! f& Y- G# ?8 G: f
581. //注意：只有WK2168/WK2204支持该功能
     / w: g  D1 Y7 D" W' {# B, s
582. /**************************wk2168_rts_cts*******************************************************/
     9 Q3 B% h- W+ ?6 y* n& O
583. void wk2168_rts_cts(u8 port)
     % r! N) c; K# `/ [+ i( R5 g
584. {   
     
585.         wk2168_write_s_reg(port,WK2XXX_FWCR,0x30);//
     
586.         wk2168_write_s_reg(port,WK2XXX_SPAGE,1);//切换到page1
     . {  _5 t$ U) o& g: {4 ?5 U' e  ?+ n9 }
587.         wk2168_write_s_reg(port,WK2XXX_FWTH,0XF0);//停止接收触点
     
588.         wk2168_write_s_reg(port,WK2XXX_FWTL,0X20);//继续接收触点
     
589.         wk2168_write_s_reg(port,WK2XXX_SPAGE,0);//切换到page0
     
590. }
     * M% Q' |* \/ e# h( A* c
591. 
     5 B9 l2 Y* E' Y; m
592. 
     
593. 
     2 \/ j; Z0 |, c/ k: H

复制代码