官方下载freemodbus-v1.6.zip源码，然后把源码中的modbus文件夹、demo\BARE\port文件夹导入工程。

9 y5 m/ |  D8 x- k1 D/ \% z: v先是一波无脑导，把文件夹里所有文件导入。
) a+ a# o& O  p% v2 [
+ x3 X# }: _! p( M: W0 S存储区配置，单片机上定义的起始地址要比实际通信过程中读写的地址+1。

1. #include "mb.h"
     D( [( w" _# B- q
2. #include "mbport.h"
   
3. #include "mbutils.h"
   : p3 I2 K  O& d6 S
4. //输入寄存器
   
5. #define REG_INPUT_START 1001
   
6. #define REG_INPUT_NREGS 2
   ' n2 r3 }- L  m7 M0 `- D! {
7. 
   5 q0 T) O) {5 K6 i. y
8. static USHORT   usRegInputStart = REG_INPUT_START;
   
9. static USHORT   usRegInputBuf[REG_INPUT_NREGS];
   
10. 
    
11. //保持寄存器
    
12. #define REG_HOLDING_START 2001
    
13. #define REG_HOLDING_NREGS 1
    " g2 |! E* J; ~$ [) U) a3 k# x
14. 
    , Y& G" D9 f! X" I& K
15. static USHORT   usRegHoldingStart = REG_HOLDING_START;
    * w& W, T9 _( s: O7 x5 u8 h& H
16. static USHORT   usRegHoldingBuf[REG_HOLDING_NREGS];
    
17. 
    
18. //输出线圈点
    
19. #define REG_COILS_START 3001
    
20. #define REG_COILS_SIZE 4
    
21. 
    
22. static USHORT   usRegCoilsStart = REG_COILS_START;
    / ~9 n9 S! [6 q9 f
23. static UCHAR           ucRegCoilsBuf[REG_COILS_SIZE/8+(REG_COILS_SIZE%8?1:0)];
    , _$ E, g4 O; n* f1 @" k/ P/ p
24. 
    
25. //离散输入点
    
26. #define REG_DISCRETE_START 4001
    
27. #define REG_DISCRETE_SIZE 8
    0 k/ h5 t2 |( g
28. 
    
29. static USHORT   usRegDiscreteStart = REG_DISCRETE_START;
    / w# g: `6 G; z
30. static UCHAR           ucRegDiscreteBuf[REG_DISCRETE_SIZE/8+(REG_DISCRETE_SIZE%8?1:0)];
    
31. 
    0 @, [4 ?5 w: D, o

复制代码

  P% I% j" A2 g" k7 L- {; `9 s1 F主程序就是标准的运行三连+IO读写。
( V% r5 M; V6 f, ~" D9 }4 p

1. eStatus = eMBInit( MB_RTU, addr, 0, 9600, MB_PAR_EVEN );
   
2. 
   
3.     /* Enable the Modbus Protocol Stack. */
   " X8 G1 C2 F) M  }8 T; b& o! ^$ ~4 f
4.     eStatus = eMBEnable(  );
   6 ]$ q. d; M, J* }' T' a3 T
5. 
   7 x- K6 b/ `  V! _, [' z
6.     for( ;; )
   
7.     {
   & g' H4 w) R) t
8.         ( void )eMBPoll(  );
   5 R9 M# y1 ^) A
9.         usRegInputBuf[0]=Get_Adc_Average(8,10);
   / Z0 D9 Z4 q1 |; @4 Q$ P; t* p6 Z
10.         usRegInputBuf[1]=Get_Adc_Average(9,10);
    
11.                        
    : z8 K2 l) i5 M! e' k3 v1 i
12.         ucRegDiscreteBuf[0]=(GPIOB->IDR&0xFFFFFF00)>>8;
    & |. D7 f( x9 k
13.         GPIOB->ODR=GPIOB->ODR&0xFFFFFF0F;
    
14.         GPIOB->ODR=GPIOB->ODR|ucRegCoilsBuf[0]<<4;
    
15.     }
    

复制代码

支持的4种读写function扔在主函数后面就行了。
! I4 c  I  C& ~2 R( D/ P

1. /**
   
2. * @brief 输入寄存器处理函数，输入寄存器可读，但不可写。
   6 r: S8 ~6 ~& L; s
3. * @param pucRegBuffer 返回数据指针
   3 `+ E6 t. m1 c: q
4. * usAddress 寄存器起始地址
   
5. * usNRegs 寄存器长度
   6 g, v, _. O3 I: q3 y2 q, f
6. * @retval eStatus 寄存器状态
   
7. */
   1 ]* V8 g( p7 p% f6 {
8. eMBErrorCode
   5 y' ?' f5 U$ c6 H* g9 B
9. eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
   2 s% }0 F; R- n
10. {
    
11.     eMBErrorCode eStatus = MB_ENOERR;
    / G9 |/ U/ E3 u3 {" z  U0 z5 e+ s
12.     int16_t iRegIndex;
    
13. 
    
14.     //查询是否在寄存器范围内
    
15.     //为了避免警告，修改为有符号整数
    
16.     if( ( (int16_t)usAddress >= REG_INPUT_START ) \
    
17.             && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
      X- t/ y, E' g1 A
18.     {
    2 B" j1 O# V# m# A( J  e
19.         //获得操作偏移量，本次操作起始地址-输入寄存器的初始地址
    " T$ l* M$ x) A1 x0 B6 W- A! _& d
20.         iRegIndex = ( int16_t )( usAddress - REG_INPUT_START );
    $ I7 }/ {; m1 h5 m# r
21.         //逐个赋值
    
22.         while( usNRegs > 0 )
    % g0 J* P, Y& b! G& a2 P8 ^
23.         {
    ; A' Z5 g- p$ z, t, Z
24.             //赋值高字节
    , ?' B( B+ U+ S& ~& ^5 f7 v; Y
25.             *pucRegBuffer++ = ( uint8_t )( usRegInputBuf[iRegIndex] >> 8 );
    
26.             //赋值低字节
    1 u( @, M2 x- T3 L0 k: ?+ y
27.             *pucRegBuffer++ = ( uint8_t )( usRegInputBuf[iRegIndex] & 0xFF );
    - O" p" M. H! m
28.             //偏移量增加
      L8 T5 c4 k& s+ v/ S* U" G3 i
29.             iRegIndex++;
    , M$ A! _5 e% t+ A
30.             //被操作寄存器数量递减
    
31.             usNRegs--;
    + x+ ^5 z. ~+ v4 i
32.         }
    
33.     }
    ( Y) [2 n8 j7 \& V# [: o6 ?, z( ?
34.     else
    
35.     {
    7 s4 N% [* f5 A8 j
36.         //返回错误状态，无寄存器
    7 a8 z4 I3 i, X, S$ e8 l+ e% X& K) `4 _
37.         eStatus = MB_ENOREG;
    
38.     }
    - X1 Z# Q' S7 U9 d4 Q) Z
39. 
    7 i& `& a( b1 r4 y' F  T
40.     return eStatus;
    9 C( k" R1 |0 N% G7 O% a( l3 D5 E
41. }
    
42. 
    9 f6 }$ k5 ]+ g7 }
43. /**
    
44. * @brief 保持寄存器处理函数，保持寄存器可读，可读可写
    
45. * @param pucRegBuffer 读操作时--返回数据指针，写操作时--输入数据指针
    + |0 J0 i: L1 d! k8 R& ]
46. * usAddress 寄存器起始地址
      T, Q! R& e; _. N
47. * usNRegs 寄存器长度
    
48. * eMode 操作方式，读或者写
    
49. * @retval eStatus 寄存器状态
    
50. */
    0 O. R  i' Z! r7 @* v
51. eMBErrorCode
    
52. eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs,
      g5 S; Z5 I3 h" c
53.                  eMBRegisterMode eMode )
    2 a$ y1 ~/ r" Y  e* u
54. {
    
55.     //错误状态
    
56.     eMBErrorCode eStatus = MB_ENOERR;
    1 }) N. F* u7 M0 j0 o& B* u  f% ^
57.     //偏移量
    
58.     int16_t iRegIndex;
    
59. 
    ) G& v1 k/ c' q/ }' Y) E3 }
60.     //判断寄存器是不是在范围内
    4 O( ^( P2 Y4 i6 p. W4 P/ Z
61.     if( ( (int16_t)usAddress >= REG_HOLDING_START ) \
    9 S9 S$ X9 ^; {6 y. c: ]0 Q5 C! b$ h
62.             && ( usAddress + usNRegs <= REG_HOLDING_START + REG_HOLDING_NREGS ) )
    
63.     {
    
64.         //计算偏移量
    ( }& i' D; q  I, c; z$ C+ I
65.         iRegIndex = ( int16_t )( usAddress - REG_HOLDING_START );
    * V1 y. o# a# F
66. 
    8 c0 l( m/ |& ~5 A% U
67.         switch ( eMode )
    ; ~- X" J$ @& i
68.         {
    ) K1 z! y$ b7 U. d/ ]0 Z
69.         //读处理函数
    ; v* B1 z8 m- Q
70.         case MB_REG_READ:
    
71.             while( usNRegs > 0 )
    ) r8 ]! u) S6 U, R# K5 _
72.             {
      W; L7 w" z& s4 N9 s$ G6 d2 j3 }
73.                 *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] >> 8 );
    
74.                 *pucRegBuffer++ = ( uint8_t )( usRegHoldingBuf[iRegIndex] & 0xFF );
    
75.                 iRegIndex++;
    
76.                 usNRegs--;
    . Z8 b5 }/ x) b
77.             }
    # W$ x5 a# U  l" v- V# j
78.             break;
    
79. 
    . p5 B2 H( q# b3 G" j7 x
80.         //写处理函数
    
81.         case MB_REG_WRITE:
    
82.             while( usNRegs > 0 )
    
83.             {
    
84.                 usRegHoldingBuf[iRegIndex] = *pucRegBuffer++ << 8;
    
85.                 usRegHoldingBuf[iRegIndex] |= *pucRegBuffer++;
    2 h- [! J& k. `3 o' k" C
86.                 iRegIndex++;
    
87.                 usNRegs--;
    4 z* y1 D) R; z0 h# N) c# H
88.             }
    
89.             break;
    # r- G/ R) H! h- N# J( e' y3 A
90.         }
    ! a- K$ [3 f6 a; |9 r
91.     }
    ( f( O5 i! o9 F
92.     else
    
93.     {
    $ N( p! S3 |" v0 e/ P! U8 S" x
94.         //返回错误状态
      {/ o$ G0 a+ L
95.         eStatus = MB_ENOREG;
    
96.     }
      p( L* \$ _% k' z
97. 
    
98.     return eStatus;
    
99. }
      I  [6 ^* B' q9 C% }0 n
100. 
     2 [/ w8 q" k, B, I
101. 
     
102. 
     
103. 
     
104. /**
     
105. * @brief 线圈寄存器处理函数，线圈寄存器可读，可读可写
     6 M" U( U1 x' Z3 |: u
106. * @param pucRegBuffer 读操作---返回数据指针，写操作--返回数据指针
     
107. * usAddress 寄存器起始地址
     
108. * usNRegs 寄存器长度
     , Y- T, A2 }# i1 _
109. * eMode 操作方式，读或者写
     + p8 U$ W  N+ R2 ]: E! r
110. * @retval eStatus 寄存器状态
     
111. */
     
112. eMBErrorCode
     + K2 K$ `  Z# y$ b3 I( e6 x
113. eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils,
     5 I0 b( o( X9 H9 w
114.                eMBRegisterMode eMode )
     $ m& J$ Q' M0 b2 Y* }+ H
115. {
     7 ]8 A0 E) ]* |: g& a5 c" z
116.     //错误状态
     3 ?. |+ M1 v0 ~! R  R- ^
117.     eMBErrorCode eStatus = MB_ENOERR;
     / D9 Y' r1 |* d, q7 H3 u
118.     //寄存器个数
     
119.     int16_t iNCoils = ( int16_t )usNCoils;
     ) f5 v& ~4 b9 K$ B7 ?" d
120.     //寄存器偏移量
     * f, v5 \- O0 h# ?
121.     int16_t usBitOffset;
     
122. 
     - r) [1 E4 Z" `% T$ M* ]5 E
123.     //检查寄存器是否在指定范围内
     
124.     if( ( (int16_t)usAddress >= REG_COILS_START ) &&
     
125.             ( usAddress + usNCoils <= REG_COILS_START + REG_COILS_SIZE ) )
     7 H8 R1 S0 j6 Y4 R
126.     {
     5 d( L. _8 U) e( E1 ]
127.         //计算寄存器偏移量
     
128.         usBitOffset = ( int16_t )( usAddress - REG_COILS_START );
     5 P4 s$ v! a9 U+ n  g
129.         switch ( eMode )
     
130.         {
     
131.         //读操作
     
132.         case MB_REG_READ:
     . h/ ~# i6 {7 n" h" N
133.             while( iNCoils > 0 )
     8 Q1 {; X2 C0 W. r" e2 z
134.             {
     ( o! p( _& m3 y4 z( v
135.                 *pucRegBuffer++ = xMBUtilGetBits( ucRegCoilsBuf, usBitOffset,
     
136.                                                   ( uint8_t )( iNCoils > 8 ? 8 : iNCoils ) );
     
137.                 iNCoils -= 8;
     ! D. W' L+ E& }7 O/ v" @& r
138.                 usBitOffset += 8;
     1 u# U# _: O5 t+ L7 r
139.             }
     0 h) F: i* ^  [& L* B
140.             break;
     : I' l' y/ l' C3 O( N6 j% H
141. 
     2 |/ [, D4 ^5 [- ?
142.         //写操作
     % }" ]% |" }! F, e; m+ ^5 ?
143.         case MB_REG_WRITE:
     ) P8 n7 z6 h" s! ?5 Q8 s3 m& u0 h
144.             while( iNCoils > 0 )
     6 t- M* O3 E4 H( ~/ R% v3 W/ v
145.             {
     & i& }3 J  q4 J$ V3 J2 K- \
146.                 xMBUtilSetBits( ucRegCoilsBuf, usBitOffset,
     - Q3 @& q" P2 O
147.                                 ( uint8_t )( iNCoils > 8 ? 8 : iNCoils ),
     * W) `) H' {. C  ?7 T0 U$ A
148.                                 *pucRegBuffer++ );
     
149.                 iNCoils -= 8;
     
150.                 usBitOffset += 8;
     
151.             }
     ( x4 Q; s4 d( b2 C$ h7 R  K
152.             break;
     + z. @0 s( G7 @
153.         }
     
154. 
     
155.     }
     . Q+ z" y0 W2 g9 N
156.     else
     
157.     {
     1 O: f  W. }( Y
158.         eStatus = MB_ENOREG;
     $ q3 t/ p9 G, C& ?& I; X
159.     }
     ; j/ v! X& L& P9 _$ C& A( L
160.     return eStatus;
     
161. }
     + G1 ]" Z; T- R. S
162. 
     
163. 
     
164. 
     # Z3 z7 g, N0 F# o* v0 ^7 b
165. 
     
166. /**
     
167. * @brief 开关输入寄存器处理函数，开关输入寄存器，可读
     3 f, c/ v  F) M0 h3 X( z+ }* U5 m
168. * @param pucRegBuffer 读操作---返回数据指针，写操作--返回数据指针
     ( _% `1 E; P. a0 \0 r
169. * usAddress 寄存器起始地址
     
170. * usNRegs 寄存器长度
     ( ]5 @% z, _3 e5 F# C. P2 w
171. * eMode 操作方式，读或者写
     
172. * @retval eStatus 寄存器状态
     / H( k% _  A3 T) r$ o0 z, F3 ]3 q
173. */
     
174. eMBErrorCode
     
175. eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
     * Y; R  L8 w! g
176. {
     
177.     //错误状态
     
178.     eMBErrorCode eStatus = MB_ENOERR;
       f6 H0 o( ]4 @, p9 N# O
179.     //操作寄存器个数
     
180.     int16_t iNDiscrete = ( int16_t )usNDiscrete;
     . I0 D! a  z: a2 V
181.     //偏移量
     
182.     uint16_t usBitOffset;
     3 o" T  a5 p! \, k- D2 p
183. 
     ) o  _7 @: t' z  I2 G$ b5 m" C5 C
184.     //判断寄存器时候再指定范围内
     & Z0 y8 T: R; L0 E2 l; b+ ^/ L
185.     if( ( (int16_t)usAddress >= REG_DISCRETE_START ) &&
     
186.             ( usAddress + usNDiscrete <= REG_DISCRETE_START + REG_DISCRETE_SIZE ) )
     
187.     {
     
188.         //获得偏移量
     
189.         usBitOffset = ( uint16_t )( usAddress - REG_DISCRETE_START );
     8 |* a8 x- P* v& W. k- B+ {
190. 
     - t  R: x$ f( F( o- L
191.         while( iNDiscrete > 0 )
     4 y( K: V; J" Y% w; K0 j3 ?
192.         {
     
193.             *pucRegBuffer++ = xMBUtilGetBits( ucRegDiscreteBuf, usBitOffset,
     % U# m2 F/ q+ D& ~" b
194.                                               ( uint8_t)( iNDiscrete > 8 ? 8 : iNDiscrete ) );
     9 g0 ~5 `7 N8 i5 a
195.             iNDiscrete -= 8;
     1 J$ j: X7 }$ n* h4 E5 O. X' O
196.             usBitOffset += 8;
     % e! D  V; g; r( S$ z( @" Y% ~; \$ ^
197.         }
     ) B" k* ]# m; P9 p* f0 ]4 w
198. 
     $ c. z' h" s  g. p9 u+ c5 i
199.     }
     
200.     else
     3 n( D% G; M( [* R8 g6 `( D7 F
201.     {
     
202.         eStatus = MB_ENOREG;
     ' m  a' Y6 \! G/ N) y
203.     }
     
204.     return eStatus;
     8 F* q5 R: H# G6 v
205. }
     
206. 
     * B4 W+ n( I  ^! B6 R
207. 
     % l/ ]1 y  i1 N/ H1 w

复制代码

porttimer.c是和定时器相关的实现接口，计算好预分频与装载值之后，可以直接调用原子例程。

1. /*
   
2. * FreeModbus Libary: BARE Port
   
3. * Copyright (C) 2006 Christian Walter <wolti@sil.at>
   
4. *
   " f, V2 n! f7 j2 s& |& j/ }; `8 Y
5. * This library is free software; you can redistribute it and/or
   7 A  F% I$ Q# n2 T' H" }: j
6. * modify it under the terms of the GNU Lesser General Public
   
7. * License as published by the Free Software Foundation; either
   0 t6 t4 D2 c/ X! X$ {7 _2 A
8. * version 2.1 of the License, or (at your option) any later version.
   % O# e6 s6 h, p3 V. h( t5 n% X
9. *
   % O. @- J8 [# ]' a( ^
10. * This library is distributed in the hope that it will be useful,
    
11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
      S0 x9 N. {8 a" l5 C* T/ t
12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
13. * Lesser General Public License for more details.
    - l! o0 o" U! {' p  n/ E  J; q
14. *
    % Y* c5 T6 Z. i; i3 s* }- ?: X8 O
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
    - O; ]1 O. M7 ^) L& Y2 N
17. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    $ D- e, I+ d3 o- p# k" _5 h4 d
18. *
    
19. * File: $Id$
    
20. */
    
21. 
    
22. #include "port.h"
    1 j+ i! X, m1 U; Z9 a2 W
23. 
    
24. /* ----------------------- Modbus includes ----------------------------------*/
    
25. #include "mb.h"
    , _5 ?- \+ b6 b. v' J2 P
26. #include "mbport.h"
    2 I+ m2 H# d  K8 n% G7 m
27. 
    
28. #include "rs485.h"
    
29. 
    
30. /* ----------------------- static functions ---------------------------------*/
    
31. static void prvvUARTTxReadyISR( void );
    
32. static void prvvUARTRxISR( void );
    1 I4 p% ^! ~( z" b- O4 K
33. 
    
34. /* ----------------------- Start implementation -----------------------------*/
    
35. void
    % Q# o2 C: v, I. M
36. vMBPortSerialEnable( BOOL xRxEnable, BOOL xTxEnable )
    ; i+ @& ]5 o+ A# p2 g
37. {
    4 N; k! r+ }, L" i% c/ Z1 {- z
38.     /* If xRXEnable enable serial receive interrupts. If xTxENable enable
    / L# i5 ^' ]+ k- F
39.      * transmitter empty interrupts.
    , n8 C; l" m6 O+ t0 P( R0 u$ R
40.      */
    4 H4 ]9 V5 y- r
41.     if(xRxEnable)
    1 Y  D% r' R- _' }: [/ I
42.     {
    
43.         //使能接收和接收中断
    
44.         USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
    - ~4 S: |& W! e7 E1 M5 T
45.         //MAX485操作 低电平为接收模式
    
46.         //GPIO_ResetBits(GPIOD,GPIO_Pin_8);
    9 n* o. e- B; N" Z: `( U
47.         RS485_TX_EN=0;
    
48.     }
    2 U( v; t4 m( C8 I0 M
49.     else
    
50.     {
    ; U8 r8 W+ S% ?  j- B
51.         USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);
    7 h3 P- o8 [9 a: [1 Y5 x
52.         //MAX485操作 高电平为发送模式
    
53.         //GPIO_SetBits(GPIOD,GPIO_Pin_8);
    . c% O( Z8 {+ Q, K
54.         RS485_TX_EN=1;
    
55.     }
    ( C1 g% `/ R+ j- g/ {5 W
56. 
    
57.     if(xTxEnable)
    
58.     {
    . {1 w/ s3 U- ~4 _" A5 y8 H
59.         //使能发送完成中断
    
60.         USART_ITConfig(USART2, USART_IT_TC, ENABLE);
    
61.     }
    
62.     else
    3 ]/ F  Y& C% ^1 L
63.     {
    0 l) z, {! y3 D1 [
64.         //禁止发送完成中断
    
65.         USART_ITConfig(USART2, USART_IT_TC, DISABLE);
    
66.     }
    
67. 
    5 b" S+ d3 `5 w5 p; |* V7 ?
68. 
    
69. }
    
70. 
    
71. BOOL
    
72. xMBPortSerialInit( UCHAR ucPORT, ULONG ulBaudRate, UCHAR ucDataBits, eMBParity eParity )
    
73. {
    
74.     RS485_Init(9600);        //初始化RS485
    
75.     return TRUE;
    / f# E  D# i$ G+ b: w$ c& v/ K
76.     //return FALSE;
    
77. }
    0 ~0 d/ S. a& o$ {0 {1 `8 t
78. 
    
79. BOOL
    , ?# O% W* z; {# X9 r! ~, B# f
80. xMBPortSerialPutByte( CHAR ucByte )
    
81. {
    
82.     /* Put a byte in the UARTs transmit buffer. This function is called
    6 |/ A; u" V/ V: [$ o
83.      * by the protocol stack if pxMBFrameCBTransmitterEmpty( ) has been
    
84.      * called. */
    
85.     //发送数据
    
86.     USART_SendData(USART2, ucByte);
    4 Q- J8 q# y( T8 M) c" {! I
87.     return TRUE;
    * i8 |9 _* r" N& |7 Z
88. }
    + T; ~( d) s& x" m' W
89. 
    3 e' a; i4 d" y% n0 n
90. 
    
91. BOOL
    
92. xMBPortSerialGetByte( CHAR * pucByte )
    
93. {
    ! L, j, x5 z$ `% ^  V  c. m
94.     /* Return the byte in the UARTs receive buffer. This function is called
    ' l6 {& j$ E) j3 V
95.      * by the protocol stack after pxMBFrameCBByteReceived( ) has been called.
    
96.      */
    
97.     //接收数据
    9 ^. q6 p$ M' ]- ^/ q* R
98.     *pucByte = USART_ReceiveData(USART2);
    
99.     return TRUE;
    
100. 
     
101. }
     
102. 
     ' N' F9 g3 z' N8 ^% P
103. /* Create an interrupt handler for the transmit buffer empty interrupt
     9 Q9 [. J; U: t. E
104. * (or an equivalent) for your target processor. This function should then
     
105. * call pxMBFrameCBTransmitterEmpty( ) which tells the protocol stack that
     
106. * a new character can be sent. The protocol stack will then call
     
107. * xMBPortSerialPutByte( ) to send the character.
     
108. */
     . X6 P0 P) s8 r( E' N' N- Y
109. static void prvvUARTTxReadyISR( void )
     
110. {
     
111.     pxMBFrameCBTransmitterEmpty(  );
     
112. }
     ! k- Y; Z( c$ ?' x& L
113. 
     + o# P9 o, {0 V! c5 S) S
114. /* Create an interrupt handler for the receive interrupt for your target
     4 N# l- y% s7 ~( X# t) f6 ?
115. * processor. This function should then call pxMBFrameCBByteReceived( ). The
     6 e# {( {- Y0 |, h& p
116. * protocol stack will then call xMBPortSerialGetByte( ) to retrieve the
     
117. * character.
     
118. */
     + ]( `- _% B3 J9 d9 @. J9 x& ^$ b
119. static void prvvUARTRxISR( void )
     7 c2 ?9 G) R2 ]( a1 b
120. {
     0 [3 w. c0 |2 L: `3 c% c$ @- b
121.     pxMBFrameCBByteReceived(  );
     
122. }
     2 ?9 Y  E8 H! m. L; }, o/ \7 j
123. 
     
124. void USART2_IRQHandler(void)
     
125. {
     , [# _1 k1 W, L# x2 q9 J
126.     if(USART_GetITStatus(USART2, USART_IT_RXNE) == SET)
     4 O+ n3 M' k( A) F. c6 q
127.     {
     
128.         prvvUARTRxISR();
     
129.         //清除中断标志位
     - `$ d& }% J1 c9 S9 O# U; h2 M
130.         USART_ClearITPendingBit(USART2, USART_IT_RXNE);
     " a( Z* G0 u' `5 ^% Q( P( H
131.     }
     ; b, e& G8 T6 D
132. 
     
133.     //发生完成中断
     2 H8 O) w8 E' w1 J* y/ C
134.     if(USART_GetITStatus(USART2, USART_IT_TC) == SET)
     1 H2 t( R3 D# x4 h0 [* z
135.     {
     
136.         prvvUARTTxReadyISR();
     - Y8 a8 ?$ e2 g8 Q+ a- Q8 p
137.         //清除中断标志
     8 J6 x* }7 I6 C- r7 o& s9 e5 a6 `3 y
138.         USART_ClearITPendingBit(USART2, USART_IT_TC);
     & B3 e* O, Q% O; G* h, [
139.     }
     6 H& k: I, Z' z; ]! m7 x
140. 
     
141. }
     
142. 
     2 D) r" v0 p- e( D/ w2 S# G

复制代码

! Y+ U# P. Y0 w3 U9 wmodbus移植过程基本就完成了。
————————————————
7 F! x' V1 h$ J( B$ h版权声明：小盼你最萌哒
如有侵权请联系删除
8 i+ f8 M8 P9 |5 C2 V