Variablen / Register / Array #V

Befehlsgruppe um interne Rechnungen und logische Operationen auszuführen. Mit Hilfe der Stringfiles kann eine Mehrsprachigkeit realisiert werden. Es sind 500 Register vorhanden. Stringregister können bis zu 250 Zeichen aufnehmen, bei Festkommaregistern wird mit signed 32 Bit, bei Fließkommaregistern wird mit 23 Bit Mantisse, 8 Bit Exponent, 1 Bit signed gerechnet.


Stringfiles / Mehrsprachigkeit

Stringfile laden

(Variable stringFile Load)

#VFL

StringfileName>

Stringfile löschen

(Variable stringFile Delete)

#VFD

<StringfileName> (alle)

Anzahl an geladenen Stringfiles senden

(Variable stringFile Count)

#VFC


Stringregister

Stringregister setzen

(Variable Stringregister Set)

#VSS

String-ID, "String"; "String" [ID+1]; ...

Stringregister ab Position setzen

(Variable Stringregister Postion)

#VSP

String-ID, Offset, "New String";

Stringregister ab Position ersetzen

(Variable Stringregister Replace)

#VSR

String-ID, Offset, "New String";

Teilstring aus Stringregister ausschneiden und ersetzen

(Variable Stringregister Truncate)

#VST

String-ID, Offset, Anzahl(bis Ende)

Teilstring aus Stringregister kopieren

(Variable Stringregister Copy)

#VSC

String-ID Ziel, String-ID Quelle, Offset (0), Anzahl(bis Ende)

Stringregister in Teilstrings aufteilen

(Variable Stringregister dElimiter)

#VSE

String-ID Ziel Start, String-ID Quelle, Seperator, Register-ID (=String-ID Ziel Start)

Stringregister mit Zeit/Datum setzen

(Variable Stringregister Date)

#VSD

String-ID, "Datumsformat"; date (aktuelle Zeit); 1/100sec

Formatiertes Stringregister setzen

(Variable Stringregister Formated)

#VSF

String-ID, "Formatstring"; Wert1, Wert2, ...., WertN

Objektsstrings auslesen

(Variable Stringregister Object)

#VSO

String-ID, Obj-ID, ...

Stringregister senden (ASCII)

(Variable string Send Ascii)

#VSA

String-ID, ...

Stringregister senden (Unicode)

(Variable string Send Unicode)

#VSU

String-ID, ...

Stringregister sortieren

(Variable Quicksort Strings)

#VQS

String-ID Start, String-ID Ende, Anzahl (0), Offset(0)

Codes im Stringregister sortieren

(Variable Quicksort Codes)

#VQC

String-ID, Richtung (1), Anzahl (0), Offset (0)

Letzte Fehlermeldung in Stringregister

(Variable Stringregister Last error)

#VSL

String-ID, Löschen(1)

Stringregister mischen

(Variable Mix Strings)

#VMS

String-ID Start, String-ID Ende

Codes im Stringregister mischen

(Variable Mix Codes)

#VMC

String-ID, Anzahl (0), Offset (0)

Definieren einer Regular expression

(Variable String regular eXpression)

#VSX

RegEx-ID, "regular expression"

Register

Register setzen (Integer)

(Variable Register Integer)

#VRI

Register-ID, Wert, Wert1 [ID+1], ...

Register setzen (Float)

(Variable Register Float)

#VRF

Register-ID, Wert, Wert1 [ID+1], ...

Objektstring umwandeln

(Variable Register Object)

#VRO

Register-ID, Obj-ID, Obj-ID1[ID+1], ...

Stringregister in Register umwandeln

(Variable Register dElimiter)

#VRE

Register-ID Start, String-ID Quelle, Seperator, Register-ID Anzahl

Register in RTC-RAM schreiben

(Variable Register rtc Write)

#VRW

ID, Register-ID, Register-ID1, ...

Register aus RTC-RAM lesen

(Variable Register rtc Read)

#VRR

ID, Register-ID, Register-ID1, ...

Stringregister als Kalkulation in Register umwandeln (Integer)

(Variable Calculate Integer)

#VCI

Register-ID, String-ID, String-ID1[ID+1], ...

Stringregister als Kalkulation in Register umwandeln (Float)

(Variable Calculate Float)

#VCF

Register-ID, String-ID, String-ID1[ID+1], ...

Register senden

