c51单片机MODBUS参考程序

kinidrily · 发表于 2019-1-21 10:03

EDA365欢迎您登录！

您需要登录才可以下载或查看，没有帐号？注册

x

c51单片机MODBUS参考程序

//在触摸屏上作个位开关，单片机系统用LED指示

//在弹片机的硬件系统中用拨码开关来模拟数据输入，在EVIEW上显示

//本程序实现位的读写和字的读写，为一对一通讯，EVIEW为主机

#include<reg52.h>

#include<absacc.h>

#include<intrins.h>

#include<ctype.h>

/* These macro define simple data type */

#define uchar unsigned char

#define ulint unsigned long

#define uint unsigned int

/* These macro for Mudbus function code */

#define ReadCoilSta 0x01 // 0X read coil function

#define ForceSingleCoil 0x05 // 0X force single coil function

#define ReadHoldReg 0x03 // 4X read input register

#define PresetMulReg 0x10 // 4X write multi register

/* These macro describe index of communiction message from start to end */

#define CommIndexSlaveID 0 // macro for slave ID

#define CommIndexFunction 1 // macro for function code

#define CommIndexStartAdrHi 2 // macro for data hight adr

#define CommIndexStartAdrLo 3 // macro for data low adr

#define CommIndexNoPointHi 4 // macro for hight quantity datas

#define CommIndexNoPointLo 5 // macro for low quantity datas

/* These macro describe recieve message lenght of different function code */

/* But not include data lenght ,the data is master write to slave */

/* because we don't know the data lenght prior, it depend on ComBuf[ComIndexNoPoint] value */

#define ReadCoilStaIndexEnd 7 // 0~7,0x01,0X

#define ForceSingleCoilIndexEnd 7 // 0~7,0x05,0X

#define ReadHoldRegIndexEnd 7 // 0~7,0x03,4X

#define PresetMulRegIndexEnd 8 // 0~8,0x10,4X

/* these macro describe send or recieve allowed */

#define SEND 1 // send allowed

#define RECIEVE 0 // recieve allowed

#define SlaveID 0x01 // the slave's ID

#define SendRecieveDelay 50 // Send turn to Recieve or Recieve turn to Send delay time vlaue

#define MaxDataLen 30 // preset CommBuf array Max lenght

#define MaxRegLen 20 // preset SlaveOutputBuf Max lenght

/* variable for modbus is following */

bit data RecFinishF;

uchar data CommIndex;

uchar data CommIndexEnd;

uchar idata CommBuf[MaxDataLen];

uchar idata SlaveOutputBuf[MaxRegLen]; // Hight 8 bit of word is front,Low 8 bit is back

uchar idata SlaveInputBuf[MaxRegLen];

/* exp data define */

#define SlaveAdr XBYTE [0xD800]

sbit LED0=P1^0;

uchar idata ForceCoilBuf[10];

uchar count=0;

uchar forceval=0x00;

//bit forcesendF=0;

/* Table Of CRC Values for high-order byte */

uchar code auchCRCHi[] = {

0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,

0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,

0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,

0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,

0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,

0x00, 0xC1, 0x81,

0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,

0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,

0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,

0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,

0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,

0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,

0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,

0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,

0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,

0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,

0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,

0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,

0x40

} ;

/* Table of CRC values for low-order byte */

uchar code auchCRCLo[] = {

0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,

0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,

0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,

0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,

0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,

0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,

0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,

0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,

0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,

0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,

0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,

0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,

0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,

0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,

0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,

0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,

0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,

0x40

} ;

uint crc16(uchar *puchMsg,uchar usDataLen) // puchMsg message to calculate CRC upon

{ // usDataLen quantity of bytes in message

uchar uchCRCHi = 0xFF ; // high byte of CRC initialized

uchar uchCRCLo = 0xFF ; // low byte of CRC initialized

uint uIndex ; // will index into CRC lookup table

while (usDataLen--) // Pass through message buffer

{

uIndex = uchCRCHi ^ *puchMsg++ ; // calculate the CRC

uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex] ;

uchCRCLo = auchCRCLo[uIndex] ;

}

