MoveResolvedSymbolsToBuffer: Read values from resolved symbols and write them into buffer (S7-1500) - STEP 7

Description

With the "Read values from resolved symbols and write them into buffer" instruction, you read values from several resolved symbols and write them into a memory area (Array of BYTE). In this way, you can prepare values of resolved symbols for further use, such as sending using communication instructions, e.g. TSEND.

The "src" parameter is an Array of ResolvedSymbol (SDT). It contains references to tags that were previously resolved with the instruction "ResolveSymbols". At the parameter "dst", specify an Array of BYTE. It serves as a target buffer to which the tag values are written. The two arrays must have the same limits.

Use the parameters "firstIndex" and "lastIndex" to restrict the list of values that are to be copied during this call of the instruction. During a later call, you can copy the values of other resolved symbols. If you do not wish to restrict the list, the value at the "firstIndex" parameter must correspond to the low limit of the list and the value at the "lastIndex" parameter must correspond to the high limit of the list.

The value at the "mode" parameter defines the memory format at the "dst" parameter.

With offsets, you determine where the values of the resolved symbols are stored in the destination buffer. You specify the offsets at the "dstOffsets" (Array of DINT) parameter. Each offset is a bit offset and determines the first bit from which the value is written to the buffer. You can store several values of the BOOL data type in one byte. Values of all other data types must start at a bit position divisible by 8.

If the "src[i]" parameter references a tag of the REAL data type, the value at the "dstOffsets[i]" parameter is 88 and 2#1 at the "mode" parameter, for example, then the "Read values from resolved symbols and write them into buffer" instruction copies the value into the bytes 11 to 14, starting with the least significant byte.

If the "src[i]" parameter references a tag of the BOOL data type and the value at the "dstOffsets[i]" parameter is 29, for example, then the "Read values from resolved symbols and write them into buffer" instruction copies the value into byte 3, offset 5 of the destination memory.

The arrays at "dstOffsets" and "src" must have the same limits to ensure that "dstOffsets[i]" contains the offset for "src[i]".

This way, you can define the structure of the target buffer very specifically. However, note that the instruction does not verify whether the specified offsets overlap. An error is not signaled in this case and the content of the target buffer is indeterminate.

The content of the target buffer also depends on whether the values are read from an optimized or non-optimized memory area. Both memory areas have different rules for fill bytes. For more information on fill bytes, refer to "See also".

The "status" parameter is an Array of INT. It must have the same limits as the "src" and "dstOffsets" parameters to ensure that "status[i]" contains the status for "src[i]".

For WSTRING and STRING, the current length of the source string is copied. If the source string is shorter than the destination string, the remaining characters of the destination string remain unchanged.

Note Invalid references in the SDT "ResolvedSymbol" The references in the SDT "ResolvedSymbol" can become invalid when the referenced tags are overwritten by loading in "RUN". The references may point to tags that no longer exist. An error code at the "status" parameter indicates invalid references. In this case, resolve the symbols again with the instruction "ResolveSymbols".

Parameters

The following table shows the parameters of the "Read values from resolved symbols and write them into buffer" instruction:

You can find additional information on SDT here: System data type ResolvedSymbol

Status parameter

The following table shows the meaning of the values of the Status[i] parameter:

RET_VAL parameter

The following table shows the meaning of the values of the RET_VAL parameter:

Example

The following example shows how the instruction works:

The following table shows how the instruction works using specific operand values:

The values of the resolved symbols in the array "Input_ResolvedSymbols" are written in Big-Endian format to the target buffer "#InOut_Buffer" at the "dst" parameter.

Using the two constants at the "firstIndex" and "lastIndex" parameters, you restrict the number of tags whose values are to be copied.

The operand "Input_Offset" contains an offset for each value to be written. Based on the offset, it is determined where the value of the resolved symbol is written in the target buffer.