MODBUS simple question

[AnthonyRFC]

Hi all:

I have a simple question regarding the modbus library and its use.

**How I can read more than 8 inputs or coils status? Just making the int8 input to a bigger variable?

**How i do it when I have more that 32 inputs (using a long)?


My current CCS is ver 4.104


Best regards and thanks for your time!
_________________
From Cumaná, Venezuela.

[Ttelmah]

You need to use an array. Modbus itself only handles data as int16 values, and coils as int8. The write_multiple coils code, is happy to accept an array of up to 250bytes. Coil numbers are allowed to be up to 2000. The example is only an example. Look at how the register access code is done (which uses an array), but be aware that registers are accessed as 16bit objects, while coils are always organised as 8bit.

[AnthonyRFC]

So I must group inputs into a byte? Later into an array?


Something like this?

[RF_Developer]

The example code uses eight of each type of MODBUS endpoint, eight coils, eight discrete input with input registers, eight holding registers, etc.

A coil is a single bit output, on or off. The example organises eight of them into a single int8. A coil is a bit, not a byte. They may be written individually.

A discrete input is a single bit. A discrete input is a bit, not a byte. They may be read individually. The example organises eight of them into a single int8.

A input register is up to sixteen bits. It is intended for "live" data. The example organises eight of them in an array. They may be read or written.

A holding register is up to sixteen bits. They are intended for processed data. They may be read or written.

These are the main data types. Coils are not used as much now as they were when MODBUS was first developed. They perhaps are most useful for global on/off controls, interlocks and similar functions.

Input registers are also comparitively rarely used in modern MODBUS systems. They were are intended for live, changing data.

Holding registers are the most commonly used these days. They are simply sixteen (or less - you don't have to implement all bits of a register) bit data of any type. They are general purpose and were orginally intended for processed data that changed less often than live data. They can be used for calibration parameters, control and other stuff.

There can be many more of each than the example provides. The example, for simplicity, does just eight of each. They can be accessed individually or in arbitrarily large groups. The example code can be expanded to more than eight, but it takes a little thinking about.

There are various limits as to how many of each can be read and written at a time to do with message size limits and so on. The code may place its own limits, just as the example code does. The code should give sensible MODBUS error messages when an attempt is made to access an unimplemented coil, input or register.

You do not have to have actual arrays to contain all the data. I use virtualisation to implement many registers and coils, etc. and don't have arrays of coils, or bytes of coils, and arrays of int16s for holding registers. Instead I redirect the request for data to an appropriate routine. Its a bit like an object orientated approach, instead of accessing data that's necessarily a copy of something, I use access routines (get/set routines) to provide the latest data.

Here is a part of my example code derived code. This is for reading holding registers. I'm using an array of sixteen "scratch" registers to temporarily hold the data from my virtualised registers, read by Read_Register():

[AnthonyRFC]

Let me explain what I got and correct me if I'm wrong:

1.- Use the length of the request (modbus_rx.data[3]) in a for cycle to evaluate the actual data of inputs (coming from the ports of the PIC).

2.-Save the data into and array.

3.-Response to the master using that array.

Correct?

Thanks for your help!
_________________
From Cumaná, Venezuela.

[AnthonyRFC]

Hi.. I tried to modify the software and I'm getting the **TIME OUT error** using ModScan32.

First: I change the limit of the lenght to accept more than 8 addresses

[RF_Developer]

A few issues that need to be addressed:

Coils are single logic OUTPUTS: they can be written individually with FUNC_WRITE_SINGLE_COIL and in groups of arbitary size with FUNC_WRITE_MULTIPLE_COILS. The state of them can also be read back with FUNC_READ_COILS in groups or individually.

Discrete inputs are single logic INPUTS: They are NOT the same as coils, which are OUTPUTS. They may be read with FUNC_READ_DISCRETE_INPUT individually or as a group.

You have to implement all of these MODBUS standard functions even if it is something as simple as:

[AnthonyRFC]