return (((uint)(uchCRCLo) << 8) | uchCRCHi) ;

}

/*------------- init code is following ----------------*/

void initSFR(void)

{

TH1=0xfa;

TL1=0xfa; // botelv set 9600 bps/s

TMOD=0x21; // T1 8bit timer for uart band rate, T0 16bit timer

PCON=PCON | 0x80; // band rate is 2 times

SCON=0x50; // uart mode is 01,start bit + 8 bit data +stop bit : peer to peer communication

PS=1; // uart intrrupt is hightest

TR1=1; // start T1

ES=1; // serially interrupt allow

EA=1; // chief interrupt allow

}

void initvar(void)

{

uchar i;

for (i=0;i<=250;i++)

_nop_();

T0=RECIEVE;

RecFinishF=0;

CommIndex=0;

CommIndexEnd=0xff; // First enlarge recieve lenght

for (i=0;i<MaxRegLen;i++)

SlaveOutputBuf=SlaveAdr;' m. Z" D: \/ g% i% A% g, b
9 ?( j& Y: Y4 @% K8 C7 K
}
0 Z% V( t* w1 d0 Y$ f; q- J1 S$ P7 ?1 w2 k9 w  N$ E- X$ D
void init(void)
! M8 y  D& h. _+ R
! z3 v1 A* ?: `& ^' r{% h! f* E) m( o, _  j

* a9 K5 x, G: q0 I( minitSFR();8 }& }4 O* x- l0 ]2 x

( e; ]2 b- @7 L3 l, g2 \3 Binitvar();
7 g( S( n) Z' z
4 f7 h" D. {$ c+ w}; M* o) w) F3 e7 Y) W
3 Z2 @, U6 V! {* Z1 h
void AnalyzeRecieve(void)
) v- _% f8 d) O) c' O- N
& F$ F4 [$ @7 M( G6 X8 I4 u{
& c- U9 T3 p  F/ Y3 t" S, `& ^3 X0 h# ^5 n' v" Z. S
uint crc16tem;
6 P$ k$ {7 N8 g( S- t! o5 H
# G& D3 n* R  x# h8 d3 Kuchar i,j;
% d/ L8 o1 E0 H0 F4 M* v" N1 p0 ]# }& @; h" W2 t3 P
if (CommBuf[CommIndexSlaveID]==SlaveID) // The slave ID is matched
" I  |' y; E: y: `7 d% ]5 a8 p5 _$ n8 X8 w
{9 g9 R2 B* Y9 @  P/ K' [5 S: j
% }7 ]8 T+ K7 ?
crc16tem=crc16(CommBuf,CommIndex-1); // calculate CRC check, erase two CRC byte
5 _' @9 O7 r0 c6 K. H% M, a% a- l. R* [" s* s- C
if (crc16tem==(((uint)(CommBuf[CommIndexEnd]) << 8) | CommBuf[CommIndexEnd-1]))7 I# ^: W5 ^" ^! A* [' g2 q3 C6 C3 @
+ ]2 R2 p/ F$ i: E. H3 {7 e/ Q
{ // crc16 check is OK
" o# j# F) Z4 g+ r1 l
1 t* }3 \+ S* u8 j/ p* g  ~switch (CommBuf[CommIndexFunction])
) s) z$ k/ |* Y! \  T# V/ Q3 a
* n1 c* N* }3 U- l{% }6 J2 c/ n, `9 @' _, W: }

8 F8 W- O, z& M4 k! _7 M- z) m; Kcase ReadCoilSta:
# }1 ]% Z3 h/ g; h: ]
0 o7 e7 t- v3 s' ~( q0 v1 C  HCommBuf[CommIndexSlaveID]=SlaveID; // 0
5 \' o, d1 I# y$ s' q7 V
$ {# U0 t8 g2 F: d/ X* h0 X6 x! YCommBuf[CommIndexFunction]=ReadCoilSta; // 1
$ q7 P& x" A2 f+ }
, L7 u2 ~1 Z: I; H* a7 C: [; a6 kCommBuf[2]=CommBuf[CommIndexNoPointLo] / 0x08; // 0x16 bit* d' S( S. C/ b; B
: i+ R4 V! e) z: G* R9 I
for (i=0;i<MaxRegLen;i++) // sim inputval for test
5 t% a4 W$ V8 k6 U1 Q+ D6 q
9 W5 O* ~" X6 x- kSlaveOutputBuf=forceval; // send data of master force coil val6 D1 _4 x( k+ x1 d
4 {" q: f" m7 p4 c$ X) r. j# W
i=CommBuf[2]+3;
/ ~* e) p8 X/ W6 |1 X$ n$ P  o% M. m2 V* a/ v9 M5 o# f+ q
for(CommIndex=3;CommIndex<i;CommIndex++) // send data Reg to Master9 k- _" _8 K1 N, i! U! n2 Y: |
  X9 Q/ K) I( e2 ~$ }
CommBuf[CommIndex]=SlaveOutputBuf[CommIndex-3]; // hight 8 bit is first send
" ^, s. z7 g: Q' X4 e! J- s0 f; R! X
crc16tem=crc16(CommBuf,CommIndex); // then send low 8 bit data
% n  e) Y" S# M* K9 V" x
. s3 l/ r- ]# S/ a1 A, ~6 r/ z9 JCommBuf[CommIndex++]=(uchar)(crc16tem & 0x00ff); // send crccheck low 8 bit is front7 Y8 n) G7 D4 m& g$ F& ^
5 ?, T2 C) m% n# Q0 X- Z
CommBuf[CommIndex]=(uchar)(crc16tem>>8); // then send hight 8 bit
1 P& C$ Q$ ^4 {4 K9 q
- _  n. t( ^4 Y  `+ jCommIndexEnd=CommIndex;5 e; x" @/ k8 u1 [; c* |5 ]# U
; x' C/ j/ y; V/ s
CommIndex=0;& H( @+ c# A& G# [/ X# X' Z9 _
  F6 J/ D  u& G9 N5 \# |
SBUF=CommBuf[CommIndex++];2 [9 B( w! \  E! q) \1 @, G' L
9 L/ x8 Z  |! {) D# |
break;- F* S4 d0 ]7 j4 Z8 O1 A
+ o7 t9 ?: g4 t+ O
case ForceSingleCoil:
* Y9 p# g; H8 o9 `: ]3 U
% |7 l1 r) G- c* A, [// SlaveInputBuf[0]=CommBuf[4]; // get data 0x00 or 0xff
/ @4 p5 ?: h2 J$ y/ x
1 N6 G' n0 _$ {: fif (CommBuf[4]==0xff). I0 T- K! h6 Y9 y1 Z
6 g2 K9 E' r( B4 ^+ m
LED0=0;
7 g5 I# w$ Q0 @' j$ A8 r0 x5 j! W) B# L6 ~
else4 m! h( {- k$ c+ G: b) _  \0 z* B

( G  |, i, I3 z; h3 y( ~LED0=1;/ `* k% T3 ?6 C  l1 X" s
: N9 w4 M1 f4 a+ P9 a7 a
// LED0=!LED0;
' q& Z: R! Q6 O: R! R" F
+ ~5 s4 `5 x1 p: }6 o) ^  ]ForceCoilBuf[count]=CommBuf[4];
: I" O, q9 M7 Y( Z* e6 H# }# W- w$ i1 D6 Y2 p: A  ~7 O2 {: \0 T
forceval=CommBuf[4];; B  w6 |4 U- t) c7 x4 N. x5 _

  L0 d* B9 e  K- x! j* ccount++;; }1 E+ G- h! p. _4 ]/ M' D