(Variable Register Send)

#VRG

Register-ID, ...

Register sortieren

(Variable Quicksort Register)

#VQR

Register-ID Start, Register-ID Ende

Register mischen

(Variable Mix Register)

#VMR

Register-ID Start, Register-ID Ende

Array

Array definieren (Integer)

(Variable Array Integer)

#VAI

Array-ID, Anzahl, Typ(0)

Array definieren (Float)

(Variable Array Float)

#VAF

Array-ID, Anzahl, Typ(0)

Array definieren (Unicode String)

(Variable Array Unicode)

#VAU

Array-ID, Anzahl, Stringlänge, Typ(0)

Array löschen (Speicher freigeben)

(Variable Array Delete)

#VAD

Array-ID

Array füllen

(Variable Array Set)

#VAS

Array-ID, Wert(0, alle Elemente), element index, ...

Array-Elementen Werte zuweisen (mit Index)

(Variable Array Value)

#VAV

Array-ID, Index, Wert, Wert[Index+1], ...

Array-Elementen Werte zuweisen (mit aktuellem Schreib-Pointer)

(Variable Array Write)

#VAW

Array-ID, Wert 1, Wert 2, ...

Schreib- und/oder Lese-Pointer setzen

(Variable Array Pointer)

#VAP

Array-ID, SchreibPointer(-1), LesePointer(-1), max. SchreibPointer

Array sortieren

(Variable Quicksort Arrays)

#VQA

Array-ID, StartIndex, EndIndex(letzter Index), Stringlänge(0), Stringoffset(0)

Array mischen

(Variable Mix Arrays)

#VMA

Array-ID, StartIndex, EndIndex(letzter Index)

Stringfiles / Mehrsprachigkeit


Es werden in 4 unterschiedlichen Sprachen "Hallo World" platziert. Es muss darauf geachtet werden, dass der ausgewählte Font alle notwendigen Zeichen unterstützt. Im folgenden Beispiel wurde "Arial Unicode MS" eingesetzt. Die unten stehende Befehle setzten voraus, dass die Stringfiles (Chinese.txt, English.txt, Cyrillic.txt und German.txt) bereits auf der SD-Card im Projektpfad im Unterordner Strings vorhanden sind:

...

#VFL <P:string/German.txt>  

#SSP 1,1,10,10,7,!HELLO!;

#VFD  

#VFL <P:string/English.txt>  

#SSP 2,1,10,50,7,!HELLO!;

#VFD                      

#VFL <P:string/Cyrillic.txt>  

#SSP 3,1,10,90,7,!HELLO!;

#VFD  

#VFL <P:string/Chinese.txt>  

#SSP 4,1,10,130,7,!HELLO!;

#VFD  

...


Stringfile laden

#VFL

<StringfileName>

Einen Satz von Strings laden. Maximal können gleichzeitig 1000 Strings aus 8 verschiedenen Dateien geladen sein.


Stringfile löschen

#VFD

<StringfileName> (alle)

Einen Satz von Strings bzw. alle löschen. Die Dateien bleiben physikalisch auf der SD Karte erhalten, sodass sie erneut geladen werden können


Anzahl an geladenen Strings senden

#VFC

Stellt die Anzahl an geladenen Strings in den Sendepuffer. Die Rückmeldung ist folgendermaßen aufgebaut:

ESC

V

F

C

Anzahl

...


$1B

$56

$53

$43

16-Bit Wert

...

#VFL ...

#VFL ...

#VFL ...

#VFL ...

#VFC

...

Stringregister

Stringregister setzen

#VSS

String-ID, "String"; "String" [ID+1]; ...

Der Befehl speichert den String im Registersatz (String-ID [0...499]) ab.

String-ID

Wert

0

"Hello World"

1

"Test Hello World"

2

"Hello World Test"

...

#VSS 0,"Hello World";"Test "S0;S0" Test";

...


Stringregister ab Position setzen

#VSP

String-ID, Offset, "New String";

Der String der Speicherstelle String-ID wird ab der Postion Offset gelöscht und die neuen Daten ("New String") werden angefügt.

String-ID

Wert

0

"Hello Test"

1

...

2

...

...

#VSS 0,"Hello World";

#VSP 0,6,"Test";

...

Stringregister ab Position ersetzen

#VSR

String-ID, Offset, "New String";

Der String der Speicherstelle String-ID wird ab der Postion Offset mit den neuen Daten ("New String") ersetzt.

