Array in kleinere Arrays stückeln

[BenWolf]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo,

ich möchte aus einem großen Array kleinere Arrays machen.
Also zB:

GrossesArray        : ARRAY [1..16] OF BYTE;
KleineArray1        : ARRAY [1..8] OF BYTE;
KleineArray2        : ARRAY [1..8] OF BYTE;

Jetzt soll das KleineArray1 die Daten von GrossesArray[1..8] haben und das KleineArray2 die Daten von grossesArray[9..16]

Vielen Dank für eure Hilfe

 

[Hendrik]

for i := 1 to 8 by 1 do
KleineArray1[i] :=      GrossesArray[i];
END_FOR;
a := 1;
FOR i := 9 TO 16 by 1 do
KleineArray1[a] :=      GrossesArray[i];
a := a + 1;
END_FOR;

so in etwa =)

 

[BenWolf]

Zuviel Werbung?
-> Hier kostenlos registrieren

for i := 1 to 8 by 1 do
KleineArray1[i] :=      GrossesArray[i];
END_FOR;
a := 1;
FOR i := 9 TO 16 by 1 do
KleineArray1[a] :=      GrossesArray[i];
a := a + 1;
END_FOR;

so in etwa =)

Geht das auch irgendwie mit Pointern oder so was?
Mein grosses Array ist wirklich groß und die Daten darin haben nicht den gleichen Datentyp wie die Zielarrays

 

[PN/DP]

Mein grosses Array ist wirklich groß und die Daten darin haben nicht den gleichen Datentyp wie die Zielarrays

Nur durch zerstückeln oder umkopieren von Array-Teilen ändert sich nicht der Datentyp. Wie genau sieht die Deklaration Deines großen Arrays und der gewünschten kleineren Arrays aus?

Harald

 

[MFreiberger]

Moin BenWolf,

Geht das auch irgendwie mit Pointern oder so was?
Mein grosses Array ist wirklich groß und die Daten darin haben nicht den gleichen Datentyp wie die Zielarrays

Wenn die Datentypen nicht gleich sind, ist das ja nicht einfach ein "zerstückeln" des Arrays. Man muss auch Datentypen konvertieren. Dazu muss man erstmal wissen, wie ein Array-Element des großen und des kleinen Arrays aussieht.

Deine Angabe sah eher so aus, dass es nur darum geht das große Array in kleine Arrays mit jeweils 8 Elementen vom Datentyp Byte zu übertragen. Dazu muss allerdings auch sichergestellt sein, dass das große Array eine Anzahl an Elementen hat, die man glatt durch 8 teilen kann. Oder man spielt etwas mit dem Auslesen der Array-Größe rum.

Egal wie, wir brauchen detailliertere Informationen:
- Arraygrößen (Quell- und Ziellarrays)
- Datentypen der Arrayelemente

VG

MFreiberger

 

[Larry Laffer]

Zuviel Werbung?
-> Hier kostenlos registrieren

Schreib das doch mal als KONKRETES Beispiel.
Ganz grundsätzlich würde ich hier als Ansatz mal die AT-Sicht ins Feld werfen ...

Gruß
Larry

 

[holgermaik]

Wenn es deine Steuerung unterstützt wäre hier eine Union die optimale Lösung.

Holger

 

[PN/DP]

Codesys kann die AT-Sicht nicht so wie S7-SCL bzw. die heißt da UNION und gibt es erst ab Codesys 3

Harald

 

[BenWolf]

Zuviel Werbung?
-> Hier kostenlos registrieren

Moin BenWolf,



Wenn die Datentypen nicht gleich sind, ist das ja nicht einfach ein "zerstückeln" des Arrays. Man muss auch Datentypen konvertieren. Dazu muss man erstmal wissen, wie ein Array-Element des großen und des kleinen Arrays aussieht.

Deine Angabe sah eher so aus, dass es nur darum geht das große Array in kleine Arrays mit jeweils 8 Elementen vom Datentyp Byte zu übertragen. Dazu muss allerdings auch sichergestellt sein, dass das große Array eine Anzahl an Elementen hat, die man glatt durch 8 teilen kann. Oder man spielt etwas mit dem Auslesen der Array-Größe rum.

