Continue to Site

Welcome to EDAboard.com

Welcome to our site! EDAboard.com is an international Electronics Discussion Forum focused on EDA software, circuits, schematics, books, theory, papers, asic, pld, 8051, DSP, Network, RF, Analog Design, PCB, Service Manuals... and a whole lot more! To participate you need to register. Registration is free. Click here to register now.

Modbus RTU communication with modbus pool app

Status
Not open for further replies.

rattlesnake

Newbie level 2
Joined
May 28, 2018
Messages
2
Helped
0
Reputation
0
Reaction score
0
Trophy points
1
Activity points
65
Hi guys.


I need communicate with pic to Modbus pool program. But somehow my code doesn't work. Modbus pool is master device and pic is slave.

Can you help me, what is problem. :(

My code:


Code C - [expand]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
#include <16F877A.h> 
#device ADC=16 
 
#FUSES NOWDT                    //No Watch Dog Timer 
 
#FUSES NOBROWNOUT               //No brownout reset 
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O 
 
#use delay(clock=20000000)   // osilatör hızı 
#define MODBUS_TYPE MODBUS_TYPE_SLAVE 
#define MODBUS_SERIAL_TYPE MODBUS_RTU     //use MODBUS_ASCII for ASCII mode 
#define MODBUS_SERIAL_RX_BUFFER_SIZE 64 
#define MODBUS_SERIAL_BAUD 9600 
 
#ifndef USE_WITH_PC 
#define MODBUS_SERIAL_INT_SOURCE MODBUS_INT_RDA 
#define MODBUS_SERIAL_TX_PIN PIN_C6 // Data transmit pin 
#define MODBUS_SERIAL_RX_PIN PIN_C7   // Data receive pin 
//The following should be defined for RS485 communication 
#define MODBUS_SERIAL_ENABLE_PIN  PIN_A3   // Controls DE pin for RS485 
#define MODBUS_SERIAL_RX_ENABLE   PIN_A3 // Controls RE pin for RS485 
#endif 
 
#include <modbus.c> 
 
#define MODBUS_ADDRESS 3 
 
int8 swap_bits(int8 c) 
{ 
   return ((c&1)?128:0)|((c&2)?64:0)|((c&4)?32:0)|((c&8)?16:0)|((c&16)?8:0) 
          |((c&32)?4:0)|((c&64)?2:0)|((c&128)?1:0); 
} 
 
void main() 
{ 
   int8 coils = 0b00000101; 
   int8 inputs = 0b00001001; 
   int16 hold_regs[] = {0x8800,0x7700,0x6600,0x5500,0x4400,0x3300,0x2200,0x1100}; 
   int16 input_regs[] = {0x1100,0x2200,0x3300,0x4400,0x5500,0x6600,0x7700,0x8800}; 
   int16 event_count = 0; 
 
   setup_adc_ports(NO_ANALOGS); 
 
   modbus_init(); 
 
   while(TRUE) 
   { 
 
    hold_regs[0]=100; 
    
//!    input_regs[1]=0xAA; 
//!    input_regs[2]=0xAA; 
  //  hold_regs[0]=0x55; 
//!    hold_regs[1]=0x55; 
//!    hold_regs[2]=0x55; 
    
      while(!modbus_kbhit()); 
      //check address against our address, 0 is broadcast 
       delay_us(50); 
      if((modbus_rx.address == MODBUS_ADDRESS) || modbus_rx.address == 0) 
      { 
         switch(modbus_rx.func) 
         { 
            case FUNC_READ_COILS:    //read coils 
            case FUNC_READ_DISCRETE_INPUT:    //read inputs 
               if(modbus_rx.data[0] || modbus_rx.data[2] || 
                  modbus_rx.data[1] >= 8 || modbus_rx.data[3]+modbus_rx.data[1] > 8) 
                  modbus_exception_rsp(MODBUS_ADDRESS,modbus_rx.func,ILLEGAL_DATA_ADDRESS); 
               else 
               { 
                  int8 data; 
 
                  if(modbus_rx.func == FUNC_READ_COILS) 
                     data = coils>>(modbus_rx.data[1]);      //move to the starting coil 
                  else 
                     data = inputs>>(modbus_rx.data[1]);      //move to the starting input 
 
                  data = data & (0xFF>>(8-modbus_rx.data[3]));  //0 out values after quantity 
 
                  if(modbus_rx.func == FUNC_READ_COILS) 
                     modbus_read_discrete_input_rsp(MODBUS_ADDRESS, 0x01, &data); 
                  else 
                     modbus_read_discrete_input_rsp(MODBUS_ADDRESS, 0x01, &data); 
 
                  event_count++; 
               } 
               break; 
            case FUNC_READ_HOLDING_REGISTERS: 
            case FUNC_READ_INPUT_REGISTERS: 
               if(modbus_rx.data[0] || modbus_rx.data[2] || 
                  modbus_rx.data[1] >= 8 || modbus_rx.data[3]+modbus_rx.data[1] > 8) 
                  modbus_exception_rsp(MODBUS_ADDRESS,modbus_rx.func,ILLEGAL_DATA_ADDRESS); 
               else 
               { 
                  if(modbus_rx.func == FUNC_READ_HOLDING_REGISTERS) 
                     modbus_read_holding_registers_rsp(MODBUS_ADDRESS,(modbus_rx.data[3]*2),hold_regs+modbus_rx.data[1]); 
                  else 
                     modbus_read_input_registers_rsp(MODBUS_ADDRESS,(modbus_rx.data[3]*2),input_regs+modbus_rx.data[1]); 
 
                  event_count++; 
               } 
               break; 
            case FUNC_WRITE_SINGLE_COIL:      //write coil 
               if(modbus_rx.data[0] || modbus_rx.data[3] || modbus_rx.data[1] > 8) 
                  modbus_exception_rsp(MODBUS_ADDRESS,modbus_rx.func,ILLEGAL_DATA_ADDRESS); 
               else if(modbus_rx.data[2] != 0xFF && modbus_rx.data[2] != 0x00) 
                  modbus_exception_rsp(MODBUS_ADDRESS,modbus_rx.func,ILLEGAL_DATA_VALUE); 
               else 
               { 
                  if(modbus_rx.data[2] == 0xFF) 
                     bit_set(coils,modbus_rx.data[1]); 
                  else 
                     bit_clear(coils,modbus_rx.data[1]); 
 
                  modbus_write_single_coil_rsp(MODBUS_ADDRESS,modbus_rx.data[1],((int16)(modbus_rx.data[2]))<<8); 
 
                  event_count++; 
               } 
               break; 
            case FUNC_WRITE_SINGLE_REGISTER: 
               if(modbus_rx.data[0] || modbus_rx.data[1] >= 8) 
                  modbus_exception_rsp(MODBUS_ADDRESS,modbus_rx.func,ILLEGAL_DATA_ADDRESS); 
               else 
               { 
                  hold_regs[modbus_rx.data[1]] = make16(modbus_rx.data[2],modbus_rx.data[3]); 
 
                  modbus_write_single_register_rsp(MODBUS_ADDRESS, 
                               make16(modbus_rx.data[0],modbus_rx.data[1]), 
                               make16(modbus_rx.data[2],modbus_rx.data[3])); 
               } 
               break; 
            case FUNC_WRITE_MULTIPLE_COILS: 
               if(modbus_rx.data[0] || modbus_rx.data[2] || 
                  modbus_rx.data[1] >= 8 || modbus_rx.data[3]+modbus_rx.data[1] > 8) 
                  modbus_exception_rsp(MODBUS_ADDRESS,modbus_rx.func,ILLEGAL_DATA_ADDRESS); 
               else 
               { 
                  int i,j; 
 
                  modbus_rx.data[5] = swap_bits(modbus_rx.data[5]); 
 
                  for(i=modbus_rx.data[1],j=0; i < modbus_rx.data[1]+modbus_rx.data[3]; ++i,++j) 
                  { 
                     if(bit_test(modbus_rx.data[5],j)) 
                        bit_set(coils,7-i); 
                     else 
                        bit_clear(coils,7-i); 
                  } 
 
                  modbus_write_multiple_coils_rsp(MODBUS_ADDRESS, 
                                 make16(modbus_rx.data[0],modbus_rx.data[1]), 
                                 make16(modbus_rx.data[2],modbus_rx.data[3])); 
 
                  event_count++; 
               } 
               break; 
            case FUNC_WRITE_MULTIPLE_REGISTERS: 
               if(modbus_rx.data[0] || modbus_rx.data[2] || 
                  modbus_rx.data[1] >= 8 || modbus_rx.data[3]+modbus_rx.data[1] > 8) 
                  modbus_exception_rsp(MODBUS_ADDRESS,modbus_rx.func,ILLEGAL_DATA_ADDRESS); 
               else 
               { 
                  int i,j; 
 
                  for(i=0,j=5; i < modbus_rx.data[4]/2; ++i,j+=2) 
                     hold_regs[i] = make16(modbus_rx.data[j],modbus_rx.data[j+1]); 
 
                  modbus_write_multiple_registers_rsp(MODBUS_ADDRESS, 
                                 make16(modbus_rx.data[0],modbus_rx.data[1]), 
                                 make16(modbus_rx.data[2],modbus_rx.data[3])); 
 
                  event_count++; 
               } 
               break; 
            default:    //We don't support the function, so return exception 
               modbus_exception_rsp(MODBUS_ADDRESS,modbus_rx.func,ILLEGAL_FUNCTION); 
         } 
      } 
  } 
}



Modbus tool program settings.

Yeni_Bit_E_lem_Resmi_2.png
 

"Doesn't work" is no useful diagnosis. What does your MODBUS server (PIC) receive, does it recognize a valid request, what does it send back? I have used the CCS MODBUS example many years ago, it basically works.
 
"Doesn't work" is no useful diagnosis. What does your MODBUS server (PIC) receive, does it recognize a valid request, what does it send back? I have used the CCS MODBUS example many years ago, it basically works.

I'm using this hardware, It has sn75176 transmitter
http://elektrotasarim.com/UARTtoRS485_Breakout.html

datasheet
http://elektrotasarim.com/UARTtoRS485_Breakout.pdf

Everything good with this hardware on arduino platform, I controlled it. But I want to use on pic 16F877A.

I'm using A B and GND terminals.


No response from pic. It is modbus pool.

http://ibb.co/jPeUi8

Do I need bias resistor or terminal resistor, or code has fault, I don't know,what is problem...

What can I do for solving problem, any suggestion?
 

Status
Not open for further replies.

Similar threads

Part and Inventory Search

Welcome to EDABoard.com

Sponsor

Back
Top