Deeper nesting for indirect addressing

[plcnut]

I don't know how much trouble it would be, but I could sure use another layer of indirect addressing in the result field for the MATH instruction. For now I am using a MOVE instruction before the MATH instruction. It is part of a FIFO.

[franji1]

Please provide example.  Do you mean
R[N[V10]]
or do you want to index the various tables indirectly, and the index (see REFWRITE for this capability)

[Controls Guy]

My guess is he wants the first thing.  I know in the Control Logix for example you can't do ThisArray[ThatArray[5]], so you have to do it in two steps and preload a scratch variable and it's an ugly kludge and it's very annoying.

[plcnut]

I was looking for: MATH Result ArrayOne[MyIndex[V1]]
Right now I had to: MOVE from MyIndex[V1] to V2
Then I could do: MATH result ArrayOne[V2]
It is a little clunky but it works.

[BobO]

Don't know if it is helpful or relevant, but remember that we can do displaced references: array[index + displacement] where displacement can be 1 to 31.

[franji1]

Don't know if it is helpful or relevant, but remember that we can do displaced references: array[index + displacement] where displacement can be 1 to 31.

1..63, e.g. R[V10 + 63] as ANY input or output parameter whenever it takes an element reference, e.g. contact, coil, TMR preset, etc., not just inside MATH.

[ATU]

On a similar note, will you be able use arrays for user defined Data types? If so can you have Arrays defined in the data type?

[plcnut]

Don't know if it is helpful or relevant, but remember that we can do displaced references: array[index + displacement] where displacement can be 1 to 31.

Can the "displacement" be a variable?
(I'm not where I can try it in the software right now)

[franji1]

On a similar note, will you be able use arrays for user defined Data types? If so can you have Arrays defined in the data type?

ALL data-blocks are available to be arrays.  This includes user defined data-blocks.

So basically, if there is a number suffix as the ID, you can replace the ID with [Vnnnn] Vnnn register is the array index.
X[V11]  // if V11 equals 32, then this would reference X32
R[V22+17]  // if V22 is 3, then this would reference R20 (3 + 17)
T[V10].Acc  // yes, structure field reference (e.g. V10 is 99, this would reference T99.Acc)
D[V8+4]:0  // even casts (e.g. V8 is 42, this would reference the LSBit of D46 (42+4)

The one limitation on the array index is that it MUST be a V data type, which is an UNSIGNED INT with a range of 0..65535.  You cannot declare something else to be an array index EXCEPT in a MATH expression, which allows for ANY mathematical expression to be an array index (e.g. Y[SQRT(R2)], so when R2 is 81, this would reference Y9).

[franji1]

Can the "displacement" be a variable?

Only inside a MATH expression, where it can be ANY math expression like R[CT6.Acc + WX[CT[V22+5].Acc]]

[BobO]

Don't know if it is helpful or relevant, but remember that we can do displaced references: array[index + displacement] where displacement can be 1 to 31.

1..63, e.g. R[V10 + 63] as ANY input or output parameter whenever it takes an element reference, e.g. contact, coil, TMR preset, etc., not just inside MATH.

I have 5 bits stuck in the brain...this is probably the 3rd time I've done this...:sigh: Yes, 1 to 63.

[plcnut]

Can the "displacement" be a variable?

Only inside a MATH expression, where it can be ANY math expression like R[CT6.Acc + WX[CT[V22+5].Acc]]

I don't think that will help me then. But I will look things over again this afternoon.

[ATU]

Sorry, I didn't ask the right question. 

When you have the capability to add user defined structures, will you have the ability to have arrays in the structures and make arrays of the structures and be able to specify variables for both the indices of the main array and the elements in the arrays located in structure?

For instance. A user defined data structure called PN consisting of:

strName                string
bSwitchData[128]       Boolean
intRecipe[100]         integer


so create an array of type PN called PartNumber[1000]


Would you be able to access the element in this way:  PartNumber[V200].intRecipe[V35]

[franji1]

No.  Our data structures will just allow simple data types (e.g. BIT, UNSIGNED BYTE, REAL, etc.)

[Controls Guy]

No.  Our data structures will just allow simple data types (e.g. BIT, UNSIGNED BYTE, REAL, etc.)

In that case let me put in a strong request for that capability in some future revision.  I definitely use arrays inside user defined types.

I also frequently create fundamental low level UDT's and nest them inside higher level ones, sometimes up to three levels deep, which sounds like it's out of bounds for the current concept as well.  It's a very useful ability to have, if you guys would be willing to do it.