Egal wie, wir brauchen detailliertere Informationen:
- Arraygrößen (Quell- und Ziellarrays)
- Datentypen der Arrayelemente

VG

MFreiberger

Moin,

das große Array sieht so aus:

MessageReceiveUDP	: ARRAY [1..2085] OF BYTE;

Daraus möchte ich jetzt verschiedene Datentypen herauslesen.
Also:

Wert1 : ARRAY [1..16] OF LREAL;
Wert2 : LREAL;
Wert3 : ARRAY [1..16] OF LREAL;
Wert4 : ARRAY [1..16] OF LREAL;
Wert5 : ARRAY [1..12] OF LREAL;
Wert6 : ARRAY [1..7] OF LREAL;
Wert7 : ARRAY [1..16] OF LREAL;
Wert8 : ARRAY [1..2] OF LREAL;
Wert9 : INT;
Wert10 : ARRAY [1..37] OF BOOL;
... usw

 

[flyingsee]

Das geht doch einfach mit Pointern. Muss nur mit Big/Little Endian aufpassen, vielleicht muss du drehen.

 

[BenWolf]

Das geht doch einfach mit Pointern. Muss nur mit Big/Little Endian aufpassen, vielleicht muss du drehen.

wie funktioniert den sowas in TwinCAT?

 

[flyingsee]

Zuviel Werbung?
-> Hier kostenlos registrieren

Ganz genau kann ich das gerade aussem Kopf nicht. Hab keine IDE her.

Aber sowas wie.

zeiger: pointer to array[0..2048] of byte; Legt den zeiger an

zeiger := ADR(dein array[0]);

und mit zeiger^ kannst du auf das Element zugreifen.

oder klassisch nur poiter to byte aber dann musst du den pointer selbst hochzählen.

 

[BenWolf]

Ganz genau kann ich das gerade aussem Kopf nicht. Hab keine IDE her.

Aber sowas wie.

zeiger: pointer to array[0..2048] of byte; Legt den zeiger an

zeiger := ADR(dein array[0]);

und mit zeiger^ kannst du auf das Element zugreifen.

oder klassisch nur poiter to byte aber dann musst du den pointer selbst hochzählen.

Aber mit zeiger^ greife ich dann ja auf ein Byte zu. Wie konvertiere ich jetzt 16 Byte in ein LREAL?
Oder kann ich einfach sagen:

NeuerWert : LREAL;
NeuerWert = zeiger^[57] und er greift ab da 16 Bytes ab?

Ich bringe grade mein Programm wieder zum laufen dan probiere ich das mal aus. Und das mit dem Union, das klingt auch interessant.

 

[flyingsee]

Du kannst dir einfach einen zweiten pointer auf ein byte machen.

zeiger 2: pointer to array[0..3] of byte;
wert :lreal;

zeiger2 := ADR(wert);

zeiger2^[0] := erstes byte vom ersten zeiger
zeiger2^[1] := zweites byte vom ersten zeiger

usw.

geht natürlich in ner for schleife schneller.

 

[BenWolf]

Zuviel Werbung?
-> Hier kostenlos registrieren

Wenn es deine Steuerung unterstützt wäre hier eine Union die optimale Lösung.

Holger

Ich habs mal mit einem Union versucht.
Dabei ergibt sich der Fehler, dass jedes Array bzw jeder Wert im Union wieder bei der Startaddresse anfangen will.
Die Arrays sehen also jetzt, je nach Länge, gleich aus.



Kann man das umgehen? Das wäre nämlich die beste Lösung für meinen Fall.

Danke euch auf jeden Fall schonmal bis hierhin

 

[PN/DP]

Ich habs mal mit einem Union versucht.
Dabei ergibt sich der Fehler, dass jedes Array bzw jeder Wert im Union wieder bei der Startaddresse anfangen will.

Packe Deine hintereinanderliegenden Arrays zuerst in ein STRUCT und dann das STRUCT in die UNION mit dem Gesamt-Byte-Array.

Harald

 

[BenWolf]

Packe Deine hintereinanderliegenden Arrays zuerst in ein STRUCT und dann das STRUCT in die UNION mit dem Gesamt-Byte-Array.

Harald

Danke dir noch für die Antwort. Ich hatte es schon, statt in ein Union, direkt in ein Struct gepackt und das passt genau so wie ich das will.