Re: [MODBUS][DISCUSS] Improving handling of datatypes ...

[Ben Hutcheson]

Hi Chris,

I'm not sure I follow your last email,

I have pushed a commit to *hutcheb:Feature/ModbusDataType
, *which
includes some of the changes I've proposed.

1) Within
build-utils/language-java/src/main/resources/templates/java/data-io-template.ftlh,
I've added a cast to the PLCValue so that we can use methods specific to
the PLCValue types to decode input from th PLC not just the methods defined
in the interface.
2) I've added the initial framework for adding Modbus datatypes within the
address string. This is able to support the INT (r/w) and UINT (w)
datatypes when parsing a Java String (I have to clean it up and fix up
handling of PLCList types)
3) I've updated the Modbus.mspec to include the INT datatype within the
dataio section, I would have to add the rest of the datatypes in the same
section.
4) I've added PlcINT and PlcUINT classes and have moved the handling of
parsing different Java Datatypes into these, as well as some handling of
decoding within the PlcINT classes. Along with the last point this allows
us to decode the INT datatype within the DataItemIO.java file.

Let me know what you think?

Kind Regards

Ben

On Tue, Sep 8, 2020 at 11:44 AM Christofer Dutz 
wrote:

> Hi Ben,
>
> well the PlcValue types are based on the types used in the language they
> are used in. In PLC4C, which supports signed and unsigned types, I
> implemented them differently.
> Initially I thought that if the PlcValues would simply have a byte-array
> and a type, then it would be universal ... but I thought accessing the
> values would require more cpu and memory.
>
> But given the fact that if we had such generic PlcValues, we could use
> them in all drivers ... sort of makes them more interesting.
>
> We could have multiple implementations of them ... so we could have these
> DefaultPlcValue implementation for the normal 61131 datatypes but give
> drivers the opportunity to provide customizations for special types.
>
> What do you think?
>
> Chris
>
>
>
> Am 08.09.20, 14:44 schrieb "Ben Hutcheson" :
>
> Hi Chris,
>
> The case where PLC data types are mapped to 16 bit registers isn't a
> special case, as the Modbus protocol only supports 16 bit registers
> but it
> doesn't specify what format the data should be in,any PLC data type
> can be
> mapped to these and then passed over Modbus. It would definitely be
> handy
> to be able to convert any of the PLC datatypes back from Modbus 16-bit
> registers to whatever datatype they should be. I've done some work
> already
> on the specific case of mapping a Java String to the
> PLCInteger/PLCShort
> classes and can expand it basing it off the S7 functions that do the
> same.
> We can then look at the differences and consolidate them if possible?
>
> However it would be great to be able to add unambiguous classes to
> plc4j/api/src/main/java/org/apache/plc4x/java/api/value for each of
> the IEC
> datatypes instead of these being based off Java types.
>
> Using the same format as the S7 protocol the address string would be
> holding-register:1000:REAL[10] instead though, I don't think this will
> cause issues if we make it optional and default to INT or BOOL as
> required.
>
> Kind Regards
>
> Ben
>
>
>
>
>
>
>
> On Tue, Sep 8, 2020 at 8:10 AM Christofer Dutz <
> christofer.d...@c-ware.de>
> wrote:
>
> > Hi Ben ...
> >
> > Sorry for my email... I should really finish reading before replying
> :-(
> >
> > About your suggestion to add it to the type to the ModbusField ... I
> > agree. But I would simply extend the Address string the same way the
> TIA
> > addresses were extended.
> > Cause the problem I'm seeing is that for the 61131 datatypes we can
> > provide an enum, but not for any custom types the driver might be
> > supporting. With a String we can keep it simple ... check if the
> type is a
> > 61131 type -> if yes: do the default handling. If it's not, use some
> driver
> > specific encoding/decoding.
> >
> > In my particular case the Float values were also 4 byte values ... I
> > manually solved it by requesting 2 element arrays for every float
> address
> > (The map of reigsters only used only even register numbers, so that
> > worked). Then I manually converted the 2 x 2bytes into a 4byte float
> with
> > this code:
> >
> > // Decode the first 10 shorts as 32bit floats ...
> > StringBuilder sb = new StringBuilder();
> > for(int i = 0; i < 10; i++) {
> > int short1 = value.getIndex(i * 2).getInteger();
> > int short2 = value.getIndex((i * 2) +
> 1).getInteger();
> > WriteBuffer wb = new WriteBuffer(4);
> > wb.writeInt(16, short1);
> > wb.writeInt(16, short2);
> > final byte[] 

Re: [MODBUS][DISCUSS] Improving handling of datatypes ...

[Christofer Dutz]

Hi Ben,

well the PlcValue types are based on the types used in the language they are 
used in. In PLC4C, which supports signed and unsigned types, I implemented them 
differently. 
Initially I thought that if the PlcValues would simply have a byte-array and a 
type, then it would be universal ... but I thought accessing the values would 
require more cpu and memory.

But given the fact that if we had such generic PlcValues, we could use them in 
all drivers ... sort of makes them more interesting. 

We could have multiple implementations of them ... so we could have these 
DefaultPlcValue implementation for the normal 61131 datatypes but give drivers 
the opportunity to provide customizations for special types.

What do you think?

Chris



Am 08.09.20, 14:44 schrieb "Ben Hutcheson" :

Hi Chris,

The case where PLC data types are mapped to 16 bit registers isn't a
special case, as the Modbus protocol only supports 16 bit registers but it
doesn't specify what format the data should be in,any PLC data type can be
mapped to these and then passed over Modbus. It would definitely be handy
to be able to convert any of the PLC datatypes back from Modbus 16-bit
registers to whatever datatype they should be. I've done some work already
on the specific case of mapping a Java String to the PLCInteger/PLCShort
classes and can expand it basing it off the S7 functions that do the same.
We can then look at the differences and consolidate them if possible?

However it would be great to be able to add unambiguous classes to
plc4j/api/src/main/java/org/apache/plc4x/java/api/value for each of the IEC
datatypes instead of these being based off Java types.

Using the same format as the S7 protocol the address string would be
holding-register:1000:REAL[10] instead though, I don't think this will
cause issues if we make it optional and default to INT or BOOL as required.

Kind Regards

Ben







On Tue, Sep 8, 2020 at 8:10 AM Christofer Dutz 
wrote:

> Hi Ben ...
>
> Sorry for my email... I should really finish reading before replying :-(
>
> About your suggestion to add it to the type to the ModbusField ... I
> agree. But I would simply extend the Address string the same way the TIA
> addresses were extended.
> Cause the problem I'm seeing is that for the 61131 datatypes we can
> provide an enum, but not for any custom types the driver might be
> supporting. With a String we can keep it simple ... check if the type is a
> 61131 type -> if yes: do the default handling. If it's not, use some 
driver
> specific encoding/decoding.
>
> In my particular case the Float values were also 4 byte values ... I
> manually solved it by requesting 2 element arrays for every float address
> (The map of reigsters only used only even register numbers, so that
> worked). Then I manually converted the 2 x 2bytes into a 4byte float with
> this code:
>
> // Decode the first 10 shorts as 32bit floats ...
> StringBuilder sb = new StringBuilder();
> for(int i = 0; i < 10; i++) {
> int short1 = value.getIndex(i * 2).getInteger();
> int short2 = value.getIndex((i * 2) + 1).getInteger();
> WriteBuffer wb = new WriteBuffer(4);
> wb.writeInt(16, short1);
> wb.writeInt(16, short2);
> final byte[] data = wb.getData();
> int intVal = (data[3] & 0xFF) | ((data[2] & 0xFF) << 8) |
> ((data[1] & 0xFF) << 16) | ((data[0] & 0xFF) << 24);
> final float v1 = Float.intBitsToFloat(intVal);
> sb.append(v1).append(", ");
> }
>
> Ok in this case I read 10 floats by reading an array of 20 registers.
> Guess it should be even simpler with 32bit integers
>
> But I guess it does the job ... not pretty, but it works and I would
> definitely love to have something similar in the drivers to handle this if
> I said "holding-register:1000[10]:REAL"
>
> Chris
>
>
> Am 08.09.20, 13:59 schrieb "Christofer Dutz" :
>
> Hi Ben,
>
> if you have followed the latest discussions here ... currently the
> modbus protocol supports 16bit integer values for registers and Boolean
> values for coils.
> The protocol doesn't directly support anything else. However I have
> seen that vendors use arrays of registers to support higher level types. 
In
> my special case the PLC vendor used two 16bit integers to provide 32bit
> float values.
>
> We will probably start adding support for the basic IEC 61131
> datatypes (https://en.wikipedia.org/wiki/IEC_61131-3) but I think this
> will only apply for the Bool, Bit-String, Signed and Unsigned Integers as
> well as Real values. 

Re: [MODBUS][DISCUSS] Improving handling of datatypes ...

[Ben Hutcheson]

Hi Chris,

The case where PLC data types are mapped to 16 bit registers isn't a
special case, as the Modbus protocol only supports 16 bit registers but it
doesn't specify what format the data should be in,any PLC data type can be
mapped to these and then passed over Modbus. It would definitely be handy
to be able to convert any of the PLC datatypes back from Modbus 16-bit
registers to whatever datatype they should be. I've done some work already
on the specific case of mapping a Java String to the PLCInteger/PLCShort
classes and can expand it basing it off the S7 functions that do the same.
We can then look at the differences and consolidate them if possible?

However it would be great to be able to add unambiguous classes to
plc4j/api/src/main/java/org/apache/plc4x/java/api/value for each of the IEC
datatypes instead of these being based off Java types.

Using the same format as the S7 protocol the address string would be
holding-register:1000:REAL[10] instead though, I don't think this will
cause issues if we make it optional and default to INT or BOOL as required.

Kind Regards

Ben







On Tue, Sep 8, 2020 at 8:10 AM Christofer Dutz 
wrote:

> Hi Ben ...
>
> Sorry for my email... I should really finish reading before replying :-(
>
> About your suggestion to add it to the type to the ModbusField ... I
> agree. But I would simply extend the Address string the same way the TIA
> addresses were extended.
> Cause the problem I'm seeing is that for the 61131 datatypes we can
> provide an enum, but not for any custom types the driver might be
> supporting. With a String we can keep it simple ... check if the type is a
> 61131 type -> if yes: do the default handling. If it's not, use some driver
> specific encoding/decoding.
>
> In my particular case the Float values were also 4 byte values ... I
> manually solved it by requesting 2 element arrays for every float address
> (The map of reigsters only used only even register numbers, so that
> worked). Then I manually converted the 2 x 2bytes into a 4byte float with
> this code:
>
> // Decode the first 10 shorts as 32bit floats ...
> StringBuilder sb = new StringBuilder();
> for(int i = 0; i < 10; i++) {
> int short1 = value.getIndex(i * 2).getInteger();
> int short2 = value.getIndex((i * 2) + 1).getInteger();
> WriteBuffer wb = new WriteBuffer(4);
> wb.writeInt(16, short1);
> wb.writeInt(16, short2);
> final byte[] data = wb.getData();
> int intVal = (data[3] & 0xFF) | ((data[2] & 0xFF) << 8) |
> ((data[1] & 0xFF) << 16) | ((data[0] & 0xFF) << 24);
> final float v1 = Float.intBitsToFloat(intVal);
> sb.append(v1).append(", ");
> }
>
> Ok in this case I read 10 floats by reading an array of 20 registers.
> Guess it should be even simpler with 32bit integers
>
> But I guess it does the job ... not pretty, but it works and I would
> definitely love to have something similar in the drivers to handle this if
> I said "holding-register:1000[10]:REAL"
>
> Chris
>
>
> Am 08.09.20, 13:59 schrieb "Christofer Dutz" :
>
> Hi Ben,
>
> if you have followed the latest discussions here ... currently the
> modbus protocol supports 16bit integer values for registers and Boolean
> values for coils.
> The protocol doesn't directly support anything else. However I have
> seen that vendors use arrays of registers to support higher level types. In
> my special case the PLC vendor used two 16bit integers to provide 32bit
> float values.
>
> We will probably start adding support for the basic IEC 61131
> datatypes (https://en.wikipedia.org/wiki/IEC_61131-3) but I think this
> will only apply for the Bool, Bit-String, Signed and Unsigned Integers as
> well as Real values. Durations, Times, Dates and especially Strings will be
> problematic as it seems every vendor uses a different encoding of these.
>
> Chris
>
>
> Am 08.09.20, 13:52 schrieb "Ben Hutcheson" :
>
> Hi,
>
> Looking at the example I had with the hello-world-write example
> trying to
> write a String to the Modbus protocol.
>
> ava -jar plc4j-hello-world-plc4x-write-0.8.0-SNAPSHOT-uber-jar.jar
> --connection-string modbus://127.0.0.1:5467 --field-addresses
> 40010
> -field-values 32000
>
> The value 32000 then gets cast as a String and is passed to the
> encodeString function in ModbusFieldHandler. (It doesn't have one
> it gets
> passed to the DefaultFieldHandler). To get this to work properly
> we would
> need to define a datatype to cast the String to, S7 does this
> already and
> with the consensus that IEC 61131 data types be used where
> possible then I
> see no reason we shouldn't add the datatype field to the
> ModbusField. If we
> are doing this for these protocols, then why don't we add the
> 

Re: [MODBUS][DISCUSS] Improving handling of datatypes ...

[Christofer Dutz]

Hi Ben ...

Sorry for my email... I should really finish reading before replying :-(

About your suggestion to add it to the type to the ModbusField ... I agree. But 
I would simply extend the Address string the same way the TIA addresses were 
extended. 
Cause the problem I'm seeing is that for the 61131 datatypes we can provide an 
enum, but not for any custom types the driver might be supporting. With a 
String we can keep it simple ... check if the type is a 61131 type -> if yes: 
do the default handling. If it's not, use some driver specific 
encoding/decoding.

In my particular case the Float values were also 4 byte values ... I manually 
solved it by requesting 2 element arrays for every float address (The map of 
reigsters only used only even register numbers, so that worked). Then I 
manually converted the 2 x 2bytes into a 4byte float with this code:

// Decode the first 10 shorts as 32bit floats ...
StringBuilder sb = new StringBuilder();
for(int i = 0; i < 10; i++) {
int short1 = value.getIndex(i * 2).getInteger();
int short2 = value.getIndex((i * 2) + 1).getInteger();
WriteBuffer wb = new WriteBuffer(4);
wb.writeInt(16, short1);
wb.writeInt(16, short2);
final byte[] data = wb.getData();
int intVal = (data[3] & 0xFF) | ((data[2] & 0xFF) << 8) | 
((data[1] & 0xFF) << 16) | ((data[0] & 0xFF) << 24);
final float v1 = Float.intBitsToFloat(intVal);
sb.append(v1).append(", ");
}

Ok in this case I read 10 floats by reading an array of 20 registers. Guess it 
should be even simpler with 32bit integers

But I guess it does the job ... not pretty, but it works and I would definitely 
love to have something similar in the drivers to handle this if I said 
"holding-register:1000[10]:REAL"

Chris


Am 08.09.20, 13:59 schrieb "Christofer Dutz" :

Hi Ben,

if you have followed the latest discussions here ... currently the modbus 
protocol supports 16bit integer values for registers and Boolean values for 
coils.
The protocol doesn't directly support anything else. However I have seen 
that vendors use arrays of registers to support higher level types. In my 
special case the PLC vendor used two 16bit integers to provide 32bit float 
values.

We will probably start adding support for the basic IEC 61131 datatypes 
(https://en.wikipedia.org/wiki/IEC_61131-3) but I think this will only apply 
for the Bool, Bit-String, Signed and Unsigned Integers as well as Real values. 
Durations, Times, Dates and especially Strings will be problematic as it seems 
every vendor uses a different encoding of these.

Chris


Am 08.09.20, 13:52 schrieb "Ben Hutcheson" :

Hi,

Looking at the example I had with the hello-world-write example trying 
to
write a String to the Modbus protocol.

ava -jar plc4j-hello-world-plc4x-write-0.8.0-SNAPSHOT-uber-jar.jar
--connection-string modbus://127.0.0.1:5467 --field-addresses 40010
-field-values 32000

The value 32000 then gets cast as a String and is passed to the
encodeString function in ModbusFieldHandler. (It doesn't have one it 
gets
passed to the DefaultFieldHandler). To get this to work properly we 
would
need to define a datatype to cast the String to, S7 does this already 
and
with the consensus that IEC 61131 data types be used where possible 
then I
see no reason we shouldn't add the datatype field to the ModbusField. 
If we
are doing this for these protocols, then why don't we add the datatype
field to the PLCField interface, this would allow us to use the same
default encodeString (We may have to map the protocol specific 
datatypes to
IEC 61131 here, the same internalEncodeString might be better) functions
for S7 and Modbus by casting the input to a PLCField instead of a 
S7Field
or ModbusField.

When encodeString is then called we can use the datatype that is passed 
to
it to encode it to a PLCInteger/PLCFloat/etc.., the same way the S7
protocol does it. S7 however only allows Strings to be passed as string
related variables (CHAR, WCHAR, STRING and WSTRING), I don't see any 
reason
we can't expand this to be able to pass any PLC datatype from a string.

The next problem I had was to then be able to parse the PLCInteger 
class to
a byte array within the fromPLCValue function. For the UINT datatype for
the Modbus protocol, this is a 2 byte array however the PLCInteger class
contains it as a 4 byte array. in the fromPLCValue function there 
doesn't
seem to be a way to test to see if it is an UINT or a 4 byte integer 
such
as a DINT. If we were to change the classes in
plc4j/api/src/main/java/org/apache/plc4x/java/api/value to 

Re: [MODBUS][DISCUSS] Improving handling of datatypes ...

[Christofer Dutz]

Hi Ben,

if you have followed the latest discussions here ... currently the modbus 
protocol supports 16bit integer values for registers and Boolean values for 
coils.
The protocol doesn't directly support anything else. However I have seen that 
vendors use arrays of registers to support higher level types. In my special 
case the PLC vendor used two 16bit integers to provide 32bit float values.

We will probably start adding support for the basic IEC 61131 datatypes 
(https://en.wikipedia.org/wiki/IEC_61131-3) but I think this will only apply 
for the Bool, Bit-String, Signed and Unsigned Integers as well as Real values. 
Durations, Times, Dates and especially Strings will be problematic as it seems 
every vendor uses a different encoding of these.

Chris


Am 08.09.20, 13:52 schrieb "Ben Hutcheson" :

Hi,

Looking at the example I had with the hello-world-write example trying to
write a String to the Modbus protocol.

ava -jar plc4j-hello-world-plc4x-write-0.8.0-SNAPSHOT-uber-jar.jar
--connection-string modbus://127.0.0.1:5467 --field-addresses 40010
-field-values 32000

The value 32000 then gets cast as a String and is passed to the
encodeString function in ModbusFieldHandler. (It doesn't have one it gets
passed to the DefaultFieldHandler). To get this to work properly we would
need to define a datatype to cast the String to, S7 does this already and
with the consensus that IEC 61131 data types be used where possible then I
see no reason we shouldn't add the datatype field to the ModbusField. If we
are doing this for these protocols, then why don't we add the datatype
field to the PLCField interface, this would allow us to use the same
default encodeString (We may have to map the protocol specific datatypes to
IEC 61131 here, the same internalEncodeString might be better) functions
for S7 and Modbus by casting the input to a PLCField instead of a S7Field
or ModbusField.

When encodeString is then called we can use the datatype that is passed to
it to encode it to a PLCInteger/PLCFloat/etc.., the same way the S7
protocol does it. S7 however only allows Strings to be passed as string
related variables (CHAR, WCHAR, STRING and WSTRING), I don't see any reason
we can't expand this to be able to pass any PLC datatype from a string.

The next problem I had was to then be able to parse the PLCInteger class to
a byte array within the fromPLCValue function. For the UINT datatype for
the Modbus protocol, this is a 2 byte array however the PLCInteger class
contains it as a 4 byte array. in the fromPLCValue function there doesn't
seem to be a way to test to see if it is an UINT or a 4 byte integer such
as a DINT. If we were to change the classes in
plc4j/api/src/main/java/org/apache/plc4x/java/api/value to match the IEC
61131 datatypes then we should be able to parse them correctly in Modbus
fromPLCValue function.

I have probably missed a few things out, like how the TransportSize class
for the S7 protocol works, and we may have to settle for mapping protocol
specific types to IEC61131 types in the encode functions in each protocol,
what are your thoughts?

Kind Regards

Ben




On Sun, Sep 6, 2020 at 11:25 AM Christofer Dutz 
wrote:

> Hi all,
>
> well I doubt that we could really centrally handle this.
> If you have an idea how to unify this, I'd be happy for a suggestion.
> I guess most will have to be handled in the individual drivers themselves.
>
> But I really would like all drivers to support the same base-set of
> datatypes.
>
> Chris
>
>
>
> Am 06.09.20, 17:02 schrieb "Cesar Garcia" :
>
> Hello,
>
> I think it can be applied from several points of view, the one
> typified as
> you indicate (HREGISTER: REAL) or (HREGISTER [2]), each one has its
> advantage.
>
> To be able to handle the types indifferently (specifically between
> Modbus
> and S7), I modify the field of the Modbus driver so that it strictly
> adapts
> to the PLC4X API. This prevents the user's App from having to 
implement
> code to interpret the content of the records.
>
> This is implemented in version 0.6.1 of  PLC4X, but the new version is
> something else.
>
> Best regards,
>
> El dom., 6 sept. 2020 a las 10:03, Ben Hutcheson (<
> ben.hut...@gmail.com>)
> escribió:
>
> > Hi,
> >
> > I ran into this issue this morning when using the hello-world-write
> example
> > and trying to write to a Modbus connection. It looks like it assumed
> the
> > input value is a string whereas the Modbus protocol doesn't have
> support
> > for it yet.
> >
> > I was thinking about expanding
> >
> >
> 

Re: [MODBUS][DISCUSS] Improving handling of datatypes ...

[Ben Hutcheson]

Hi,

Looking at the example I had with the hello-world-write example trying to
write a String to the Modbus protocol.

ava -jar plc4j-hello-world-plc4x-write-0.8.0-SNAPSHOT-uber-jar.jar
--connection-string modbus://127.0.0.1:5467 --field-addresses 40010
-field-values 32000

The value 32000 then gets cast as a String and is passed to the
encodeString function in ModbusFieldHandler. (It doesn't have one it gets
passed to the DefaultFieldHandler). To get this to work properly we would
need to define a datatype to cast the String to, S7 does this already and
with the consensus that IEC 61131 data types be used where possible then I
see no reason we shouldn't add the datatype field to the ModbusField. If we
are doing this for these protocols, then why don't we add the datatype
field to the PLCField interface, this would allow us to use the same
default encodeString (We may have to map the protocol specific datatypes to
IEC 61131 here, the same internalEncodeString might be better) functions
for S7 and Modbus by casting the input to a PLCField instead of a S7Field
or ModbusField.

When encodeString is then called we can use the datatype that is passed to
it to encode it to a PLCInteger/PLCFloat/etc.., the same way the S7
protocol does it. S7 however only allows Strings to be passed as string
related variables (CHAR, WCHAR, STRING and WSTRING), I don't see any reason
we can't expand this to be able to pass any PLC datatype from a string.

The next problem I had was to then be able to parse the PLCInteger class to
a byte array within the fromPLCValue function. For the UINT datatype for
the Modbus protocol, this is a 2 byte array however the PLCInteger class
contains it as a 4 byte array. in the fromPLCValue function there doesn't
seem to be a way to test to see if it is an UINT or a 4 byte integer such
as a DINT. If we were to change the classes in
plc4j/api/src/main/java/org/apache/plc4x/java/api/value to match the IEC
61131 datatypes then we should be able to parse them correctly in Modbus
fromPLCValue function.

I have probably missed a few things out, like how the TransportSize class
for the S7 protocol works, and we may have to settle for mapping protocol
specific types to IEC61131 types in the encode functions in each protocol,
what are your thoughts?

Kind Regards

Ben




On Sun, Sep 6, 2020 at 11:25 AM Christofer Dutz 
wrote:

> Hi all,
>
> well I doubt that we could really centrally handle this.
> If you have an idea how to unify this, I'd be happy for a suggestion.
> I guess most will have to be handled in the individual drivers themselves.
>
> But I really would like all drivers to support the same base-set of
> datatypes.
>
> Chris
>
>
>
> Am 06.09.20, 17:02 schrieb "Cesar Garcia" :
>
> Hello,
>
> I think it can be applied from several points of view, the one
> typified as
> you indicate (HREGISTER: REAL) or (HREGISTER [2]), each one has its
> advantage.
>
> To be able to handle the types indifferently (specifically between
> Modbus
> and S7), I modify the field of the Modbus driver so that it strictly
> adapts
> to the PLC4X API. This prevents the user's App from having to implement
> code to interpret the content of the records.
>
> This is implemented in version 0.6.1 of  PLC4X, but the new version is
> something else.
>
> Best regards,
>
> El dom., 6 sept. 2020 a las 10:03, Ben Hutcheson (<
> ben.hut...@gmail.com>)
> escribió:
>
> > Hi,
> >
> > I ran into this issue this morning when using the hello-world-write
> example
> > and trying to write to a Modbus connection. It looks like it assumed
> the
> > input value is a string whereas the Modbus protocol doesn't have
> support
> > for it yet.
> >
> > I was thinking about expanding
> >
> >
> github/plc4x/plc4j/spi/src/main/java/org/apache/plc4x/java/spi/connection/DefaultPlcFieldHandler.java
> > to include default handlers for the various IEEE 61131 data types,
> the
> > specific protocols can then override them as necessary?
> >
> > Kind Regards
> >
> > Ben
> >
> > On Wed, Sep 2, 2020 at 9:36 AM Christofer Dutz <
> christofer.d...@c-ware.de>
> > wrote:
> >
> > > Hi Julian,
> > >
> > > I agree ... if one driver would define an "INT" as 32bit integer
> and the
> > > others would treat it as 16bit ... that could be a problem.
> > > Perhaps having a statement of the project that we use the IEC
> 61131 types
> > > as a basis and if you want to use a given protocols different
> types, that
> > > you can prefix them ..
> > >
> > > Assuming a driver for the famous "HURZ" protocol would use 32bit
> INTs,
> > > then an "INT" could reference the 16bit version and a "HURZ_INT"
> could be
> > > the 32bit version?
> > >
> > > Chris
> > >
> > >
> > >
> > >
> > > Am 02.09.20, 15:26 schrieb "Julian Feinauer" <
> > > j.feina...@pragmaticminds.de>:
> > >
>  

[VOTE] Apache PLC4X Build-Tools Code-Generation 1.3.0 RC1

[Christofer Dutz]

   Apache PLC4X Build-Tools Code-Generation 1.3.0 has been staged under [2]
   and it’s time to vote on accepting it for release.

   All Maven artifacts are available under [1]. Voting will be open for 72hr.

   A minimum of 3 binding +1 votes and more binding +1 than binding -1
   are required to pass.

   Repository: https://gitbox.apache.org/repos/asf/plc4x-build-tools.git
   Release tag: releases/code-generation/1.3.0
   Hash for the release tag: 7f2fab83d6cd0ccba41b8622d6abe4f8995748bd

   Per [3] "Before voting +1 PMC members are required to download
   the signed source code package, compile it as provided, and test
   the resulting executable on their own platform, along with also
   verifying that the package meets the requirements of the ASF policy
   on releases."

   You can achieve the above by following [4].

   [ ]  +1 accept (indicate what you validated - e.g. performed the non-RM 
items in [4])
   [ ]  -1 reject (explanation required)


[1] https://repository.apache.org/content/repositories/orgapacheplc4x-1029
[2] 
https://dist.apache.org/repos/dist/dev/plc4x/build-tools/code-generation/1.3.0/rc1/
[3] https://www.apache.org/dev/release/validation.html#approving-a-release
[4] https://plc4x.apache.org/developers/release/validation.html