$ I1 r/ f5 N0 J% ]. C6 QCommBuf[CommIndexSlaveID]=SlaveID; // 0  H5 o& P0 L0 Y# P2 A1 Z" R: P
, O: z$ A  M: H4 O) s
CommBuf[CommIndexFunction]=ForceSingleCoil; // 1' L: N% D) a: B: o8 g
, @2 ]% N5 D2 z) C  n, d" Y% ^
CommIndex=2;
& E6 K6 G; h+ T+ E' i5 ]1 e
5 g- U& ]2 Q9 X4 q( y4 A" f// CommBuf[CommIndex++]=0x00;: ]# @$ L1 {2 x% ?
' g$ ?3 E, S2 S+ r4 s
// CommBuf[CommIndex++]=0x01;7 E3 M+ i; R- z6 e) O' F

' G, ~3 A! b4 C! h// CommBuf[CommIndex++]=0x00;! j3 \. y8 h  I9 e/ T7 D( K
# W; t8 o) J4 d
// CommBuf[CommIndex++]=0xff;1 b5 I7 x, G0 q8 u+ D

( v/ s/ O8 T& Q- e0 C// forcesendF=1;
7 H7 H! o5 c' M6 c. Z$ O  K1 y# Z$ E! y4 I7 q& c  L/ Y. v7 Y
CommBuf[CommIndex++]=CommBuf[CommIndexStartAdrHi]; // 2
* D  a) i* W4 E1 G) z
: r! H8 T9 l; d3 d9 ^6 {- V9 SCommBuf[CommIndex++]=CommBuf[CommIndexStartAdrLo]; // 3
1 T. w- J$ j6 B2 N. O' K0 w: i3 L
CommBuf[CommIndex++]=CommBuf[CommIndexNoPointHi]; // 4
* Q7 y6 T1 K( M1 `0 S, x0 w$ r5 K: L
CommBuf[CommIndex++]=CommBuf[CommIndexNoPointLo]; // 5
+ X9 [1 m  I* e
3 u/ w" v" A- {. @& N; ~" Xcrc16tem=crc16(CommBuf,CommIndex); // then send low 8 bit data, M7 D7 G9 ?" R4 d: J4 p# t
7 {5 B0 T  D8 k4 W
CommBuf[CommIndex++]=(uchar)(crc16tem & 0x00ff); // send crccheck low 8 bit is front
- x" Z9 M% r' X# Z
& z2 K2 z: b2 E1 N4 aCommBuf[CommIndex]=(uchar)(crc16tem>>8); // then send hight 8 bit
% X: s0 ~1 m( X9 r6 Q
1 Q6 q0 ^9 B: l0 G4 fCommIndexEnd=CommIndex;. ^- g4 N  z, x/ m

2 P; R3 r. D. a# c. p# j2 dCommIndex=0;
( G. _; [3 N- W& s
% G+ w! V8 G" ]: c" CSBUF=CommBuf[CommIndex++];  P1 a; d8 V6 f  i( I$ Z
* w7 p) q8 C# H8 ^- G9 ~* p9 L( P. q- u
break;
+ Q5 I8 I' A6 {$ H8 N0 C
( |0 k' g4 _! i$ {* j0 F& i9 Ocase ReadHoldReg:
7 l+ x/ i- _8 c/ R( s- b6 p
2 G) K' R. Q9 F+ Y  A( h, MCommBuf[CommIndexSlaveID]=SlaveID; // 0
2 }* C! B* i5 w! \
" ^+ C2 {: o+ sCommBuf[CommIndexFunction]=ReadHoldReg; // 1
& T1 n  N, Y$ R' Y; a1 F4 _( j: Z6 |: I; I
CommBuf[2]=CommBuf[CommIndexNoPointLo]*2; // 2 Byte Count
! l& e) P& K" v) \9 Z9 W
: p1 S3 d/ A  Qfor (i=0;i<MaxRegLen;i++) // sim inputval for test
$ ^$ ?$ R: F2 [2 w2 g6 r4 M  o( x; k3 q7 F  U
SlaveOutputBuf=SlaveAdr;3 X+ w! P8 J7 P7 J* C

' V3 q% D0 z' L- Ei=CommBuf[2]+3;
% ~( |8 p& @! p7 u4 D% R  s$ ~
" |* {3 W2 x" E9 A6 M" Xfor(CommIndex=3;CommIndex<i;CommIndex++) // send data Reg to Master
# M2 S) s5 c3 f' \/ a/ p( `4 x5 o" F8 j1 b0 m
CommBuf[CommIndex]=SlaveOutputBuf[CommIndex-3]; // hight 8 bit is first send' ?/ x  Y" `. C( z# j
& [0 a8 v, m6 k* u
crc16tem=crc16(CommBuf,CommIndex); // then send low 8 bit data) V! N9 g( k$ f. T; j' H8 h

0 @  [6 m* k9 }! Y( ~9 p4 f! cCommBuf[CommIndex++]=(uchar)(crc16tem & 0x00ff); // send crccheck low 8 bit is front8 W( H* M7 l3 L, X7 U
9 A* T3 b1 L5 d3 Z# s6 x
CommBuf[CommIndex]=(uchar)(crc16tem>>8); // then send hight 8 bit3 W- s" {$ m5 W  W9 r8 U, [+ n

2 N- s; w' |# K6 g5 J& L6 ~- V9 @CommIndexEnd=CommIndex;) C1 r, q5 f& u6 q8 O4 ?3 v
* t% A% I) A0 Y( H# g
CommIndex=0;" V8 r1 [' e6 X* t

* l) N' [  q; E8 m+ a: A$ oSBUF=CommBuf[CommIndex++];
* s6 E: j" ^, J9 q, h( z. B2 b
  r$ F) A1 ?; q: Xbreak;
* p6 S* X$ o* ~5 s; a6 C& @) C6 h" n6 C4 z( w: f1 L* r
case PresetMulReg:# |3 z2 Z' ]9 E! T; C3 M! E  p

9 \3 g) Y" J4 I/ D7 W9 uj=CommBuf[CommIndexNoPointLo]*2;- M( i8 f: }8 n: ]: w