String-ID

Wert

0

"Hello Test "

1

...

2

...

...

#VSS 0,"Hello World";

#VSR 0,6,"Test ";

...

Teilstring aus Stringregister ausschneiden und verschieben (ab V1.1)

#VST

String-ID, Offset, Anzahl(bis Ende)

Den "linken" Teil des Stringregisters löschen und den Teil von Offset bis Offset+Anzahl nach vorne schieben. Ist Anzahl negativ, wird Anzahl als zweiter Offset genommen. Es handelt sich also dann um eine Bereichsangabe.

String-ID

Wert

0

"World"

1

...

2

...

...

#VSS 0,"Hello World";

#VST 0,6,5

...


...

#VSS 0,"Hello World";

#VST 0,6-10

...


Teilstring aus Stringregister kopieren (ab V1.1)

#VSC

String-ID Ziel, String-ID Quelle, Offset (0), Anzahl(bis Ende)

Aus dem String (String-ID Quelle) einen Teilstring beginnend mit dem Offset und der Länge Anzahl kopieren und in ein anderes Stringregister (String-ID Ziel) einfügen.

String-ID

Wert

0

"Hello World"

1

"World"

2

...

...

#VSS 0,"Hello World";

#VSC 1,0,6,5

...


...

#VSS 0,"Hello World";

#VSC 1,0,6-10

...


Stringregister in Teilstrings aufteilen (ab V1.1)

#VSE

String-ID Ziel Start, String-ID Quelle, Seperator, Register-ID (=String-ID Ziel Start)

Der String (String-ID Quelle) wird in Teilstrings zerlegt. Die Teilstrings werden ab String-ID Ziel Start abgelegt. Die Anzahl der Teilstrings wird in Register-ID abgelegt. Der Parameter Seperator gibt das Trennzeichen an.


String-ID

Wert

0

"Entry1,Entry2,Entry3"

1

"Entry1"

2

"Entry2"

3

"Entry3"


Register-ID

Wert

10

3

...

#VSS 0,"Entry1,Entry2,Entry3";

#VSE 1,0,?,,10

...


Stringregister mit Zeit/Datum setzen

#VSD

String-ID, "Datumsformat"; date (aktuelle Zeit); 1/100sec

Im Stringregister wird die Zeit als formatierter String abgelegt. Die Darstellungsweise richtet sich nach dem Datumsformat. Der Aufbau ist im Unterkapitel Datumsformate näher beschrieben.

String-ID

Wert

0

...

1

"14:59:30"

2

...

...

#VSD 1,"%h:%m:%s";

...

Formatiertes Stringregister setzen

#VSF

String-ID, "Formatstring"; Wert1, Wert2, ...., WertN

Eine formatierten Zeichenkette wird im Stringregister abgelegt (String-ID). Wird der Variablen Satz wiederholt, wird der Formatstring erneut angewendet und in String-ID+1 abgelegt

String-ID

Wert

0

...

1

"Analog 3420"

2

...

...

#VSF 1,"Analog %d";(analog(0))

...


Objektsstrings auslesen

#VSO

String-ID, Obj-ID, ...

Objektstrings (Obj-ID) werden im Stringregister (String-ID) abgelegt. Diese Funktion wird vor allem für EditBoxen verwendet.


String-ID

Wert

0

...

1

"edit me"

2

...

...

#SED 1,"edit me"     /**Default text for EditBox

#VSO 1,1

...

Stringregister senden (ASCII)

#VSA

String-ID, ...

Den Inhalt des Stringregisters (ASCII formatiert) in den Sendepuffer stellen. Die Rückmeldung ist folgendermaßen aufgebaut:

ESC

V

S

A

String-ID

Länge

Char 1

Char 2

...

Char n

...


$1B

$56

$53

$41

16-Bit Wert

16-Bit Wert

8-Bit Wert

8-Bit Wert

8-Bit Wert

8-Bit Wert



...

#VSS0,"str";

#VSA 0

...


Stringregister senden (Unicode)

#VSU

String-ID, ...

Den Inhalt des Stringregisters (Unicode formatiert) in den Sendepuffer stellen. Die Rückmeldung ist folgendermaßen aufgebaut:

ESC

V

S

U

String-ID

Länge

Char 1

Char 2

...

Char n

...

$1B

$56

$53

$55

