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;
' q$ {1 M; F: ^! r3 C4 G* s. C- i* y( h- i% z# o6 i
}& Y% }# F/ [+ O% U

/ G. V9 J/ r6 j: f, C6 C- x7 H; Gvoid init(void); o% w) H, Q8 Q" ]7 ~6 }

* d- D+ b* u' F/ b% \{/ b/ v- S2 b4 _: e

( ?) h7 u, }* }initSFR();' S( C: O+ y* n9 U( O
* S5 D2 p* T- W+ `0 {7 E
initvar();4 j2 [2 Y& U9 }. o' ]: r
: L- S4 I. ^( c) z$ m  {2 }
}% N3 L5 B% G, c. V
; z9 A- r- B0 {* P( w9 e) f
void AnalyzeRecieve(void)
( ?! g% F% s: }: S4 z
, I: I/ M' i! X, p3 c{
/ G; b( h5 }& U$ v$ h/ ^5 R( j4 W9 k: ]
uint crc16tem;
8 D+ P5 l& u! a# D
, K, t( D1 `, e8 G" Suchar i,j;! A1 @* f3 ~; D1 N% C

) x8 o0 }: J+ [! \. |. h# Cif (CommBuf[CommIndexSlaveID]==SlaveID) // The slave ID is matched
: L9 p1 {0 E; ]+ X9 U
$ I: a9 V0 ]: g; `) }  q5 R{& @2 Y4 |% W/ U4 V

* c$ k. u1 W+ f  p5 l* u2 ?& ocrc16tem=crc16(CommBuf,CommIndex-1); // calculate CRC check, erase two CRC byte- S2 v  D" S+ G1 F0 {) _( O
% a4 ^! T" J6 {$ E; G. Y7 u
if (crc16tem==(((uint)(CommBuf[CommIndexEnd]) << 8) | CommBuf[CommIndexEnd-1]))
7 R! \/ U1 ]$ R0 M' F0 o; f# y4 b& V* u2 g; G) c1 T
{ // crc16 check is OK4 q0 Y9 G6 ]: y; r2 Y+ l
! Z) {" L+ C' I, Q
switch (CommBuf[CommIndexFunction])8 P& {, [7 ^' a' u4 `
/ H3 u! F$ W" k5 g. J
{0 [- s2 W/ l% D: ?; W
7 L8 I% d' ?$ n; a0 T* D
case ReadCoilSta:+ O% \+ Q, Z: A" X
! t( \3 u- l! J, ^3 C$ T
CommBuf[CommIndexSlaveID]=SlaveID; // 0
( ^% s' a. |6 A& Y# g4 K, L% C7 `/ L5 H4 I2 j
CommBuf[CommIndexFunction]=ReadCoilSta; // 1! b- Q& i1 x& ?
: p, }$ U, c* |( K
CommBuf[2]=CommBuf[CommIndexNoPointLo] / 0x08; // 0x16 bit% o0 G: p6 T' H# [( n

  o( o+ E) B4 ?4 o1 W4 Q: y! Vfor (i=0;i<MaxRegLen;i++) // sim inputval for test
4 }* ]9 u' I7 C: R# w9 e! e  }" i& K& B+ @& Z- c+ |
SlaveOutputBuf=forceval; // send data of master force coil val
( o( {2 B2 f0 g1 z
% C# n' y/ Q' Y/ yi=CommBuf[2]+3;
/ k- T& Z7 f' x, l9 h3 j6 ], l0 [: b
. D/ D4 j# O7 r/ L) m* g3 Qfor(CommIndex=3;CommIndex<i;CommIndex++) // send data Reg to Master
* V% |4 C* c" I' o, S/ D
1 ?: E8 Y. O$ o7 D% z( d3 T3 OCommBuf[CommIndex]=SlaveOutputBuf[CommIndex-3]; // hight 8 bit is first send1 [6 K3 |" s8 y5 [7 b2 ]/ l" j- _4 E

1 }0 C6 ~' E+ d, n4 ^" P7 ocrc16tem=crc16(CommBuf,CommIndex); // then send low 8 bit data" T0 K8 Y" `4 T) o, C' G
" f9 ^: n! Y3 D9 d( ]7 w
CommBuf[CommIndex++]=(uchar)(crc16tem & 0x00ff); // send crccheck low 8 bit is front
$ L2 D( e& A, g2 f0 i& E* P- c% r  Y  E# o& h8 P9 y$ X) D/ M1 N
CommBuf[CommIndex]=(uchar)(crc16tem>>8); // then send hight 8 bit4 p, r3 R* |! _$ }7 x

, y# t0 V. w, B  H1 E: q# R' d. u5 oCommIndexEnd=CommIndex;
5 ?; z* {9 B& k, O/ |' @: c2 F+ R  K+ M  X
CommIndex=0;, M) A7 a; J4 v) j6 G  u% I

* |% }4 Y6 }5 SSBUF=CommBuf[CommIndex++];
3 s: z0 R! B& O; |. |  ?1 O$ N& |3 M, r
break;
  [; P; S/ a9 k1 T2 J' [: F2 `' z9 |- M$ Y6 y( }# O
case ForceSingleCoil:
' W4 E2 d* l+ H- n; P! r, L5 [$ r+ ~9 T
// SlaveInputBuf[0]=CommBuf[4]; // get data 0x00 or 0xff
4 J6 F; @; T$ U0 a9 w
( C6 u/ P$ g+ @" a8 }if (CommBuf[4]==0xff)0 ]6 D- r. `( b) J# @# S- Z, C, D
  y7 i: f: Z  z  v
LED0=0;6 a  a2 Y5 g7 b" ]. ?$ k

- S+ k5 j  h0 ]: B$ E& Yelse
! {# z& I4 \2 ^
" G) T+ p, p  SLED0=1;
/ i% Z5 O8 R1 A- w' c: `
9 b( ?( t- p; D+ ~7 `// LED0=!LED0;
; x7 [; }+ {; }7 @5 S& }: ~$ l: s4 @$ G9 |6 Y( X
ForceCoilBuf[count]=CommBuf[4];
8 I/ ?( A" h1 r* q8 N  y! s$ I. Y# q# A) a. U
forceval=CommBuf[4];
2 ?( b4 O8 z3 R0 k$ y( u( J/ N9 T# w9 ?' G4 {1 _: S
count++;
' L9 k) @# @6 g
7 O) J& `: Z% \5 I: p+ uCommBuf[CommIndexSlaveID]=SlaveID; // 0- U2 P$ R$ Z  P" J, Y" L. g' {
7 R9 d9 L; ]* W2 Q
CommBuf[CommIndexFunction]=ForceSingleCoil; // 12 J: q2 |' K0 Q: Y4 F9 @. l
8 v# G0 }* @% j, H
CommIndex=2;
+ s4 D! T# Z' ^) y, Z7 W! [: g8 h7 D' B1 J" |& v! m
// CommBuf[CommIndex++]=0x00;
. l! }8 o% ?2 l( d5 k% c" ?' v3 z" @  `# A# X4 K) R
// CommBuf[CommIndex++]=0x01;+ Z+ D- X7 P8 F  U( l
6 g% s7 l* f* [/ a: [: O
// CommBuf[CommIndex++]=0x00;. S9 ~! O) O3 I$ T/ E& T

& B" ~6 k# [+ j  n, I5 {: S// CommBuf[CommIndex++]=0xff;
  N% z8 _0 C. v2 _8 M% x. f
& n+ H. q% \" O  I// forcesendF=1;5 h+ w# t8 X2 h8 w) x9 N
  i3 Z! r1 i+ [. E  I' c
CommBuf[CommIndex++]=CommBuf[CommIndexStartAdrHi]; // 28 Q& k% ]* P: k3 ^

6 m3 e0 u9 T# J( t7 W+ S) ]CommBuf[CommIndex++]=CommBuf[CommIndexStartAdrLo]; // 3
) d9 r* |, L3 \3 n7 {0 K1 d
( C# b/ z8 Z2 Q* B) @" HCommBuf[CommIndex++]=CommBuf[CommIndexNoPointHi]; // 4, x. l8 c7 A- M

; `2 E- w6 g4 Q7 ECommBuf[CommIndex++]=CommBuf[CommIndexNoPointLo]; // 5: b5 _3 @. v4 {/ d, E

; }4 T5 J. x  h# c! Z+ Q' Xcrc16tem=crc16(CommBuf,CommIndex); // then send low 8 bit data" L$ E, W9 p$ e5 H: v" W+ U  r

6 B+ f. _# @7 t# F! DCommBuf[CommIndex++]=(uchar)(crc16tem & 0x00ff); // send crccheck low 8 bit is front+ q* _7 y1 D6 v: G- y$ b! K2 F
$ V6 ~. g; g1 y/ U& V8 ~
CommBuf[CommIndex]=(uchar)(crc16tem>>8); // then send hight 8 bit
- \4 B4 \' h# n- g4 {* R$ [0 p4 X9 S
CommIndexEnd=CommIndex;4 Y8 P' s6 D* ~  N

! W2 u/ o) P: g. [$ s. M* KCommIndex=0;
2 {9 K% }) @4 e# Q5 t1 G* E8 L3 y; [0 g6 s, L
SBUF=CommBuf[CommIndex++];1 J- k3 Y( |8 J: @* N

2 V- l& T: [2 F: ]7 C" lbreak;  B' o" F9 I$ Z
+ p* h: f. s& s7 H0 `3 p
case ReadHoldReg:
+ Q7 X/ g6 g' A' m5 a2 H; G( U, Q  j% _3 z
CommBuf[CommIndexSlaveID]=SlaveID; // 0
2 B. k* e5 f; h  w4 Y6 Y+ U' l" l: N% v, c
CommBuf[CommIndexFunction]=ReadHoldReg; // 1+ H/ t+ s% W* x- I8 d
, O) f9 @3 T6 N* ]/ g% S" O
CommBuf[2]=CommBuf[CommIndexNoPointLo]*2; // 2 Byte Count
" d, w) t0 ?2 P- M' N5 Q( S$ {& Y" N- K
for (i=0;i<MaxRegLen;i++) // sim inputval for test
( x* A! d$ G, [% d% L! \
" D" w! g2 X3 z5 z  o- ~& J0 FSlaveOutputBuf=SlaveAdr;
' J5 C# X3 J; j% Y+ K9 k, Z( H- \) b
i=CommBuf[2]+3;/ K( S- S, D. f0 v
7 b% A( ]% g$ G( n
for(CommIndex=3;CommIndex<i;CommIndex++) // send data Reg to Master3 [2 \4 g5 G7 v. I7 v
  z: E" }3 a% I
CommBuf[CommIndex]=SlaveOutputBuf[CommIndex-3]; // hight 8 bit is first send) k: N. P( D2 k$ q

& ]+ |% ^; }% s1 ]& j5 xcrc16tem=crc16(CommBuf,CommIndex); // then send low 8 bit data+ ^, Q; o. V" t7 K3 O; i9 F

4 U1 h+ }/ ]' wCommBuf[CommIndex++]=(uchar)(crc16tem & 0x00ff); // send crccheck low 8 bit is front; Z: ]5 K" V$ {/ C8 h5 E/ x/ u
: f. ]3 W$ B  G# t* J2 }
CommBuf[CommIndex]=(uchar)(crc16tem>>8); // then send hight 8 bit, l: E6 q. H* K

" ]/ D) _1 a  C6 L: N$ TCommIndexEnd=CommIndex;6 m+ f# {6 e) h) d7 w( ], a7 W
; T5 `! j* n" W# ~( G; _, U. _
CommIndex=0;
9 G, Z/ S$ [3 _8 D
. N9 l3 A* y2 Z2 ~; v5 GSBUF=CommBuf[CommIndex++];
9 ^5 {4 n+ ~! l$ K) C  A0 V2 a0 O- O! K9 i
break;
2 _1 i/ W/ w) U4 K
/ b- }1 B. L, u# |case PresetMulReg:
6 P) V% R# C* w/ c0 C6 x
9 x: W7 u! ^) fj=CommBuf[CommIndexNoPointLo]*2;5 U& U$ w8 d1 `0 G

1 @" l5 N& V' g9 pfor (i=0;i<j;i++)
% ?% J' e5 l8 Q5 K* x
+ o& I* ~, s/ Y1 s0 KSlaveOutputBuf[0]=CommBuf[i+7]; // get data that master send start 7th byte
, u, @/ n( e) R3 J/ z5 |0 ?. H  T3 L2 M( l8 t2 j! I* Y
C' ?  B$ P5 j. j1 [7 h3 p6 K* F

" O$ ]' n' _5 ^5 M2 J. P4 AommBuf[CommIndexSlaveID]=SlaveID; // 0
1 T: l+ n/ r7 e- C
3 [, `  A+ D& Z) T. ^1 _# }CommBuf[CommIndexFunction]=PresetMulReg; // 1+ [* `. X1 D: d1 i* k/ _
, {* B7 g, ^1 x$ ]$ m" @% y$ W+ r0 c
CommIndex=2;. g' \) o: d$ o$ F' L; H& q' T( }' K2 g
' H/ Q6 M" z1 d4 p* K8 j7 `' ]
CommBuf[CommIndex++]=CommBuf[CommIndexStartAdrHi]; // 2
5 Z8 _3 u4 y* K. p" j! w0 G! B/ @
CommBuf[CommIndex++]=CommBuf[CommIndexStartAdrLo]; // 3
3 b  @: n$ J: @0 U0 D0 B
8 l, @1 q2 z! oCommBuf[CommIndex++]=CommBuf[CommIndexNoPointHi]; // 4
5 V7 ], [) v1 F3 Q* l+ Q2 T  t3 f' W! o8 p% [
CommBuf[CommIndex++]=CommBuf[CommIndexNoPointLo]; // 5- v+ X+ f! G4 T( p2 P3 i# u
" J- r" C# W& w8 b5 X
crc16tem=crc16(CommBuf,CommIndex); // then send low 8 bit data( |/ {% M% T6 U/ N" q. b
: |- p9 G# K. e4 U; P
CommBuf[CommIndex++]=(uchar)(crc16tem & 0x00ff); // send crccheck low 8 bit is front
/ V3 x; @  j' l* r0 D! ~# w# ~0 x- }7 H2 r
CommBuf[CommIndex]=(uchar)(crc16tem>>8); // then send hight 8 bit
1 Q6 _: S- R- e) R+ X9 ^
% |$ g2 G" {0 f: nCommIndexEnd=CommIndex;% s0 q; c$ u( n2 k# f4 N

  |5 m; X: _- {' R: |2 zCommIndex=0;
5 h) x2 S6 p2 L4 H
* z- }  a1 B5 m2 W! i4 K1 PSBUF=CommBuf[CommIndex++];
; ?. Z! m0 s4 ?. P3 v; Z* g+ A2 d: M0 ~4 l" S2 X4 G9 r+ E
break;
9 f3 Y$ ]" N0 _1 u) N
; N+ |6 G2 y  w0 F& O" o5 j+ sdefault:
2 F; C+ ^" s! ~
3 b1 X2 R( J/ U$ k# Dfor (i=0;i<=80;i++) // delay // error recieve again
- [+ z. ^( T7 r+ ^6 a" \1 n6 M
9 g0 N0 L6 _# l; A% ^_nop_();1 ^' v6 I1 Q" D/ {
6 m$ H6 _% g/ B6 h5 p
CommIndex=0;5 ^  D4 `. F; P+ V
- `+ G! g: B. W3 W& E% s
T0=RECIEVE;
9 e, ]4 s0 I! Y8 i
  Y* U8 h6 d5 S; B& W* }, j( abreak;
$ M: [8 J3 K3 W' _* c
5 T9 t( U/ O8 p- y* Q  ^0 {}2 s9 k4 q) p$ Q7 h9 A( u  _" _

6 b$ Y# I! l- l7 i3 D3 }}; u3 I7 i: K3 a% ~- H

2 b' b7 }8 @. F0 ^3 ~8 @- J; {" p5 uelse0 h4 b' L# ]# Z7 O+ c- Q" ~

8 M5 E4 T; J* I% x3 ^9 S{
8 g4 @; g4 y, Y; m3 @9 M
' I4 P5 R1 e- ?' S' U8 Ofor (i=0;i<=80;i++) // delay
# y0 O4 m$ C0 q5 E  ^3 ~8 X$ k" C3 M
_nop_();
) V: _9 r0 _/ K% p9 r
) z$ q- D* V; D. X& [CommIndex=0;! M# P0 k  G8 I/ _- L$ P2 ~

" |4 s4 o& k* [1 HT0=RECIEVE;' L+ b2 Z& K; n0 w9 D: h2 e2 e

- C1 {, d3 e) h- r}7 o+ }/ g2 S. A/ k' ]! e0 u2 \
. [  [& O4 v- f4 R9 }" c. \
}' ?+ n5 ~, s3 b' L: ~6 b1 l  V

/ v: b1 J& O6 o3 Z/ [' m}1 {# X* r: r1 U, q
3 C$ T& b3 ^* }9 {) ]2 n# `, y0 ?( l! g+ W
/*------------- intr code is following ----------------*/
9 p) E, Z( J' g9 ~( S; U/ r
7 a8 @- L$ s6 j$ T3 s; Mvoid slavecomm(void) interrupt 4 using 2/ m. ?: J# h& Y+ G
1 X! p& {7 u  ~
{; e( N+ f' K9 }0 K
3 ~8 o7 H+ o5 H8 z- {
uint i;
0 m* F& p3 P  [1 o0 ^6 `5 O) `7 g0 p- p: Z1 N8 V7 N
ES=0;: x  o' f* I% |: p

. e4 z' g2 X0 [: J2 S: Iif(TI)' [# |& w/ h1 e$ l4 }1 V
" _1 F- E9 Q; C
{' u3 ~  a0 i3 V
8 R% ^% C% P& u% o- O
TI=0;& c$ R6 Z, o1 e# I' y

6 z; x' Y: v7 ^+ zif (CommIndex<=CommIndexEnd)# ]8 K/ H2 }8 a

# z) \* c  y/ R0 Z; ?9 B& `{
0 Z5 F; x* G5 l% C& p; r% t+ n& `% f& n& w; }
SBUF=CommBuf[CommIndex++];
  |9 {; d0 k4 p" Z" p8 x& Y
5 [+ k! i0 a  H}
: Y4 X; w$ U$ R! C0 Q# T
9 I, r! D, S7 Z% ~else6 z; G7 l+ l. w3 ?) f( y

* O2 b8 r0 e! I{
2 Z6 R2 z9 k- p: C6 e
// if (forcesendF)! t0 d2 \) f- i0 {3 q) }
( r  R, C/ e  j6 j! V5 Y% ?, p
// _nop_();2 U- Y& h. K. h' ~9 O. ]5 E- c
- @: |) J" e! o4 f: ^
for (i=0;i<=SendRecieveDelay;i++) // delay
! ~- v" N* o, d/ u3 ]; g0 R9 L. u2 [0 y
_nop_();/ g; I+ O( e2 l% O9 p

7 D3 H- S( H2 t! M: g( [! `) ECommIndex=0;
$ w) I1 x  b) _9 i0 j
. ?: u" a' J- V# J5 I6 x- uT0=RECIEVE;
  P8 Z- y6 e  f$ {, t
- X/ e. ]  t* O}+ p% `$ A1 d/ f% o. }# _

4 }1 A, Y$ \! L& E}
" [3 ^( r2 N: H7 x" v' `  b/ I8 d; J# f- w' Q# T
if(RI)
* q& c& _5 r- I" X3 ~  |: u* C
6 r& q% W2 L$ ^/ `0 I3 |+ P, ?{
' ^! m+ I. O* ^+ M& _+ X, Z
  |4 }) N9 D! d7 z: f  c5 {7 \RI=0;( s) K& y1 F% U

5 A, k! q, w# w" R! @3 C! \4 Gif (CommIndex<CommIndexEnd) // CommIndex less than recieve lenght; N( X& x8 v( q- A: r* z5 w1 h$ F) c

7 b) P8 u8 S* e$ _8 d0 y; V{
% s. W4 n; _" `7 I) i
7 R- e6 V  d; X- n9 M+ g+ J( cCommBuf[CommIndex]=SBUF;
7 _/ G9 W  t/ B6 Z; O+ h
; H& r$ m) j+ E( V/ Fif (CommIndex==CommIndexFunction); W8 [5 Y, k3 g) ?

( t$ X" K. }! ~8 I" g' A' r{: b1 e( D' R/ `( r( _; f: k1 x7 a
" {4 u) w: U- c/ @! e  g9 i% y
switch (CommBuf[CommIndexFunction])
1 |7 ?1 r& ~1 V! @  E* P& `" [( {' q0 o: }( T5 I! s
{
4 Q; [" z' B% p# W0 b6 V3 z
( N/ Z) G8 M7 w( rcase ReadCoilSta:1 W4 `( U/ y1 q1 m/ Y' O

  G& t- W! z$ `; G* P3 [; ~CommIndexEnd=ReadCoilStaIndexEnd;
  E& M, {6 L3 K* v: \/ M/ Q  F( @
+ u& j: ]; I7 G+ A5 Xbreak;/ ]" R& m7 ~$ F! b
8 T8 X  q% t: q# H4 u8 e% R- G0 }
case ForceSingleCoil:8 ?+ }$ q; p9 V" i0 \; m" {
9 D1 n+ e$ s  R6 `1 q5 t
CommIndexEnd=ForceSingleCoilIndexEnd;
7 f6 Y" ~) J. H& r% p# K) [
: T- v% V: z- T4 z" {1 L  v4 J3 tbreak;" t' E2 I8 p7 Q9 x+ `" D9 g
+ g! k+ n$ E# H- R: E
case ReadHoldReg:/ Y: R8 X. y$ V2 v
0 p$ ]& Y1 J& x# n
CommIndexEnd=ReadHoldRegIndexEnd;, w* H& h" z1 Q% ]1 I7 Q

; w' b9 U3 _8 K2 T4 p1 C4 H3 v8 _break;: F, i2 E: I1 H

5 G* |, t8 D4 e. y% s- _# a' Ocase PresetMulReg:
$ w1 R- _% S) D0 [0 V- ^* x% s( ^) C( j% q& x+ I6 l
CommIndexEnd=6+CommBuf[CommIndexNoPointLo]*2+2;0 s0 x. w7 M9 ]- g

# v, E. s1 X% |+ r- t* Nbreak;8 J" [2 Y( f9 U, c, k$ A+ N0 l
; l3 c- d" d, g- ~
default:2 N8 G6 T: G, t/ ?. M9 o& F
& X/ t3 i" |4 B9 e4 o4 p3 m# U9 m' ^
break;9 Q; ]  ^( e1 N* J
3 z1 s5 p& C7 X3 V. j* v3 Z
}
( p6 p- J. `; `7 H! g
; C& V. ^6 F# o7 a" s: g}0 P1 U# B) R' L8 P. w8 d0 X$ s$ @5 l

+ I, ]+ y: b! _) rCommIndex++;% S, d0 \/ W4 s; O0 |
. h( n, |% C# Q. G( k. ?
}
/ w, f1 A4 x/ C+ r4 V/ `6 `. g- K( i" b  M3 x9 U
else // recieve finished CommIndex==CommIndexEnd# |+ [( `1 f  j) t: w

+ _  o7 ?: J4 P7 ~: q{; W2 l7 d' {& {( ?& s5 j

2 z( _  }, z9 Q5 B$ A; ]" `CommBuf[CommIndexEnd]=SBUF;9 F" i" b* Y) s. V: J. j# C
: [0 B+ F2 l7 F% _
RecFinishF=1;" E9 @- \& j- X

7 Z8 x( e$ V! A) S7 wfor (i=0;i<=Sen$ C  E: |7 n$ n& g
* M- r7 t/ c+ Z5 I* s+ ~
dRecieveDelay;i++) // delay  a7 ?& X0 L4 j& j

& n0 r4 B- j( a8 k+ __nop_();
) u! z8 O) M) u$ S5 `# S% N) h, L  L; M
T0=SEND;' d$ ?, E1 o: {* C+ ?, V

; ]4 E9 C& c' x}
+ g1 l% v! X' }6 Z
& H" n: }( p, U, K7 G}/ G. B: f6 V2 b

! N5 `% ]9 Z* X: M+ J7 OES=1;' P! ?: T6 y" [3 u+ f
+ o5 y! l  y# k& y- E& z, j1 k& D
}
1 {$ R8 J# L4 ?' c& R! |4 L+ {1 Y1 h4 Q; d  V" H
/*------------------ main code following -----------------*/
; y7 f% I2 ]+ R& e8 s* a2 p
' e* j/ L* v/ T: [3 c$ Tvoid main(void)" ^  V' f+ A3 d
# W! v# m0 P1 [! B+ o
{
# {. ^7 E  J8 ]$ E' K# s* F% a+ ^
/ g& n2 Y. E6 d# |) D6 h+ [3 Muint data i;
) P/ z6 x. }& R- f- l2 D1 U* o
$ I/ [# M6 S) J$ y' h, Binit();6 K6 ^* I7 s6 @. m" B3 [; @

, [% |! ?; B" j2 k+ _" ewhile(1)5 a- [6 z4 |& M" M
. w2 m4 M- i, o% p3 H( r
{3 m7 T7 x9 {, c) d2 c# _
: ]  i* n6 O6 u: @1 A' B' U
// LED0=!LED0;
! s. D; f( p$ ~5 z. u3 I
% s: \0 A6 m' h% \! Tfor(i=0;i<=9;i++)
' U+ \) e2 _5 j5 f5 T1 ~& b" T9 a
_nop_();, ~8 w0 m& B- B( }" a
2 f4 P4 {# G/ J! o4 i
if (RecFinishF)% i$ T6 K% a, o
& d1 `. Q- u5 v
{
2 m* l; `: u' b9 w4 S5 W: ?& p  t
AnalyzeRecieve();5 ]0 a4 T2 k8 }5 T) ?& X5 V

* u% H) o! s0 T# z- `7 q! y* uRecFinishF=0;

3 ?" v; j% @( |! c; f}
& k3 S7 _) Y: K3 r' H0 e; h) a) ~: g
}# y/ {% x* X2 D" }6 m% \8 w, \7 |" Q
$ \( e) k/ X( c+ m
}

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

谢谢分享

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

不错

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

c51单片机MODBUS参考程序

EDA365欢迎您登录！

浏览过的版块

推荐内容 /1