8 F9 T# ~4 E" R* wfor (i=0;i<j;i++)
0 s- r. G# ~" C  X1 i- n, n" d- s# d3 x
SlaveOutputBuf[0]=CommBuf[i+7]; // get data that master send start 7th byte9 \* Y" f% ]( W; i0 f+ l
6 U' l; R; C1 X# _
C2 R' w9 r2 m% d( p
* ]1 @* K" o" q4 J; J9 B
ommBuf[CommIndexSlaveID]=SlaveID; // 0$ \; f- L1 u6 K8 h5 b5 ?7 r

( Z( D3 r) W( _# QCommBuf[CommIndexFunction]=PresetMulReg; // 10 `' J6 Z- C- Z* ?2 x. g& Y

$ B' I3 h3 p3 i. {* mCommIndex=2;, x9 V2 y- Z$ |- `, M1 g

* Z2 s# G$ e' V! O5 _CommBuf[CommIndex++]=CommBuf[CommIndexStartAdrHi]; // 2! X5 ~  k* X0 x2 L/ d
$ K* u, y( L' z8 a
CommBuf[CommIndex++]=CommBuf[CommIndexStartAdrLo]; // 3% J7 ]0 D: Q6 C

8 i& C3 l: Y8 K$ z6 _4 m$ y  `CommBuf[CommIndex++]=CommBuf[CommIndexNoPointHi]; // 4; D. Y0 h9 W7 w  V$ z% P

5 x, e3 r* D. H( C2 }9 F! F: xCommBuf[CommIndex++]=CommBuf[CommIndexNoPointLo]; // 54 d( X* o( B2 P) ?
8 j, G8 y" `* L3 G3 F4 |
crc16tem=crc16(CommBuf,CommIndex); // then send low 8 bit data
: n, F( h) @  X2 f5 M
+ t; R/ ~# l% g( R2 Y( {CommBuf[CommIndex++]=(uchar)(crc16tem & 0x00ff); // send crccheck low 8 bit is front
* E' {: v* {8 @& K8 \. ]
0 N; Y; P1 ]5 h+ W; n# G1 X6 aCommBuf[CommIndex]=(uchar)(crc16tem>>8); // then send hight 8 bit# E& w  I: K$ [6 p  f5 ~
  j7 I7 \% {2 x) s
CommIndexEnd=CommIndex;/ j9 o1 w% O% g5 O7 ]7 J

7 F* ]9 x" W2 XCommIndex=0;
& V2 t  D$ W* H1 q% o$ c
: F6 @5 l) |7 `! }3 |SBUF=CommBuf[CommIndex++];
) d1 h7 J' U% `' F, h1 h0 S3 W# o+ e) \8 o9 `% w. A
break;% [% g' h# W& A2 d& o
5 K: [2 T1 a  K- h# e6 p9 K2 U
default:
) Q3 c# A: I8 e# c1 y& t5 X
- }6 n3 R4 ~0 ^4 l5 Jfor (i=0;i<=80;i++) // delay // error recieve again
' f) q$ |2 a7 f$ O- ^
/ u9 [5 f' R# `" P! f& f# I& |_nop_();- G. ~2 ^, |1 t" K
4 y% S/ T0 ~  }
CommIndex=0;
) x- i( g- J7 y0 X# b" ~3 ]: m/ D( ?  i
T0=RECIEVE;$ k- ?2 I8 L# C. \5 H  S9 h0 d

! j6 R" {. [/ y) r0 t* ebreak;5 ^3 H5 F# e9 [& {, h+ v! w
4 H# g8 e& x( Z4 Y7 P
}' j" l7 ^1 a- r1 {& j4 @