16-Bit Wert

16-Bit Wert

16-Bit Wert

16-Bit Wert

16-Bit Wert

16-Bit Wert

...

#VSS0,"str";

#VSU 0

...

Stringregister sortieren (ab V1.1)

VQS

String-ID Start, String-ID Ende, Anzahl (0), Offset(0)

Der Bereich des Stringregisters (String-ID Start bis String-ID Ende) wird sortiert. Anzahl gibt den Bereich an, welcher für die Sortierung beachtet wird, bei Anzahl=0 wird die gesamte Länge untersucht. Offset gibt die Stelle im String an ab der die Sortierung beginnt.

String-ID

Wert davor

Wert danach

0

"Sort"

"Entry"

1

"Test"

"Exit"

2

"Entry"

"Sort"

3

"Exit"

"Test"

...

#VSS 0,"Sort";"Test";"Entry";"Exit";

#VQS 0,3,2,0

...


Codes im Stringregister sortieren (ab V1.1)

VQC

String-ID, Richtung (1), Anzahl (0), Offset (0)

Codes innerhalb des Stringregisters (String-ID) werden sortiert. Anzahl gibt den Bereich an, welcher für die Sortierung beachtet wird, bei Anzahl=0 wird die gesamte Länge untersucht. Offset gibt die Stelle im String an ab der die Sortierung beginnt. Zudem kann die Richtung angegeben werden:

Richtung

0

Absteigend

1

Aufsteigend

String-ID

Wert

0

...

1

" HWdellloor"

2

...

...

#VSS 1,"Hello World"

#VQC 1

...


Letzte Fehlermeldung in Stringregister (ab V1.3)

#VSL

String-ID, Löschen(1)

Die Fehlermeldungen aus dem Terminal zusätzlich in ein Stringregister (String-ID) speichern. Der Parameter Löschen gibt das Löschverhalten der Fehlermeldung an:

Löschen

0

Nicht löschen

1

Löschen


Stringregister mischen (ab V1.3)

#VMS

String-ID Start, String-ID Ende

Der Inhalt der Register bleibt bestehen, nur die String-ID ändert sich. Damit ist eine neue Zuordnung String-ID Inhalt vorhanden.


Codes im Stringregister mischen (ab V1.3)

#VMC

String-ID, Anzahl (0), Offset (0)

Der Inhalt eines Stringregister (String-ID) wird zufällig vertauscht.
Anzahl gibt die Anzahl der Stellen an (= 0 kompletter String), Offset den Startpunkt innerhalb des Registers.


Definieren einer  Regular expression (from V1.6)

#VSX

RegEx-ID, "regular expression"

Eine regular expression definieren und in RegEx-ID[0..9] speichern. Dieses Kommando arbeitet mit vielen Kalkulationen zusammen, um in StringRegistern oder StringArrays vorkommen des Ausdrucks zu finden.

...

#VAU 0, 14,24, 0 /**Definieren des UnicodeArrays

#VAW 0, "Alabama Slammer"; "Bloody Mary"; "Cosmopolitan"; "Fireball";

#VAW 0, "Kamikaze"; "Mai Tai"; "Mojito"; "Long Island Iced Tea"; "Pina Colada";

#VAW 0, "Gin Fizz"; "Jim Beam"; "Smirnoff"; "Tequila"; "Zombie"

