Questa funzione esegue il trasferimento tra un array di bytes il cui indirizzo è indicato in Source e la variabile di destinazione Destination di tipo Type. In base alla impostazione di Endiannes l’array può essere little endian (LSB-MSB) o big endian (MSB-LSB).
Se endianness definito è lo stesso del sistema che esegue la funzione viene eseguita una copia del valore tra la sorgente e la destinazione. Se endianness diverso viene eseguita la conversione.
Il trasferimento tra sorgente e destinazione è atomico quindi la funzione può operare sulla stessa area di memoria e può trasferire variabili di dimensione maggiori ai bits gestiti dal sistema tra tasks di esecuzione diverse.
Sostituisce “LEArrayToVar”
A causa di un BUG la funzione LEArrayToVar eseguiva la conversione di un array big endian, quindi per sostituirla occorre impostare Endiannes:=TRUE.
PROGRAM ST_LEArrayToVarReplacement
VAR
AValue : ARRAY[0..3] OF BYTE := [16#12,16#34,16#56,16#78]; (* Big endian array value *)
WValue : ARRAY[0..3] OF WORD; (* Word value *)
DValue : ARRAY[0..1] OF DWORD; (* Double value *)
CSts : ARRAY[0..5] OF BOOL; (* Conversion status *)
END_VAR
// *****************************************************************************
// PROGRAM "ST_LEArrayToVarReplacement"
// *****************************************************************************
// This program shows how to replace the "LEArrayToVar" function.
// -----------------------------------------------------------------------------
// -------------------------------------------------------------------------
// "LEArrayToVar" EXAMPLE
// -------------------------------------------------------------------------
CSts[0]:=LEArrayToVar(VR_TYPE#WORD_TYPE, ADR(WValue[0]), ADR(AValue)); //WValue[0]:16#1234
CSts[1]:=LEArrayToVar(VR_TYPE#WORD_TYPE, ADR(WValue[1]), ADR(AValue)+2); //WValue[1]:16#5678
CSts[2]:=LEArrayToVar(VR_TYPE#DWORD_TYPE, ADR(DValue[0]), ADR(AValue)); //DValue[0]:16#12345678
// -------------------------------------------------------------------------
// "ArrayVarTxfer" EXAMPLE
// -------------------------------------------------------------------------
CSts[3]:=ArrayVarTxfer(TRUE, VR_TYPE#WORD_TYPE, ADR(WValue[2]), ADR(AValue)); //WValue[2]:16#1234
CSts[4]:=ArrayVarTxfer(TRUE, VR_TYPE#WORD_TYPE, ADR(WValue[3]), ADR(AValue)+2); //WValue[3]:16#5678
CSts[5]:=ArrayVarTxfer(TRUE, VR_TYPE#DWORD_TYPE, ADR(DValue[1]), ADR(AValue)); //DValue[1]:16#12345678
// [End of file]Sostituisce “BEArrayToVar”
A causa di un BUG la funzione BEArrayToVar eseguiva la conversione di un array little endian, quindi per sostituirla occorre impostare Endiannes:=FALSE.
PROGRAM ST_BEArrayToVarReplacement
VAR
AValue : ARRAY[0..3] OF BYTE := [16#78,16#56,16#34,16#12]; (* Little endian array value *)
WValue : ARRAY[0..3] OF WORD; (* Word value *)
DValue : ARRAY[0..1] OF DWORD; (* Double value *)
CSts : ARRAY[0..5] OF BOOL; (* Conversion status *)
END_VAR
// *****************************************************************************
// PROGRAM "ST_BEArrayToVarReplacement"
// *****************************************************************************
// This program shows how to replace the "BEArrayToVar" function.
// -----------------------------------------------------------------------------
// -------------------------------------------------------------------------
// "BEArrayToVar" EXAMPLE
// -------------------------------------------------------------------------
CSts[0]:=BEArrayToVar(VR_TYPE#WORD_TYPE, ADR(WValue[0]), ADR(AValue)+2); //WValue[0]:16#1234
CSts[1]:=BEArrayToVar(VR_TYPE#WORD_TYPE, ADR(WValue[1]), ADR(AValue)); //WValue[1]:16#5678
CSts[2]:=BEArrayToVar(VR_TYPE#DWORD_TYPE, ADR(DValue[0]), ADR(AValue)); //DValue[0]:16#12345678
// -------------------------------------------------------------------------
// "ArrayVarTxfer" EXAMPLE
// -------------------------------------------------------------------------
CSts[3]:=ArrayVarTxfer(FALSE, VR_TYPE#WORD_TYPE, ADR(WValue[2]), ADR(AValue)+2); //WValue[2]:16#1234
CSts[4]:=ArrayVarTxfer(FALSE, VR_TYPE#WORD_TYPE, ADR(WValue[3]), ADR(AValue)); //WValue[3]:16#5678
CSts[5]:=ArrayVarTxfer(FALSE, VR_TYPE#DWORD_TYPE, ADR(DValue[1]), ADR(AValue)); //DValue[1]:16#12345678
// [End of file]Sostituisce “VarToLEArray”
A causa di un BUG la funzione VarToLEArray eseguiva la conversione di un array big endian, quindi per sostituirla occorre impostare Endiannes:=TRUE.
PROGRAM ST_VarToLEArrayReplacement
VAR
WValue : ARRAY[0..1] OF WORD := [16#1234,16#5678]; (* Word value *)
DValue : DWORD := 16#12345678; (* Double value *)
AValue : ARRAY[0..15] OF BYTE; (* Array value *)
CSts : ARRAY[0..5] OF BOOL; (* Conversion status *)
END_VAR
// *****************************************************************************
// PROGRAM "ST_VarToLEArrayReplacement"
// *****************************************************************************
// This program shows how to replace the "VarToLEArray" function.
// -----------------------------------------------------------------------------
// -------------------------------------------------------------------------
// "VarToLEArray" EXAMPLE
// -------------------------------------------------------------------------
CSts[0]:=VarToLEArray(WORD_TYPE, ADR(AValue), ADR(WValue[0])); //AValue:1234
CSts[1]:=VarToLEArray(WORD_TYPE, ADR(AValue)+2, ADR(WValue[1])); //AValue:12345678
CSts[2]:=VarToLEArray(DWORD_TYPE, ADR(AValue)+4, ADR(DValue)); //AValue:12345678, 12345678
// -------------------------------------------------------------------------
// "ArrayVarTxfer" EXAMPLE
// -------------------------------------------------------------------------
CSts[3]:=ArrayVarTxfer(TRUE, VR_TYPE#WORD_TYPE, ADR(AValue)+8, ADR(WValue[0])); //AValue:12345678, 12345678, 1234
CSts[4]:=ArrayVarTxfer(TRUE, VR_TYPE#WORD_TYPE, ADR(AValue)+10, ADR(WValue[1])); //AValue:12345678, 12345678, 12345678
CSts[5]:=ArrayVarTxfer(TRUE, VR_TYPE#DWORD_TYPE, ADR(AValue)+12, ADR(DValue)); //AValue:12345678, 12345678, 12345678, 12345678
// [End of file]Sostituisce “VarToBEArray”
A causa di un BUG la funzione VarToBEArray eseguiva la conversione di un array little endian, quindi per sostituirla occorre impostare Endiannes:=FALSE.
PROGRAM ST_VarToBEArrayReplacement
VAR
AValue : ARRAY[0..15] OF BYTE; (* Array value *)
WValue : ARRAY[0..1] OF WORD := [16#1234,16#5678]; (* Word value *)
DValue : DWORD := 16#12345678; (* Double value *)
CSts : ARRAY[0..5] OF BOOL; (* Conversion status *)
END_VAR
// *****************************************************************************
// PROGRAM "ST_VarToBEArrayReplacement"
// *****************************************************************************
// This program shows how to replace the "VarToBEArray" function.
// -----------------------------------------------------------------------------
// -------------------------------------------------------------------------
// "VarToBEArray" EXAMPLE
// -------------------------------------------------------------------------
CSts[0]:=VarToBEArray(WORD_TYPE, ADR(AValue)+2, ADR(WValue[0])); //AValue:00003412
CSts[1]:=VarToBEArray(WORD_TYPE, ADR(AValue), ADR(WValue[1])); //AValue:78563412
CSts[2]:=VarToBEArray(DWORD_TYPE, ADR(AValue)+4, ADR(DValue)); //AValue:78563412, 78563412
// -------------------------------------------------------------------------
// "ArrayVarTxfer" EXAMPLE
// -------------------------------------------------------------------------
CSts[3]:=ArrayVarTxfer(FALSE, VR_TYPE#WORD_TYPE, ADR(AValue)+10, ADR(WValue[0])); //AValue:78563412, 78563412, 00003412
CSts[4]:=ArrayVarTxfer(FALSE, VR_TYPE#WORD_TYPE, ADR(AValue)+8, ADR(WValue[1])); //AValue:78563412, 78563412, 78563412
CSts[5]:=ArrayVarTxfer(FALSE, VR_TYPE#DWORD_TYPE, ADR(AValue)+12, ADR(DValue)); //AValue:78563412, 78563412, 78563412, 78563412
// [End of file]Funzione
CODESYS: Non disponibile
LogicLab: eLLabCommonLib
Descrizione
Endiannes (BOOL) Definizione endiannes array. FALSE:Little endian, TRUE:Big endian.
Type (VR_TYPE) Tipo di variabile destinazione.
Destination (PVOID) Indirizzo variabile di destinazione.
Source (PVOID) Indirizzo array sorgente.
La funzione ritorna una variabile BOOL con lo stato della conversione, FALSE: Errore tipo dati, TRUE: Conversione eseguita.
Esempi
Come utilizzare gli esempi.
Nell’esempio viene acquisito il valore da un array little endian e da un array big endian, ed i valori acquisiti sono trasferiti in variabili WORD che avranno valore 16#1234, variabili DWORD che avranno valore 16#12345678 e variabili LWORD che avranno valore 16#123456789ABCDEF.
LogicLab (Ptp201, ST_ArrayVarTxfer)
PROGRAM ST_ArrayVarTxfer
VAR
SLEArray : ARRAY[0..7] OF BYTE := [16#EF, 16#CD, 16#AB, 16#89, 16#67,16#45,16#23,16#01]; (* Source little endian array *)
SBEArray : ARRAY[0..7] OF BYTE := [16#01,16#23,16#45,16#67, 16#89, 16#AB, 16#CD, 16#EF]; (* Sourrce big endian array *)
WValue : ARRAY[0..1] OF WORD; (* Word value *)
DValue : ARRAY[0..1] OF DWORD; (* Double value *)
CSts : ARRAY[0..11] OF BOOL; (* Conversion status *)
WLEArray : ARRAY[0..1] OF BYTE; (* Word little endian array *)
LValue : ARRAY[0..1] OF LWORD; (* Long word value *)
WBEArray : ARRAY[0..1] OF BYTE; (* Word big endian array *)
DBEArray : ARRAY[0..3] OF BYTE; (* Double big endian array *)
DLEArray : ARRAY[0..3] OF BYTE; (* Double little endian array *)
LBEArray : ARRAY[0..7] OF BYTE; (* Long big endian array *)
LLEArray : ARRAY[0..7] OF BYTE; (* Long little endian array *)
END_VAR
// *****************************************************************************
// PROGRAM "ST_ArrayVarTxfer"
// *****************************************************************************
// This program shows the use of "ArrayVarTxfer" function.
// -----------------------------------------------------------------------------
// -------------------------------------------------------------------------
// ARRAY TO VAR CONVERSION
// -------------------------------------------------------------------------
// Little endian array conversion
CSts[0]:=ArrayVarTxfer(FALSE, WORD_TYPE, ADR(WValue[0]), ADR(SLEArray)+6); //Value 16#0123
CSts[1]:=ArrayVarTxfer(FALSE, DWORD_TYPE, ADR(DValue[0]), ADR(SLEArray)+4); //Value 16#01234567
CSts[2]:=ArrayVarTxfer(FALSE, LWORD_TYPE, ADR(LValue[0]), ADR(SLEArray)); //Value 16#0123456789ABCDEF
// Big endian array conversion
CSts[3]:=ArrayVarTxfer(TRUE, WORD_TYPE, ADR(WValue[1]), ADR(SBEArray)); //Value 16#0123
CSts[4]:=ArrayVarTxfer(TRUE, DWORD_TYPE, ADR(DValue[1]), ADR(SBEArray)); //Value 16#01234567
CSts[5]:=ArrayVarTxfer(TRUE, LWORD_TYPE, ADR(LValue[1]), ADR(SBEArray)); //Value 16#0123456789ABCDEF
// -------------------------------------------------------------------------
// VAR TO ARRAY CONVERSION
// -------------------------------------------------------------------------
// Little endian array conversion
CSts[6]:=ArrayVarTxfer(FALSE, WORD_TYPE, ADR(WLEArray), ADR(WValue[0])); //Value [16#23,16#01]
CSts[7]:=ArrayVarTxfer(FALSE, DWORD_TYPE, ADR(DLEArray), ADR(DValue[0])); //Value [16#67,16#45,16#23,16#01]
CSts[8]:=ArrayVarTxfer(FALSE, LWORD_TYPE, ADR(LLEArray), ADR(LValue[0])); //Value [16#EF, 16#CD, 16#AB, 16#89, 16#67,16#45,16#23,16#01]
// Big endian array conversion
CSts[9]:=ArrayVarTxfer(TRUE, WORD_TYPE, ADR(WBEArray), ADR(WValue[0])); //Value [16#01,16#23]
CSts[10]:=ArrayVarTxfer(TRUE, DWORD_TYPE, ADR(DBEArray), ADR(DValue[1])); //Value [16#01,16#23,16#45,16#67]
CSts[11]:=ArrayVarTxfer(TRUE, LWORD_TYPE, ADR(LBEArray), ADR(LValue[1])); //Value [16#01,16#23,16#45,16#67, 16#89, 16#AB, 16#CD, 16#EF]
// [End of file]