9 Z' ?; ]" T7 T* J}
- t  Y2 x& N$ N
# @! c; [1 `8 l6 Ielse1 }( E8 O$ Z: F4 R& M: y( E& x
+ n+ [0 g& _' R5 D) y
{1 l: A5 g5 A, b, ^
* X5 U' G# S, u, d7 Y4 m: S$ c3 s
for (i=0;i<=80;i++) // delay
! k# `7 O) v; N- o4 G' U2 S3 n! o3 |% [1 x- M
_nop_();
1 O! ~4 i, P" g$ I/ h2 j. o1 M! r
. u4 U% N0 Q" c# [CommIndex=0;
7 P& U8 G% ~8 I+ g+ @& ~7 ~* c3 H* k- s: b: B4 U3 _; |% e
T0=RECIEVE;
/ B4 E! y1 S! }: {" L3 I! V
: k" J4 V  f+ U- L7 v% x}
" E- [! ?% B9 L3 \0 {: T; h9 e2 U# |1 }5 S5 K6 H/ i8 p3 O
}4 Q7 i2 n" \( i( h# C9 N
- x5 ^7 a9 {# }' v$ n8 U
}
' g* k7 o: B5 ?7 Z5 y0 Z5 R0 E" W( z% m4 l( g" m. ^+ v/ Q$ U& F
/*------------- intr code is following ----------------*/1 \- u1 ^! r6 C& I
% q7 ?: G, b7 c1 a3 s; ~. g
void slavecomm(void) interrupt 4 using 2& ^+ J5 c( D6 O  [
) p3 l! u8 P7 _% h7 E
{) `5 S  `% b* C2 b/ @" c% b  E/ }

1 T. {+ j- T* h: b- E3 huint i;
4 |4 p; B$ z" I' z$ G' p: u" {" U: z# y' n8 D
ES=0;1 ~; l+ ]0 H- j- Z9 r# e
1 N5 K/ ~& F: h
if(TI)
; s* B; ?' o% h/ m* b/ |4 S
; r) M; U. _& ~2 h{
) H. `% k4 }- e: R5 [# p6 S# z" w0 Z/ R6 }" O0 S0 @' t
TI=0;
! _( v  f' w9 W6 `6 l( s, c( {$ g2 v" V; @& m3 z
if (CommIndex<=CommIndexEnd)$ d4 \5 ~! R# M8 p! k! ^
3 \5 r9 X9 g$ D2 [
{( P9 h7 o; W) m' P
8 _3 g, N0 w6 {% R7 J; t% U
SBUF=CommBuf[CommIndex++];
; @( Q1 A& l- a. H0 {) q% u: f: e4 @5 g: a
}
! Y5 I$ N/ j" ~0 i7 b
4 v/ s9 ?2 M3 \6 J" c, `0 Relse1 Y5 C1 k) m$ q* {5 `; V5 H5 ?
8 z5 g! g& M) B% w3 o4 j, u0 a. ]
{( E9 d2 P/ j8 |7 H0 C7 t. A

1 V1 i& |/ o6 D% k: j; v// if (forcesendF)6 a; Y2 Z* {5 _& e

" N9 [" I3 J; G) Q: d& |; p2 {// _nop_();
2 r) X- E* V4 u7 S
5 @, I7 r; q+ h( W: R9 A$ }for (i=0;i<=SendRecieveDelay;i++) // delay
8 \6 U" r- t9 ~1 p
3 |7 R0 M5 c6 `9 i" S) u_nop_();! f$ V- K, ?( s4 c+ X  A: Y5 b

' c- z2 M" Y& i! @8 TCommIndex=0;
' ]& {# @0 t( a& @; \; o! E- n
3 G& K5 w* z6 n' V+ @; K0 PT0=RECIEVE;
5 y% T, m* N: m1 {: C% Z/ a2 e* D
}6 u4 K# {4 S$ t" I# b

1 t! T( F9 d3 c/ Y}
) T7 G% a% }! I5 i8 [: }* t+ l' T* k7 i/ C2 k" B1 d$ R* X
if(RI)
3 O  W5 K7 z0 u  V  G+ N/ p9 q- ], N8 q, ]1 S  U% V5 \
{6 A) ^0 `# T  p0 f9 u

9 F' D- T6 r( h% A& j* g- ZRI=0;* f( f2 T( G8 v+ w
! c% \6 I/ t6 c$ E. R! |( K
if (CommIndex<CommIndexEnd) // CommIndex less than recieve lenght- a2 s7 \& G% F! R( y& H, ~0 U

% X" D  ~( w% h% q8 B) ]9 ~1 \7 W' V{
- W3 \% h# ~$ b# o& q  g
( Z% T9 m. ?5 ACommBuf[CommIndex]=SBUF;
3 o; J. [4 Y' d/ r# e: f( @& }  J) F4 P. t$ h. Z$ O5 I
if (CommIndex==CommIndexFunction)
! R3 Z5 f/ M0 r1 ]. _! B
9 g+ ]9 S+ c& f* F{
3 _, T8 |: j7 c. @  x1 H1 y$ p& x6 m% c% T
switch (CommBuf[CommIndexFunction])
5 f- \6 Z/ \6 t- k6 v1 `. A2 w& l. @4 u+ N3 U* G: [
{) }% s& B. Z; Q
% C( k/ ^+ K( `+ w9 b
case ReadCoilSta:) u/ r7 ?) r- V- W+ b
" [; U0 _3 g! V" H8 I4 W# j2 [9 w
CommIndexEnd=ReadCoilStaIndexEnd;
: X8 O- B7 r. W2 C) n: U. E: I4 R
break;: W# j8 T& R6 g
9 ?; k* X/ W; n& G+ a- g
case ForceSingleCoil:
2 @  g" _: s1 l9 n/ q; y
  X! }3 ]' J  m0 ~1 xCommIndexEnd=ForceSingleCoilIndexEnd;
/ r9 |/ O0 A" y( y2 u- d0 i1 ^8 R% a5 s+ z" B; R
break;
/ \! ^' d% f2 e3 J- f8 X% t7 {' Y  t; d* n
case ReadHoldReg:
2 U3 |6 ]( l: W. {% g3 u! n: {+ H) b5 _
CommIndexEnd=ReadHoldRegIndexEnd;4 C( w* j" o1 Y4 m

7 D1 R0 D4 f: w7 J; {break;
, \% C/ Q2 ]* K+ m7 m) ]
4 m5 d8 ]: k( s/ m6 U% ]9 Zcase PresetMulReg:
9 p8 I0 ]' K5 n6 C
+ f) k7 @4 A8 Q: g( T* eCommIndexEnd=6+CommBuf[CommIndexNoPointLo]*2+2;+ x, {# E6 l2 C7 u- k5 B, R

: x" x' O1 }1 U* e# d+ Fbreak;
: K3 Y8 L# C, h# W) I4 B) p3 E8 Y
4 Q7 j7 `: j5 f+ vdefault:
) G) X5 k! l+ O, F8 L. V" d9 V! J" u5 G$ q! y$ L
break;* w) r3 L' c2 s
0 W3 F' V' _1 R7 D6 O1 ~$ |) H* r
}
; \2 _- ^" ^9 h+ [* i5 j; E6 r: W" L* E- c! L
}$ q5 I) I% F2 n6 }8 C: y
( S# l( {/ }2 r4 `* b
CommIndex++;
  _9 G: Y# l  E) y7 R$ B: s# n- ?+ z2 e" {1 }
}+ j4 V; d- d. q" O7 S8 C' R

3 p. G- q" Q$ V) D+ Jelse // recieve finished CommIndex==CommIndexEnd( Y% a  g# _! a3 P* K+ S

" C; K9 {1 z+ p) `4 d2 n{7 ?. [( J. |6 m! H8 Q/ `! v+ S

% S0 W4 _9 s3 v6 m! dCommBuf[CommIndexEnd]=SBUF;
* p4 ^/ G, S: J* V( ?& q
' O- U. |+ ?: A  u6 H& PRecFinishF=1;
* ]7 ?& \; i! R0 c% q- S# F% t
- e0 b0 G4 b/ v7 D4 zfor (i=0;i<=Sen6 i) C6 F( @$ \- n: `

  H/ V8 [$ Q: ]+ B/ z+ ^" B1 ^& ?dRecieveDelay;i++) // delay
4 g3 p; q* \8 K$ a
) q9 ^; \& M7 ?_nop_();
6 i$ [, \& C1 p- Y- a1 `. b/ W! v7 d7 n3 z
T0=SEND;. d% L( r; \9 z; ^+ j% s9 K2 u
. t# U6 z; n- z# C
}* F, W5 L$ @% h, _2 i2 a, s+ P$ d" P$ k

( @1 T: s( e' n' Y}" O. o: {6 q& }& t; ~7 R
- u4 J; c$ k; T1 K, ~
ES=1;
0 X- C9 a0 t8 H3 C" M) F# o! Y  E' {, q- r* D  _% _
}
1 h, R, }8 g) F! T2 z$ R& n5 H3 i1 U
/*------------------ main code following -----------------*/( C4 L& U+ |1 B  q

7 E7 `( m- s3 s8 n2 N7 _! Y2 B! ]7 v( zvoid main(void)
: t! i# O+ b, P
% f  }0 \/ \7 Y5 H: X5 f3 T1 }" y4 o{/ Y8 D/ _1 H1 K$ |( u2 A( A
1 i* ^- N' Y4 U. S, P
uint data i;" _6 A' g$ w9 b9 A; H+ d

( H" \) `3 C* c5 O( l2 Winit();, V+ \# }; P9 C

  X- l5 e" v# P+ i7 qwhile(1)" N  I5 n0 ?) D0 h) z* }& m% l
