LabVIEW
I cannot read and write information using the Modbus API library and the serial port becomes unusable when the program is run.
Solved!
@constructionworker wrote:
What exactly is the correct way to do this.
The answer is as always with such things: it depends.
In this specific case you would use a one dimensional array that auto-indexes just as the address array. And to make the single scalar value on the inside of the border match the array input of Write Register function, to place a Build Array Node in between with one element input.
As to writing negative values: Again it depends on what you want to write and how that register is defined by your device. If it is defined as a 16 bit signed integer with range -32768 ... 32767 you can create such a control or constant in LabVIEW and then use a ToUInt16 conversion function to convert it to an unsigned 16-bit integer before sending it to the Modbus Write function. If it is designed as a 8-bit signed integer instead with a range of -128 to +127 things are less clear and it depends very much how the device treats the actual 16 bit register internally. The above code may still work or it may not, depending on the device implementation.
That's the address you are pointing at. There are no negative Modbus addresses.
As to data: Modbus only has 16 bit unsigned registers (and coils, which are single booleans). If your device likes to interpret the bits in such a 16 bit register as signed number or not is entirely up to the device but Modbus itself does not have signed integer registers.
So the "problem" is that you need to understand how your device likes to interpret that register and then write the correct bit pattern into it so that it understands the data. If your device likes to treat a register as an int16 value, you can in LabVIEW create a signed 16-bit integer control and enter the value as you like it, then convert it to a unsigned 16 bit integer and transfer it through the Modbus VIs and then check that the value is seen correctly in the device. If not you need to investigate where the difference happens. As already mentioned the main issue is simply to understand how your device likes to interpret the register. If it wants to treat it as boolean it still is a 16 bit register but only the first bit of those 16 bits is interesting for it. If it wants to use a 32 bit value it has to use two 16 bit Modbus registers and combine them to a 32 bit register. You have to then know what order the two registers are to be done, as you can either have the first register containing the lower significant 16 bits or the second register. All of this is however entirely independent of LabVIEW as you first have to understand how your device "thinks"! And this is where these exercises often end. Not because LabVIEW can't do it, it certainly can, but because the person doesn't understand about integers and that they are in essence also simply a variable number of bits and that you can perfectly transfer that bunch of bits as an unsinged 16 bit integer and the device will simply treat it as a signed integer then, if it insists on a signed integer.
Well, if you need a range of -75000 to + 75000 you obviously have a larger range than what a 16 bit integer can contain, no matter if it is signed or not.
So that means that your device really needs a 32 bit signed integer, and since Modbus only has 16 bit registers, it needs to combine two of them to create such a 32 bit register. How to do that?
Do you remember the code earlier on where we had register to read that were 32 bit. You read 2 registers and "combined" them into a 32 bit integer.
Now you want to write such a register so you have to reverse that operation. You take a 32 -bit number and split it into two 16 bit numbers and send them as that to the device. It's as simple as that, except you need to know the order in which those 2 16-bit registers are to be transmitted. From the earlier example when reading a 32-bit register we saw that the first register was the lowest significant 16-bit and the second register was the highest significant 16-bit, so it is quite safe to assume that that also applies to registers we need to write.
Here are a number of possibilities to do this:
Well if it works it works. It looks a bit like playing around until it seems to do what it should without quite understanding what you did. But if it works it works.
@constructionworker wrote:
I think I solved the problem. It was solved by converting a 2 dimensional array. Do you think this method is correct?
Since those two locations are directly consecutive - P1-09 and P1-10 are directly behind each other - and you want to write the two registers that make up such a location anyhow, it would be much better to simply create a 1D array that contains the four 16 bit registers and simply write that to the Modbus with start address 0112H. This way you write both locations in one go without needing 2D arrays. If the registers are not directly behind each other, then you would have to separate the two writes of course.