#VSX 2, ".*am.*" /**RegEx in RegExp-ID 2 speichern

                /**Finde alle Vorkommnisse der Buchstabenkombination 'am'

#VRI 3, -1 /**Register R3 wird als Indexregister genutzt. Mit -1 laden, da =-1 kein vorkommen bedeutet

#MFM 1 /**Loop start

 #VRI 3, (strXA(2,0,++R3)) /**Kalkulation um naechsten Index mit wahrer RegEx zu finden.

                           /**Suchindex start bei letztem gefunden Resultat + 1

 #MFS (R3<0), 1 /**Naechste Zeile ueberspringen wenn kein Ergebnis mehr vorhanden ist

   #YPA A0I(R3) "\r\n" /**Ausgabe des ArrayString im Terminal window und neue Zeile einfuegen

#MFJ(R3>=0) 1 /**loop Ende,Zurueck zum Loop-Start wenn RegEx ein Ergebnis hatte ansonsten verlassen

...

Unterstützte RegEx Sonderzeichen:

^        String Anfang

$        String Ende

.        ein beliebiges Zeichen

a?        null- oder einmal der Ausdruck a , d.h. der Ausdruck ist optional

a+        mindestens einmal oder mehrfach der Ausdruck a

a*        beliebig oft (auch keinmal)

[ ]        Zeichenauswahl, z.B. [a-z]

[^ ]        nicht vorkommende Zeichenauswahl, z.B. [^a-f]

( )        RegEx Unterbereich max. 9

|        Oder

\        Sonderzeichen aufheben (normales Zeichen)


Register

Register setzen (Integer)

#VRI

Register-ID, Wert, Wert1 [ID+1], ...

Der Befehl speichert im Registersatz (Register-ID [0...499]) einen Integerwert (32 Bit).


Register-ID

Wert

0

10

1

42

2

-8

...

#VRI 0,10,42,-8

...


Register setzen (Float)

#VRF

Register-ID, Wert, Wert1 [ID+1], ...

Der Befehl speichert im Registersatz (Register-ID [0...499]) einen Floatwert (32 Bit).


Register-ID

Wert

0

10.25

1

42.39

2

-8.19

...

#VRF 0,10.25,42.39,-8.19

...


Objektstring umwandeln

#VRO

Register-ID, Obj-ID, Obj-ID1[ID+1], ...

Objektstrings werden in Register abgelegt. Der Objektstring wird dabei in einen Zahlenwert gewandelt (automatisch passend als Integer oder Float). Diese Funktion wird vor allem für EditBoxen verwendet.

Register-ID

Wert

0

...

1

42.5

2

...

...

#SED 1,"42.5"     /**Default text for EditBox

#VRO 1,1

...



Stringregister in Register umwandeln (ab V 1.2)

#VRE

Register-ID Start, String-ID Quelle, Seperator, Register-ID Anzahl

Numerischen String (String-ID Quelle) in Register (Register-ID Start) wandeln. Separator gibt das Trennzeichen zwischen den Werten an. Im optionalen Parameter Register-ID Anzahl wird die Anzahl gültiger Werte nach der Wandlung angegeben

Register-ID

Wert

0

10

1

42.39

2

-8

10

3

...

#VSS 0,"10,42.39,-8";

#VRE 0,0,?,,10

...


Register in RTC-RAM schreiben

#VRW

ID, Register-ID, Register-ID1, ...

Eine Register-ID im RAM der RTC puffern. ID [0...7] gibt den Speicherplatz an. Der Wert bleibt auch nach dem Ausschalten des Moduls erhalten.


Register aus RTC-RAM lesen

#VRR

ID, Register-ID, Register-ID1, ...

Aus dem RTC-RAM (ID) einen Wert zurück lesen und in Register (Register-ID) übernehmen


Stringregister als Kalkulation in Register umwandeln (Integer)

#VCI

Register-ID, String-ID, String-ID1[ID+1], ...

Den Inhalt eines Stringregisters als Kalkulationsstring interpretieren. Das Ergebnis wird im Register (Register-ID) abgelegt

Register-ID

Wert

0

-8

1

50

2

42

...

#VSS 0,"R0+R1";

#VCI 2,0

...


Stringregister als Kalkulation in Register umwandeln (Float)

#VCF

Register-ID, String-ID, String-ID1[ID+1], ...

Den Inhalt eines Stringregisters als Kalkulationsstring interpretieren. Das Ergebnis wird im Register (Register-ID) abgelegt

Register-ID

Wert

0

-8.21

1

50.89

2

42.68

...

#VSS 0,"R0+R1";

#VCF 2,0

...


Register senden

#VRG

Register-ID, ...

Den Inhalt des Registers in den Sendepuffer stellen. Die Rückmeldung ist folgendermaßen aufgebaut:

ESC

V

R

G

Register-ID

Typ

Wert

...


$1B

$56

$52

$47

16-Bit Wert

16-Bit Wert

32-Bit Wert

...

#VRF 0,...

#VRG 0

...


Register sortieren (ab V1.1)

#VQR

Register-ID Start, Register-ID Ende

Der Bereich der Register (Register-ID Start bis Register-ID Ende) werden sortiert.

Register-ID

Wert davor

Wert danach

0

2

-5

1

8

2

2

4

4

3

-5

8

...

#VRI 0,2,8,4,-5

#VQR 0,3

...


Register mischen (ab V1.3)

#VMR

Register-ID Start, Register-ID Ende

Der Inhalt der Register bleibt bestehen, nur die Register-ID ändert sich. Damit ist eine neue Zuordnung Register-ID Inhalt vorhanden.


Array (ab V1.4)

Array definieren (Integer)

#VAI

Array-ID, Anzahl, Typ(0)

Der Befehl definiert ein Integer Array (Array-ID  [0...499]) mit der gegebenen Anzahl an Einträgen. Die maximale Länge des Arrays bzw. ob das Arrays mit der gewünschten Größe angelegt werden konnte kann mit der Kalkulation arE() überprüft werden. Der Typ gibt das Verhalten beim Schreiben am Ende des Arrays an.

Typ

0

Am Ende abbrechen

1

Am Ende umbrechen (Ringbuffer)



Array definieren (Float)

#VAF

Array-ID, Anzahl, Typ

Der Befehl definiert ein Float Array (Array-ID  [0...499]) mit der gegebenen Anzahl an Einträgen. Die maximale Länge des Arrays bzw. ob das Arrays mit der gewünschten Größe angelegt werden konnte kann mit der Kalkulation arE() überprüft werden. Der Typ gibt das Verhalten beim Schreiben am Ende des Arrays an.

Typ

0

Am Ende abbrechen

1

Am Ende umbrechen (Ringbuffer)


Array definieren (Unicode String) (ab V1.6)

#VAU

Array-ID, Anzahl, Stringlänge, Typ(0)

Der Befehl definiert ein String Array (Array-ID  [0...499]) mit der gegebenen Anzahl an Einträgen. Die maximale Länge des Arrays bzw. ob das Arrays mit der gewünschten Größe angelegt werden konnte kann mit der Kalkulation arE() überprüft werden. Der Parameter Stringlänge gibt die maximale Stringlänge pro Eintrag an. Der Typ gibt das Verhalten beim Schreiben am Ende des Arrays an.

Typ

0

Am Ende abbrechen

1

Am Ende umbrechen (Ringbuffer)



Array löschen (Speicher freigeben)

#VAD

Array-ID

Der Befehl löscht ein Array (Array-ID  [0...499]) und gibt den Speicher frei.


Array füllen

#VAS

Array-ID, Wert(0), element index, ...

Der Befehl füllt alle Elemente des Arrays (Array-ID  [0...499]) mit dem gegeben Wert. Ist kein Wert angegeben wird das komplette Array gefüllt. Element index ermöglicht das füllen bestimmter Elemente des Arrays mit dem angegebenen Wert.


Array-Elementen Werte zuweisen (mit Index)

#VAV

Array-ID, Index, Wert, Wert[Index+1], ...

Der Befehl weist Array-Elementen, beginnend mit dem Array-Index neue Werte zu.


Array-Elementen Werte zuweisen (mit aktuellem Schreib-Pointer)

#VAW

Array-ID, Wert 1, Wert 2, ...

Der Befehl weist Array-Elementen, beginnend mit dem aktuellen Schreib-Pointer neue Werte zu.


Schreib- und/oder Lese-Pointer setzen

#VAP

Array-ID, SchreibPointer(-1), LesePointer(-1), max. SchreibPointer

Der Befehl setzt den Schreib- und/oder Lese-Pointer des Arrays (Array-ID  [0...499]). Soll der Pointer unverändert bleiben muss der jeweilige Parameter auf -1 gesetzt werden.


Array sortieren

#VQA

Array-ID, StartIndex, EndIndex(letzter Index), Stringlänge(0), Stringoffset(0)

Die Werte des Arrays (Array-ID  [0...499]) werden im angegebenen Bereich (StartIndex bis EndIndex) sortiert. Die letzten beiden Parameter Stringlänge und Stringoffset werden nur verwendet wenn es sich um ein Stringarray (#VAU). Stringlänge (gesamt =0) gibt die Anzahl der Zeichen an, der Stringoffset die Zeichenposition die für die Sortierung beachtet werden sollen.


Array mischen

#VMA

Array-ID, StartIndex, EndIndex(letzter Index)

Der Befehl mischt die Werte des Arrays im angegebenen Bereich (StartIndex bis EndIndex). Die Werte bleiben dabei unverändert. Nur die Reihenfolge (Indexes) wird angepasst. Damit ist eine neue Zuordnung der Array-Indexes Werte vorhanden....