9 R- p. l& E: h/ `3 o. ]0 i
{
& M2 E# E8 \" v% z0 R8 i2 o
% J0 X% R" X3 g/ |// LED0=!LED0;
0 c& g3 V. M0 ^+ d9 \
! h% A* Q% w  G4 h' N7 Ifor(i=0;i<=9;i++)- b) G5 ]  R+ C- v  N( O
- W% c1 G1 E1 c5 T3 g- I6 E$ s
_nop_();/ c/ k$ Y6 O) [: a; [9 g
* e: y% n9 S5 |: }$ |
if (RecFinishF)
  b2 f# e8 ?3 D& z7 J1 r% d$ \5 Y& F: A! S" v3 t
{
4 H% l0 R5 P4 _2 }2 x5 ]" [" h4 J5 W$ O% m
AnalyzeRecieve();1 M1 @% q# S( ~$ J* f6 k' H, |

: X4 }' e0 O5 E! cRecFinishF=0;
: @+ B# D/ ~# E3 F# t1 i( L! X' P+ ~6 g0 o4 A5 s
}
/ W! g+ j- w5 C4 }
4 a+ c) X% |  Q7 H. l. ^, k}
7 m5 U$ [/ x& `0 @8 A
$ x! X5 l! E( W. F& I}

cat12620 · 发表于 2019-1-21 11:31

谢谢分享

13516385570 · 发表于 2022-4-1 17:07

不错

帐号		自动登录	找回密码
密码			注册

c51单片机MODBUS参考程序

EDA365欢迎您登录！

浏览过的版块

推荐内容 /1