官方下载freemodbus-v1.6.zip源码，然后把源码中的modbus文件夹、demo\BARE\port文件夹导入工程。
4 P& n# U5 M3 C& o! l
. {: U0 t# H$ b1 y: v4 U5 }先是一波无脑导，把文件夹里所有文件导入。
1 h( h) S$ A- g
6 H* o1 n; u4 E  {& c) q3 G* s存储区配置，单片机上定义的起始地址要比实际通信过程中读写的地址+1。

1. #include "mb.h"
   ) I$ O2 J, |: c& ^% e  m
2. #include "mbport.h"
   , w% M. ]; g- M( x
3. #include "mbutils.h"
   
4. //输入寄存器
   " }! R0 s: P5 A- P) J
5. #define REG_INPUT_START 1001
   
6. #define REG_INPUT_NREGS 2
   . Y0 O' O0 F( ^0 ]* d
7. 
   & r* O& P* D' {4 Q2 D
8. static USHORT   usRegInputStart = REG_INPUT_START;
   
9. static USHORT   usRegInputBuf[REG_INPUT_NREGS];
   
10. 
    
11. //保持寄存器
    7 p& A( X* m1 a6 Z6 Z
12. #define REG_HOLDING_START 2001
    
13. #define REG_HOLDING_NREGS 1
    
14. 
    
15. static USHORT   usRegHoldingStart = REG_HOLDING_START;
    7 a$ Z: ?% A! m' Q4 x4 w; T5 i! X
16. static USHORT   usRegHoldingBuf[REG_HOLDING_NREGS];
    . d% X3 ?  w* g" Q
17. 
    2 y9 }3 j/ Q9 v* R4 B
18. //输出线圈点
    $ q& B! U( ?% K+ w/ r8 d! q' s3 B
19. #define REG_COILS_START 3001
    
20. #define REG_COILS_SIZE 4
    / o5 A3 c0 |1 ]1 ?- {2 Y3 G, E
21. 
    / y- C8 |( X, a" a& V
22. static USHORT   usRegCoilsStart = REG_COILS_START;
    $ ?! S# z) k# _1 i& J
23. static UCHAR           ucRegCoilsBuf[REG_COILS_SIZE/8+(REG_COILS_SIZE%8?1:0)];
    # k; T" b3 `2 z4 M
24. 
    
25. //离散输入点
    
26. #define REG_DISCRETE_START 4001
    " J+ {& H' y4 L% e3 c2 m
27. #define REG_DISCRETE_SIZE 8
    $ \$ m/ }! y  Y( v
28. 
    7 H8 l" k  a" b$ G
29. static USHORT   usRegDiscreteStart = REG_DISCRETE_START;
    , |3 Z3 j0 ^  R" j+ a. M
30. static UCHAR           ucRegDiscreteBuf[REG_DISCRETE_SIZE/8+(REG_DISCRETE_SIZE%8?1:0)];
    0 H8 F  {+ c6 k' Y0 S" l
31. 
    

复制代码

主程序就是标准的运行三连+IO读写。

1. eStatus = eMBInit( MB_RTU, addr, 0, 9600, MB_PAR_EVEN );
   
2. 
   
3.     /* Enable the Modbus Protocol Stack. */
   + J  `7 r% P  Y
4.     eStatus = eMBEnable(  );
   : C: G; J) l0 e& g
5. 
   
6.     for( ;; )
   
7.     {
   7 ?! X4 v9 I; l! ?0 y) C* C  K
8.         ( void )eMBPoll(  );
   
9.         usRegInputBuf[0]=Get_Adc_Average(8,10);
   5 g- \( \3 X" U  Y' f
10.         usRegInputBuf[1]=Get_Adc_Average(9,10);
    
11.                        
    
12.         ucRegDiscreteBuf[0]=(GPIOB->IDR&0xFFFFFF00)>>8;
    ! G' C1 p9 x# i& m) s4 Q+ b
13.         GPIOB->ODR=GPIOB->ODR&0xFFFFFF0F;
    & Z* w0 w4 P+ ~( {
14.         GPIOB->ODR=GPIOB->ODR|ucRegCoilsBuf[0]<<4;
    
15.     }
    

复制代码

支持的4种读写function扔在主函数后面就行了。
0 J" F7 [1 B$ \" @& H' p: D8 q

1. /**
   ' p. M" x* M) k% M
2. * @brief 输入寄存器处理函数，输入寄存器可读，但不可写。
   
3. * @param pucRegBuffer 返回数据指针
   
4. * usAddress 寄存器起始地址
   
5. * usNRegs 寄存器长度
   : P( [, e  Q; e6 r
6. * @retval eStatus 寄存器状态
   ) G( ]& Z# B& k& z. S& l
7. */
   
8. eMBErrorCode
   ' A/ b+ [2 j) K! f. _
9. eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
   + A! `6 Q4 W% @: ~* u
10. {
    
11.     eMBErrorCode eStatus = MB_ENOERR;
    
12.     int16_t iRegIndex;
    
13. 
    
14.     //查询是否在寄存器范围内
    # P9 Z7 P% ]7 [5 c. R" Q
15.     //为了避免警告，修改为有符号整数
    
16.     if( ( (int16_t)usAddress >= REG_INPUT_START ) \
    
17.             && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
    # P: m* @8 p/ V- o; A6 E+ y3 Q2 Q
18.     {
    ) ^, w- t7 _0 k6 @$ I* w
19.         //获得操作偏移量，本次操作起始地址-输入寄存器的初始地址
    
20.         iRegIndex = ( int16_t )( usAddress - REG_INPUT_START );
    
21.         //逐个赋值
    
22.         while( usNRegs > 0 )
    
23.         {
    
24.             //赋值高字节
    
25.             *pucRegBuffer++ = ( uint8_t )( usRegInputBuf[iRegIndex] >> 8 );
    ( f& l; Q! f" m- S: r. k, J
26.             //赋值低字节
    
27.             *pucRegBuffer++ = ( uint8_t )( usRegInputBuf[iRegIndex] & 0xFF );
    4 P  h+ O6 Z( l9 j; ]/ {
28.             //偏移量增加
    
29.             iRegIndex++;
    - v  @5 U# g) u. h* H$ |
30.             //被操作寄存器数量递减
    
31.             usNRegs--;
    . |1 A3 k2 L1 P% K& d- H; v6 j
32.         }
    
33.     }
    ' Y1 d) [- Q, J  l
34.     else
    
35.     {
    # P& U3 _4 |7 o9 S( E$ e7 o
36.         //返回错误状态，无寄存器
    , Z2 D0 A- A1 N$ y) F- h6 H% D
37.         eStatus = MB_ENOREG;
    ' g( G! b0 g% E* [7 ]: l
38.     }
    : n. c2 O& R1 O* {4 B5 l8 w
39. 
    
40.     return eStatus;
    ! Y2 x& P5 }. T0 w9 ^% |
41. }
    
42. 
    
43. /**
    
44. * @brief 保持寄存器处理函数，保持寄存器可读，可读可写
    8 V& I( Z% f# t$ C, I, F
45. * @param pucRegBuffer 读操作时--返回数据指针，写操作时--输入数据指针
    * \8 s, Q; r' U' U
46. * usAddress 寄存器起始地址
    4 H3 m4 R+ T4 M' ]% J* E  q& f5 z
47. * usNRegs 寄存器长度
    , x( r8 U( T, W* S4 `
48. * eMode 操作方式，读或者写
    
49. * @retval eStatus 寄存器状态
    0 f: ]& `7 M1 M. U
50. */
    : e& p) Z( N0 f0 Q, }& ~- l
51. eMBErrorCode
    
52. eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs,
    
53.                  eMBRegisterMode eMode )
    3 L! c& K6 X& L9 p* K2 r
54. {
    
55.     //错误状态
    
56.     eMBErrorCode eStatus = MB_ENOERR;
    
57.     //偏移量
    
58.     int16_t iRegIndex;
    . f: M& N/ Z- U1 g6 W! H$ [
59. 
    
60.     //判断寄存器是不是在范围内
    
61.     if( ( (int16_t)usAddress >= REG_HOLDING_START ) \
    
62.             && ( usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS ) )
    ' [5 i* S8 q. j" j0 d3 p
63.     {
    
64.         //计算偏移量
    ) L; X- h4 L0 B8 b
65.         iRegIndex = ( int16_t )( usAddress - REG_HOLDING_START );
    
66. 
    3 J( D* x8 j* ?  Y; I+ t- P
67.         switch ( eMode )
    
68.         {
    
69.         //读处理函数
    
70.         case MB_REG_READ:
    
71.             while( usNRegs > 0 )
    
72.             {
    / w. k( |. X( @5 P6 ]) Y/ s
73.                 *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] >> 8 );
    
74.                 *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] & 0xFF );
    
75.                 iRegIndex++;
    : F- Z2 e0 D7 N( Z# y. @
76.                 usNRegs--;
    " P% }. k; D: O  A1 N8 _
77.             }
    
78.             break;
    
79. 
    
80.         //写处理函数
    / I) D; @# K! ?/ n
81.         case MB_REG_WRITE:
    6 {. g2 ^8 C- S/ W5 q5 d8 @8 d
82.             while( usNRegs > 0 )
    3 B- a; F; J8 w: V: t* z& L. O
83.             {
    
84.                 usRegHoldingBuf[iRegIndex] = *pucRegBuffer++ << 8;
    
85.                 usRegHoldingBuf[iRegIndex] |= *pucRegBuffer++;
    ; `9 F9 M" f; D6 L! ~, q; q- D
86.                 iRegIndex++;
    9 V) @9 n9 j1 Q0 h* w! {5 ^" O
87.                 usNRegs--;
    
88.             }
    5 D3 E) j( U) {4 }7 B$ N" Y
89.             break;
    . V% ], J( s/ y# d2 E
90.         }
    , Y  O( a  E, v0 w2 E
91.     }
    / T! ]( u/ V; L, [# v
92.     else
    2 w8 Q* W5 |/ S) K6 Z8 o
93.     {
    
94.         //返回错误状态
    
95.         eStatus = MB_ENOREG;
    
96.     }
    ( o& ?  e  R4 _4 F6 A. L
97. 
    - k1 E& I/ w. G9 m- E9 b" G/ O! a
98.     return eStatus;
    7 ?/ k* h5 B5 ]" E1 P! [6 S: i
99. }
    
100. 
     
101. 
     
102. 
     
103. 
     
104. /**
     0 Y, G8 }: m  Z
105. * @brief 线圈寄存器处理函数，线圈寄存器可读，可读可写
     , |6 q. ~* L$ S- e
106. * @param pucRegBuffer 读操作---返回数据指针，写操作--返回数据指针
     ( h1 k# N) T) h# h3 l, g
107. * usAddress 寄存器起始地址
     + E& @" ^5 d" d+ j  A: M8 S
108. * usNRegs 寄存器长度
     / b) @" y$ P: B: L
109. * eMode 操作方式，读或者写
     , Q2 S& r& l. _3 A
110. * @retval eStatus 寄存器状态
       F7 g) M' k, @9 Q% @, [4 }
111. */
     , w) {9 Q/ d, o7 o5 z( d( U# D
112. eMBErrorCode
     # k9 B- N8 \: S( O
113. eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils,
     
114.                eMBRegisterMode eMode )
       U6 _$ P0 o& f1 ^9 G
115. {
     2 x- T/ p+ [" s* h4 ^1 D
116.     //错误状态
     4 l+ P' \: |* L* l
117.     eMBErrorCode eStatus = MB_ENOERR;
     
118.     //寄存器个数
     5 p% ^. g1 T" t
119.     int16_t iNCoils = ( int16_t )usNCoils;
     
120.     //寄存器偏移量
     
121.     int16_t usBitOffset;
     
122. 
     
123.     //检查寄存器是否在指定范围内
     
124.     if( ( (int16_t)usAddress >= REG_COILS_START ) &&
     * v2 L. Y- r( F4 v2 O% P
125.             ( usAddress + usNCoils <= REG_COILS_START + REG_COILS_SIZE ) )
     
126.     {
     
127.         //计算寄存器偏移量
     
128.         usBitOffset = ( int16_t )( usAddress - REG_COILS_START );
     
129.         switch ( eMode )
       X* ^0 m1 y8 m- H" m2 O  t
130.         {
     
131.         //读操作
     + O; q2 @/ v: |$ L1 X
132.         case MB_REG_READ:
     
133.             while( iNCoils > 0 )
     
134.             {
     * `4 A0 {2 B8 n3 [
135.                 *pucRegBuffer++ = xMBUtilGetBits( ucRegCoilsBuf, usBitOffset,
     
136.                                                   ( uint8_t )( iNCoils > 8 ? 8 : iNCoils ) );
     / _4 n2 G+ T; Q8 ^4 M$ l8 h
137.                 iNCoils -= 8;
     
138.                 usBitOffset += 8;
     / c. B+ \& h' o( B
139.             }
     ' K/ Q, i* [) @) _) B6 a2 V1 @
140.             break;
     ( |2 z  k9 R8 Q& D1 N# I# X. |
141. 
     & l5 {3 d; d: y! d& Q5 f8 Z, a( S9 E
142.         //写操作
     $ H' u+ R# [5 G# T, i# A- K
143.         case MB_REG_WRITE:
     
144.             while( iNCoils > 0 )
     
145.             {
     
146.                 xMBUtilSetBits( ucRegCoilsBuf, usBitOffset,
     ; j! r: \6 m  i2 O2 o0 }7 P% b
147.                                 ( uint8_t )( iNCoils > 8 ? 8 : iNCoils ),
     5 i* S8 K/ a' `! q. K$ z( @
148.                                 *pucRegBuffer++ );
     
149.                 iNCoils -= 8;
     
150.                 usBitOffset += 8;
     $ \% C) q& N* j6 u
151.             }
     
152.             break;
     % A# s6 u: J3 i/ Q6 L$ V4 L, n# k
153.         }
     2 u( Y/ Q, V5 h6 g5 W. T4 ]
154. 
     % i; O9 S& c+ [& I1 L# [: X
155.     }
     / U& H7 s" X: L9 S) P
156.     else
     
157.     {
     $ U! v1 y- C/ g/ W. K# |9 N, L
158.         eStatus = MB_ENOREG;
     : s% G  }3 M6 }* b
159.     }
     
160.     return eStatus;
     ( W( z3 D! c; E& _% R4 H- {
161. }
     8 [$ f" ?2 K: b0 u+ {
162. 
     + H& T; e3 l. `) ~9 D9 d6 F
163. 
     
164. 
     0 b& o% x. @& `" R# q
165. 
     * K& i; u! Z" a; v
166. /**
     
167. * @brief 开关输入寄存器处理函数，开关输入寄存器，可读
     
168. * @param pucRegBuffer 读操作---返回数据指针，写操作--返回数据指针
     $ E; @% i* |/ Y; e
169. * usAddress 寄存器起始地址
     
170. * usNRegs 寄存器长度
     
171. * eMode 操作方式，读或者写
     8 D! D2 M; `9 ^" @& w
172. * @retval eStatus 寄存器状态
     # J9 M% t3 U" I2 L9 V6 {
173. */
     
174. eMBErrorCode
     & z# B; w  W2 K
175. eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
     
176. {
     
177.     //错误状态
     
178.     eMBErrorCode eStatus = MB_ENOERR;
     " H0 W0 ^" u5 @7 F, e& x" ~
179.     //操作寄存器个数
     6 }9 K! q+ z& Y. z# B
180.     int16_t iNDiscrete = ( int16_t )usNDiscrete;
     
181.     //偏移量
     
182.     uint16_t usBitOffset;
     # L9 `$ \: ]7 K& `$ `
183. 
     9 f4 j8 W9 a( q/ l' ^1 d0 [. Y
184.     //判断寄存器时候再指定范围内
     " m4 G+ N6 W, j9 ~# K
185.     if( ( (int16_t)usAddress >= REG_DISCRETE_START ) &&
     + y' D3 }; F. V$ e; U; {, ~
186.             ( usAddress + usNDiscrete <= REG_DISCRETE_START + REG_DISCRETE_SIZE ) )
     
187.     {
     1 [0 s' Q; D; z& l2 U3 }3 ]
188.         //获得偏移量
     
189.         usBitOffset = ( uint16_t )( usAddress - REG_DISCRETE_START );
     
190. 
     
191.         while( iNDiscrete > 0 )
     
192.         {
     4 ]$ {: i1 h4 Z/ Q& y& k( v
193.             *pucRegBuffer++ = xMBUtilGetBits( ucRegDiscreteBuf, usBitOffset,
     
194.                                               ( uint8_t)( iNDiscrete > 8 ? 8 : iNDiscrete ) );
     
195.             iNDiscrete -= 8;
     , B9 v0 C( S9 v
196.             usBitOffset += 8;
     
197.         }
     
198. 
     + R  l8 M( h. B: u
199.     }
     ; w. J' m6 j" x
200.     else
     
201.     {
     3 L0 ~, r; P3 u
202.         eStatus = MB_ENOREG;
     
203.     }
     0 d& `; {0 y0 v' @% B+ q! ~
204.     return eStatus;
     0 l. t- @4 `9 o2 I3 ?6 y! g: _$ q% l2 E
205. }
     
206. 
     
207. 
     % |7 [5 z$ y1 v8 g# i$ m

复制代码

; K" \4 g: m) y  i% o1 Aporttimer.c是和定时器相关的实现接口，计算好预分频与装载值之后，可以直接调用原子例程。

1. /*
   ' o% P  o) X4 Y, r
2. * FreeModbus Libary: BARE Port
   
3. * Copyright (C) 2006 Christian Walter <wolti@sil.at>
     l2 U1 a& N9 }& f
4. *
   
5. * This library is free software; you can redistribute it and/or
   
6. * modify it under the terms of the GNU Lesser General Public
   
7. * License as published by the Free Software Foundation; either
   
8. * version 2.1 of the License, or (at your option) any later version.
   
9. *
   : t' U! K. [0 e8 ]7 R( Y. `
10. * This library is distributed in the hope that it will be useful,
    
11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    : W. m- |2 c$ v
12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
13. * Lesser General Public License for more details.
    % ?& y& T0 E1 l* U6 M/ p7 M
14. *
      i# y  R, S6 X
15. * You should have received a copy of the GNU Lesser General Public
    
16. * License along with this library; if not, write to the Free Software
    0 E( @, T# m' k. Q3 k, a
17. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    ' L. p, p+ ~7 t  `
18. *
    % u6 m+ h# E4 @% b6 y! B
19. * File: $Id$
    
20. */
    9 x- t9 N# |: ?! @- m- p
21. 
    
22. #include "port.h"
    8 F4 s- F" Z  ^. X$ k; ~
23. 
    
24. /* ----------------------- Modbus includes ----------------------------------*/
    
25. #include "mb.h"
    
26. #include "mbport.h"
    
27. 
    6 a3 m! T* U$ {7 C
28. #include "rs485.h"
    / u2 r) X2 c& V. e
29. 
    
30. /* ----------------------- static functions ---------------------------------*/
    / g8 ^) ^" J8 a6 s! y) {
31. static void prvvUARTTxReadyISR( void );
    $ r  J# ^8 y$ u. F$ [' K
32. static void prvvUARTRxISR( void );
    
33. 
    0 X4 E4 e: w9 I* L" `# w" A
34. /* ----------------------- Start implementation -----------------------------*/
    
35. void
    
36. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
    
37. {
    + c- r4 M4 h; h$ K+ `& e
38.     /* If xRXEnable enable serial receive interrupts. If xTxENable enable
    2 Y2 B: t) u; M
39.      * transmitter empty interrupts.
    
40.      */
    . w5 A# b1 T3 G! {
41.     if(xRxEnable)
    & G* [. [8 t7 G1 i
42.     {
    
43.         //使能接收和接收中断
    
44.         USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
    ( d8 T; Y( b+ @( ]% u5 ?# y
45.         //MAX485操作 低电平为接收模式
    
46.         //GPIO_ResetBits(GPIOD,GPIO_Pin_8);
    
47.         RS485_TX_EN=0;
    
48.     }
    9 w; Y  O1 ~& g8 z* v% S0 b9 c5 T  d
49.     else
    & T1 }9 h( q  ]$ ~1 \
50.     {
    
51.         USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);
    
52.         //MAX485操作 高电平为发送模式
    4 d& @3 P5 y. {9 `# C/ m
53.         //GPIO_SetBits(GPIOD,GPIO_Pin_8);
    ' |) S; W. A0 Y- ]
54.         RS485_TX_EN=1;
    
55.     }
    
56. 
    0 }3 X/ v# H9 u- T  l- |$ e
57.     if(xTxEnable)
    , f2 ]& W0 \- Y2 ]' U
58.     {
    : X7 J) @/ f) h% A  E# p
59.         //使能发送完成中断
    
60.         USART_ITConfig(USART2, USART_IT_TC, ENABLE);
    - a0 T3 }0 j, L0 t
61.     }
    
62.     else
    
63.     {
    2 W  y$ w" E5 L0 K; o0 s
64.         //禁止发送完成中断
    4 F1 M% g2 c$ `" I) G
65.         USART_ITConfig(USART2, USART_IT_TC, DISABLE);
    
66.     }
    3 {, j# I3 T; f$ k! [( T0 ]1 }# b
67. 
    ' X' ^9 N) O- m
68. 
    # P* q" I$ U( K9 {/ O$ c# a
69. }
    
70. 
    
71. BOOL
    
72. xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity )
    3 w# L. T* a7 \' h
73. {
    
74.     RS485_Init(9600);        //初始化RS485
    # R0 _( U2 s, J
75.     return TRUE;
    
76.     //return FALSE;
    
77. }
    6 R9 X1 b4 h4 q$ g% F$ ~# Y' A" w/ b
78. 
    
79. BOOL
    
80. xMBPortSerialPutByte( CHAR ucByte )
    
81. {
    
82.     /* Put a byte in the UARTs transmit buffer. This function is called
    
83.      * by the protocol stack if pxMBFrameCBTransmitterEmpty( ) has been
    " |' w) \! |6 N9 X# D2 @
84.      * called. */
    " p% {2 s$ ?9 }6 D5 \
85.     //发送数据
    " M7 A* z! r9 ]. s* [- Y
86.     USART_SendData(USART2, ucByte);
    
87.     return TRUE;
    
88. }
    
89. 
    
90. 
    
91. BOOL
    0 [/ ~1 c" _' q7 A& X5 h" U
92. xMBPortSerialGetByte( CHAR * pucByte )
    
93. {
    
94.     /* Return the byte in the UARTs receive buffer. This function is called
    
95.      * by the protocol stack after pxMBFrameCBByteReceived( ) has been called.
    
96.      */
    7 Q3 A5 R! }+ Q: w" T0 b, Y) c! [
97.     //接收数据
    
98.     *pucByte = USART_ReceiveData(USART2);
    2 f1 _# d9 n5 ?2 n7 I, \5 ~
99.     return TRUE;
    
100. 
     
101. }
     * e  `  `! q& o; g, F9 C
102. 
     ; Q# k0 O2 B. _; P# e
103. /* Create an interrupt handler for the transmit buffer empty interrupt
     ( ?. k3 T" q& I6 S" h
104. * (or an equivalent) for your target processor. This function should then
     
105. * call pxMBFrameCBTransmitterEmpty( ) which tells the protocol stack that
     1 V7 N) A( Z+ S  S0 E
106. * a new character can be sent. The protocol stack will then call
     
107. * xMBPortSerialPutByte( ) to send the character.
     
108. */
     
109. static void prvvUARTTxReadyISR( void )
     
110. {
     
111.     pxMBFrameCBTransmitterEmpty(  );
     
112. }
     
113. 
     
114. /* Create an interrupt handler for the receive interrupt for your target
     ; b0 S7 R& X, |: H7 \; A
115. * processor. This function should then call pxMBFrameCBByteReceived( ). The
     . r. l- ~( l4 j  h; p
116. * protocol stack will then call xMBPortSerialGetByte( ) to retrieve the
     
117. * character.
     
118. */
     
119. static void prvvUARTRxISR( void )
     
120. {
     # L; F! m! g4 Z! h  E' N5 k
121.     pxMBFrameCBByteReceived(  );
     
122. }
     
123. 
     $ K- x/ T- d& l4 J, d! d9 A; S
124. void USART2_IRQHandler(void)
     + c" o( V, s1 @# E4 E6 t
125. {
     
126.     if(USART_GetITStatus(USART2, USART_IT_RXNE) == SET)
     
127.     {
     
128.         prvvUARTRxISR();
     7 M; s# B' [3 I+ ?" v; l5 `5 d/ J
129.         //清除中断标志位
     
130.         USART_ClearITPendingBit(USART2, USART_IT_RXNE);
     , l3 H! y6 E$ `' |# S
131.     }
     
132. 
     
133.     //发生完成中断
     8 `& T; a- w& ~( a( K( J
134.     if(USART_GetITStatus(USART2, USART_IT_TC) == SET)
     
135.     {
     / a' I8 V! |% o
136.         prvvUARTTxReadyISR();
     
137.         //清除中断标志
     
138.         USART_ClearITPendingBit(USART2, USART_IT_TC);
     % X4 R2 ~$ `; R4 z
139.     }
     $ I/ \: D9 Q! r4 x8 A
140. 
     % e5 K7 Q' w' A5 _1 G
141. }
     
142. 
     % R/ L" O! t* r: u% e

复制代码

modbus移植过程基本就完成了。
7 \9 R! T/ Q4 _+ \+ S, t————————————————
版权声明：小盼你最萌哒
如有侵权请联系删除