Copy UDT variable from/to array of UDT variables

This is a SCL source for copy UDT variable into an array of UDT elements of same type.

I would like if smiffytakes a look, if I have done something wrong.

Part of this program is copied from other post:

/tf/WW/en/Posts/71210#506807

[code]

TYPE UDT98
TITLE = DISSASEMBLED ANYPOINTER
STRUCT
S7Code : BYTE; // Code for S7 = 0x10
DataType : BYTE; // Code for data type = 0x02 = byte
Length : INT; // Repetition factor = Send/receive length
DBNumber : INT; // Data block Number
AreaPointer : DWORD; // address
END_STRUCT
END_TYPE

FUNCTION FC98 : INT

VAR_INPUT
Array_2_Element: BOOL; //0=copy element to array[index], 1=copy array[index] to element
ArrayIndex : INT;
UDT_Element : ANY; // Pointer to array area 1
UDT_Array : ANY; // Pointer to array area 2
END_VAR

VAR_TEMP
pARR1 : ANY; // Pointer for ARRAY data no.1
ArrAny1 AT pARR1 : UDT98; // ANY pointer data structure
pARR2 : ANY; // Pointer for ARRAY data no.2
ArrAny2 AT pARR1 : UDT98; // ANY pointer data structure
IncSize : DINT ; // Address increment size based of data type
RetVal : INT; // BLK_MOV return value for comparison value no.1
Address : DWORD;
AreaPointer : DWORD;
MemoryArea : DWORD;
END_VAR

CONST
DT_BOOL := 01;
DT_BYTE := 02;
DT_CHAR := 03;
DT_WORD := 04;
DT_INT := 05;
DT_DWORD := 06;
DT_DINT := 07;
DT_REAL := 08;
END_CONST

BEGIN
// Setup ANY pointers to the ARRAYS
pARR1 := UDT_Element;
pARR2 := UDT_Array;

IF BYTE_TO_INT(ArrAny1.DataType) >= DT_BOOL AND BYTE_TO_INT(ArrAny1.DataType) <= DT_REAL THEN
// Determine data type and take appropriate action for each

ArrAny2.DataType := ArrAny1.DataType; //equalize data type and length of array element to single element
ArrAny2.Length := ArrAny1.Length;
IncSize:=ArrayIndex*ArrAny1.Length;

AreaPointer:=ArrAny2.AreaPointer ;
Address:= AreaPointer AND 16#00FFFFFF;
MemoryArea:= AreaPointer AND 16#FF000000;

CASE BYTE_TO_INT(ArrAny1.DataType) OF

DT_BYTE, DT_CHAR:
IncSize := IncSize*8;

DT_WORD, DT_INT:
IncSize := IncSize*16;

DT_DWORD, DT_DINT, DT_REAL:
IncSize := ArrayIndex*32;
END_CASE;

Address := DINT_TO_DWORD(DWORD_TO_DINT(Address) + IncSize); // compute begining address of array[index]
Address := Address AND 16#00FFFFFF;
ArrAny2.AreaPointer := Address OR MemoryArea;

IF Array_2_Element THEN

RetVal := BLKMOV(SRCBLK := pARR2, DSTBLK := pARR1); //copy from array[index] to UDT Element
ELSE
RetVal := BLKMOV(SRCBLK := pARR1, DSTBLK := pARR2); //copy from UDT Element to array[index]
END_IF;
END_IF;

FC98 := RetVal;

END_FUNCTION

[/code]

Thank you for your reply.

1,2,3) UDT_Element is a kind of active/in use recipe, UDT_Array is kind of stored recipes. All of them should use equal UDT. Its more likely that pointer passed from UDT_Element is "more secure" to geta type and the length of record of this type. Basicaly it doesn't matter what kind of type, just that product type * length gives the exactsize of record.

4) - yes it's a mistake, should be IncSize:=IncSize*32, not ArrayIndex.

5I don't understand about S7_string, never heard about that, but yes I was thinking how to make more user friendly, since had to think twice before I could properly set this bit when calling the function. I will check this S7_string.

Another bug is related to your initial code:

ArrAny2ATpARR1, should be ArrAny2ATpARR2

Anyway I have learned a new feature, you can have more AT instructions for the same variable.

Regards, Marko.

Hello,

Please, how to do it in the other direction, i mean copy an element from array (of UDT) to a Variable type UDT.

Thanks