# Zerlegen eines DWORD in BYTE und wieder zusammensetzen



## Atlas (27 September 2010)

Ich scheitere gerade daran ein 32Bit DWORD in einzelne Bytes zu zerlegen und hinterher wieder zusammensetzen. Es soll am Ende im zusammengesetzten DWORD natürlich wieder das selbe stehen wie zu Beginn 

Ich habe jeweile einen FC dafür...

*FC3 zum zerlegen:*

*Variablen IN:*
DW_In : DWORD

*Variablen OUT:*
B1 : BYTE
B2 : BYTE
B3 : BYTE
B4 : BYTE

*Variablen Temp:*
DW_RAM : DWORD
*
AWL Code:*


```
// Zerlegen des DWORDS in einzelne BYTE
// DWORD: B1(11111111) B2(11111111) B3(11111111) B4(11111111)

// Byte 4 von 4
      L     #DW_In
      T     #B4

// Byte 3 von 4
      L     W#16#8
      L     #DW_In
      SRD   
      T     #DW_RAM

      L     #DW_RAM
      T     #B3

// Byte 2 von 4
      L     W#16#16
      L     #DW_In
      SRD   
      T     #DW_RAM

      L     #DW_RAM
      T     #B2

// Byte 1 von 4
      L     W#16#24
      L     #DW_In
      SRD   
      T     #DW_RAM

      L     #DW_RAM
      T     #B1
```
*FC4 zum zusammensetzen:*

*Variablen IN:*
B1 : BYTE
B2 : BYTE
B3 : BYTE
B4 : BYTE

*Variablen INOUT:*
DW_Out : DWORD

*Variablen Temp:*
DW_RAM : DWORD
*
AWL Code:*


```
// Zusammensetzen eines DWORDS aus einzelne BYTE
// DWORD: B1(11111111) B2(11111111) B3(11111111) B4(11111111)

// Byte 4 von 4
      L     #B4
      T     #DW_Out

// Byte 3 von 4
      L     #B3
      T     #DW_RAM

      L     W#16#8
      L     #DW_RAM
      SLD   
      T     #DW_RAM

      L     #DW_RAM
      L     #DW_Out
      UD    
      T     #DW_Out

// Byte 2 von 4
      L     #B2
      T     #DW_RAM

      L     W#16#16
      L     #DW_RAM
      SLD   
      T     #DW_RAM

      L     #DW_RAM
      L     #DW_Out
      UD    
      T     #DW_Out

// Byte 1 von 4
      L     #B1
      T     #DW_RAM

      L     W#16#24
      L     #DW_RAM
      SLD   
      T     #DW_RAM

      L     #DW_RAM
      L     #DW_Out
      UD    
      T     #DW_RAM
```
Leider klappt das Ganze nicht so wie ich mir das vorstelle und es kommt am Ende leider nicht das selbe wieder raus...

Die Ganze Funktion würde mich übrigends auch für REAL interessieren.



PS: Mir ist bekannt, das "#DW_RAM" nicht notwendig ist. Ich tu mir damit aber irgendwie leichter.


----------



## vierlagig (27 September 2010)

statt mit

```
*
L           W#16#8
L           #DW_In
SRD   
T           #DW_RAM
```
versuche er es mit


```
*
L           #DW_In
L           W#16#8
SRD   
T           #DW_RAM
```


----------



## Atlas (27 September 2010)

Hmm, das scheint nicht das Problem zu sein. Habe es mal testweise getauscht. Dann kommt noch mehr falsch raus als vorher 

Habe denn Schiebebefehl mal von KOP nach AWL wandeln lassen. Dann kommt dabei raus:

```
L     W#16#16
      L     #DW_In
      SRD   
      T     #DW_RAM
```

Sollte also passen dass erst "L W#16#16" und dann "L     #DW_In" kommt.


----------



## vierlagig (28 September 2010)

möglicherweise hast du recht, aber was kommt denn überhaupt RAUS???


----------



## Atlas (28 September 2010)

In der originalen Fassung aus meinem ersten Post sehen die Variablen in einer VAT wie folgt aus...

Als Eingangswert habe ich den maximal möglichen Wert (unsignet) eingegeben: 2.147.483.647


----------



## vierlagig (28 September 2010)

ok, geb ich dir beim schieben halt nochmal recht, aber der FC scheint das ganze durch die interne adressierung nicht so abbilden zu wollen, wie du es dir es vorstellst und der code es verheißen würde ... schon mal mit indirekter adressierung versucht?


----------



## Atlas (28 September 2010)

Nein, hab ich noch nicht. Liegt vermutlich daran, dass ich mit indirekter adresierung noch nie was gemacht habe und das mal so eben nicht auf die reihe bringe.


----------



## PN/DP (28 September 2010)

Moin,
müssen die paar (8) AWL-Zeilen zum Zerlegen unbedingt in KOP/FUP lesbar sein?

Die Schiebe-Befehle sind ja sehr interessant und sollten mal genau untersucht werden
(sprich: F1-Taste benutzen, die Befehlsbeschreibung und die Beispiele lesen und ausprobieren).

Wenn Du die Anzahl zu schiebender Bits nicht vorher in den Akku lädst, sondern direkt 
am Schiebebefehl angibst, dann kann da schon mal nichts mehr schief gehen:

```
L     #DW_In
      T     #B4
      SRD   8
      T     #B3
      SRD   8
      ...
```

Harald


----------



## Ralle (28 September 2010)

Wie PN/DP schon schrieb, allerdings noch etwas länger, da nur mal so umgemodelt, das es funzt:



```
// Zerlegen des DWORDS in einzelne BYTE
// DWORD: B1(11111111) B2(11111111) B3(11111111) B4(11111111)

// Byte 4 von 4
      L     #DW_In
      T     #DW_RAM
      T     #B4

// Byte 3 von 4
      L     W#16#8
      L     #DW_RAM
      SRD   
      T     #DW_RAM
      T     #B3

// Byte 2 von 4
      L     W#16#8
      L     #DW_RAM
      SRD   
      T     #DW_RAM
      T     #B2

// Byte 1 von 4
      L     W#16#8
      L     #DW_RAM
      SRD   
      T     #B1
```


----------



## Ralle (28 September 2010)

Und auch der Code zum Zusammensetzen muß etwas geändert werden, nun gleich mit der kürzeren Form:



```
// Zusammensetzen eines DWORDS aus einzelne BYTE
// DWORD: B1(11111111) B2(11111111) B3(11111111) B4(11111111)

// Byte 4 von 4
      L     #B4

// Byte 3 von 4
      L     #B3
      SLD   8
      +D    

// Byte 2 von 4
      L     #B2
      SLD   16
      +D    

// Byte 1 von 4
      L     #B1
      SLD   24
      +D    
      T     #DW_Out
```

PS: Statt +D kann man auch OD einsetzen! 
Du hattest UD genutzt, das geht natürlich nicht.


----------



## PN/DP (28 September 2010)

OK, weil Atlas anscheinend schon ins Bett gegangen ist, verrate ich schnell noch das Zusammensetzen:

```
L     #B1
      SLD   8
      L     #B2
      OD
      SLD   8
      L     #B3
      OD
      ...
      L     #B4
      OD
      T     #DW_Out
```
Wichtig: *OD*ER - nicht UND! 
(@Ralle: +D funktioniert natürlich auch, ist aber für den Datentyp eigentlich nicht zulässig)

Um wenn es ganz effizient sein soll, dann kannst Du (Atlas) mal hier drüber nachdenken:

```
// Zerlegen
      L     #DW_In      // 1234
      T     #B4
      TAW               // 1243
      T     #B3
      TAD               // 3421
      T     #B1
      TAW               // 3412 
      T     #B2

// Zusammensetzen
      L     #B2         // 0002
      TAW               // 0020
      L     #B1
      OD                // 0021
      TAD               // 1200 
      L     #B3
      OD                // 1203
      TAW               // 1230
      L     #B4
      OD                // 1234
      T     #DW_Out
```

Gute Nacht
Harald


----------



## Ralle (28 September 2010)

PN/DP schrieb:


> Um wenn es ganz effizient sein soll, dann kannst Du (Atlas) mal hier drüber nachdenken:
> 
> ```
> // Zerlegen
> ...



Das gefällt mir, wird aber sicher,wenn im Code genutzt, immer wieder mal zu Fragen von Kollegen führen. 

@PN/DP
Das mit dem +D stimmt, aber es ist spät


----------



## Paule (28 September 2010)

PN/DP schrieb:


> Um wenn es ganz effizient sein soll, dann kannst Du (Atlas) mal hier drüber nachdenken:
> 
> ```
> // Zerlegen
> ...


*ROFL*

Ist das genial,
ich habe das jetzt nicht probiert, aber ich glaube Dir dass es so funktioniert.

Ich würde mich zwar selber Ohrfeigen wenn ich das mal später ohne Kommentar bei mir sehen würde, aber wie gesagt "Klasse"


----------



## PN/DP (28 September 2010)

Ralle schrieb:


> aber es ist spät


Stimmt, ich mache auch nicht mehr alles gleich richtig.
Also Computer *ZU*.

Gute Nacht
Harald


----------



## vierlagig (28 September 2010)

PN/DP schrieb:


> Stimmt, ich mache auch nicht mehr alles gleich richtig.
> Also Computer *ZU*.
> 
> Gute Nacht
> Harald



nasch dir noch einen, dann schreibste och son scheiß wie ich...


----------



## PN/DP (28 September 2010)

Nagut, 
Moin Paule!

Was glaubst Du, warum ich für die paar Zeilen einen kurzen Kommentar dranstehen habe?
Ich werde älter und müsste in einem Jahr ohne Kommentar auch länger drüber nachdenken.
Bei meinen Programmen ist meistens die Erklärung viel länger als der Code. 

und 4L:
meinst Du mit Scheiß etwa die indirekte Adressierung?!

Aber jetzt wirklich Gute Nacht!!!
Harald


----------



## Atlas (28 September 2010)

Guten Morgen!

Danke für die Unterstützung!

Habe eben die Vorschläge von Ralle in die Steuerung geladen... 

http://sps-forum.de/showpost.php?p=283395&postcount=9
http://sps-forum.de/showpost.php?p=283395&postcount=10

Das scheint zu funktionieren!


Der Vorschlag von PN/DP ist mir so früh am Morgen noch nicht verständlich aber er scheint auf die schnelle auch zu funktionieren.

Danke an alle!!


PS:
Mit REAL funkitioniert das ganze genauso. Super!


```
L REAL_Zahl
T #DW_In

// Zerlegen
// ...

// Zusammensetzen
// ...

L #DW_Out
T REAL_Zahl
```


----------



## PN/DP (28 September 2010)

Atlas schrieb:


> PS:
> Mit REAL funkitioniert das ganze genauso. Super!
> 
> 
> ...


Guten Morgen!
Mal eine Frage: wozu soll dieses Zerlegen eines REAL in 4 BYTE gut sein?
(man kann natürlich jeden 32-Bit-Datentyp in 4 Byte zerlegen)
Die 4 Bytes haben dann einen völlig unauswertbaren Inhalt und eignen sich nur zum wieder Zusammensetzen.
Was willst Du damit erreichen? In Dezimalziffern zerlegen?

Harald


----------



## vierlagig (28 September 2010)

PN/DP schrieb:


> Guten Morgen!
> Mal eine Frage: wozu soll dieses Zerlegen eines REAL in 4 BYTE gut sein?
> (man kann natürlich jeden 32-Bit-Datentyp in 4 Byte zerlegen)
> Die 4 Bytes haben dann einen völlig unauswertbaren Inhalt und eignen sich nur zum wieder Zusammensetzen.
> ...



mögliche anwendung: bytweise versenden ... über nen cp341 z.b.


----------



## erzteufele (28 September 2010)

moin 
wenn ihr grad so schön dabei seid *grins*

ich grübel seit lägerem ab und zu mal darüber 16 bit´s zu einem word zu machen... bisher is mir nichts gescheites dazu eingefallen 

wie würde das denn gehn  *ganz lieb schau*


----------



## Ralle (28 September 2010)

erzteufele schrieb:


> moin
> wenn ihr grad so schön dabei seid *grins*
> 
> ich grübel seit lägerem ab und zu mal darüber 16 bit´s zu einem word zu machen... bisher is mir nichts gescheites dazu eingefallen
> ...



Im einfachsten Fall, indem du mit einem MW arbeitest. Da kannst du direkt auf die Bits und das MW zugreifen. Ansonsten in einem FC/FB über indirekte Adressierung. Entweder du legst ein Temp-DWord an und greifst über indir. Adressierung auf die einzelnen Bits des DWord zu oder umgekehrt, di legst 16 Temp-Bool hintereinander an (Wordgrenzen beachten!) und greifst dann über indir. Adressierung (siehe FAQ) auf das Word zu. Welche Variante der indir. Adressierung du nutzt hängt dabei nur davon ab, wie oft du die Bits oder das Word benötigst, welches öfter verwendet wird kommt direkt in den Temp-Bereich.

Eine weitere Möglichkeit ist SCL und der AT-Operator. Da kann man einer Variable unterschiedliche Sichten zuordnen, also auf ein Word, dessen Bytes oder auch Bits schauen.


----------



## Atlas (28 September 2010)

PN/DP schrieb:


> Guten Morgen!
> Mal eine Frage: wozu soll dieses Zerlegen eines REAL in 4 BYTE gut sein?


 


vierlagig schrieb:


> mögliche anwendung: bytweise versenden ... über nen cp341 z.b.


 
 Genau dafür!




erzteufele schrieb:


> moin
> ich grübel seit lägerem ab und zu mal darüber 16 bit´s zu einem word zu machen... bisher is mir nichts gescheites dazu eingefallen
> 
> wie würde das denn gehn



Ich habe fertige und getestete Bausteine die dir aus 2 BYTES ein WORD machen und umgedreht. Allerdings kann ich Dir den Code dafür erst heute abend posten wenn dir das auch hilft...

Ansonsten kannst Du jedes einzelne BIT in einem WORD welches z.B. im DB1 auf Adresse 0 steht über DB1.DBX0.1 bis DB1.DBX1.0 direkt adressieren. Das muss dann aber immer manuell für jedes WORD programmiert werden.


----------



## vierlagig (28 September 2010)

Atlas schrieb:


> Genau dafür!



meine glaskugel ist aus der reparatur zurück und funktioniert offensichtlich eimerfreistens


----------



## Ralle (28 September 2010)

vierlagig schrieb:


> meine glaskugel ist aus der reparatur zurück und funktioniert offensichtlich eimerfreistens



4L, jetzt bin ich aber beruhigt, deine letzten Posts heute ganz sehr früh haben mich etwas verunsichert.  *ROFL*


----------



## PN/DP (28 September 2010)

16 Bit in ein Word? War die Frage tatsächlich ernst gemeint?
Dann vielleicht so:

```
L MW222      // enthält M223.0 (Bit0) ... M222.7 (Bit15)
T #Wordwert
```
Für solche Fälle eignet sich ein Schmiermerkerbereich. (Temp geht auch, aber nur in SCL durchgehend symbolisch)

```
TmpUnion_Bit24	M     220.0	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit25	M     220.1	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit26	M     220.2	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit27	M     220.3	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit28	M     220.4	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit29	M     220.5	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit30	M     220.6	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit31	M     220.7	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit16	M     221.0	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit17	M     221.1	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit18	M     221.2	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit19	M     221.3	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit20	M     221.4	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit21	M     221.5	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit22	M     221.6	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit23	M     221.7	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit8	M     222.0	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit9	M     222.1	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit10	M     222.2	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit11	M     222.3	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit12	M     222.4	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit13	M     222.5	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit14	M     222.6	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit15	M     222.7	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit0	M     223.0	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit1	M     223.1	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit2	M     223.2	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit3	M     223.3	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit4	M     223.4	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit5	M     223.5	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit6	M     223.6	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_Bit7	M     223.7	BOOL	temporäres DWord für Zugriff auf .0 ... .31
TmpUnion_HH_B	MB    220	BYTE	temporäres DWord Bits .24 ... .31
TmpUnion_HL_B	MB    221	BYTE	temporäres DWord Bits .16 ... .23
TmpUnion_LH_B	MB    222	BYTE	temporäres DWord Bits .8 ... .15
TmpUnion_LL_B	MB    223	BYTE	temporäres DWord Bits .0 ... .7
TmpUnion_H_W	MW    220	WORD	temporäres DWord Bits .16 ... .31
TmpUnion_L_W	MW    222	WORD	temporäres DWord Bits .0 ... .15
TmpUnion_DW	MD    220	DWORD	temporäres DWord Bits .0 ... .31
```

Harald


----------



## PN/DP (28 September 2010)

Atlas schrieb:


> Genau dafür!


Na, dann bin ich auch beruhigt, daß Du weißt was Du tust.

Harald


----------



## erzteufele (28 September 2010)

@ralle ja immoment mach ich das direkt über eine db word direkt auf die einzelnen bits möchte des aber gerne indirekt machen in einem fb um dann noch einen timer dazuzubauen ... (für fehlermeldungen von zylindern) mach des ziemlich simpel ein die einzelnen bit´s sind fehler und werden dann word weiße verglichen erst wenn das wort dann unverändert über längere zeit bleibt wird das word an´s panel gesendet.

und das mit das word auf ne temp legen sagt mir sogar grad was muss mal schauen  

auf den code von atlas bin ich trozdem gespannt


----------



## rostiger Nagel (28 September 2010)

vierlagig schrieb:


> eimerfreistens


 
damit ich auch alles verstehe in diesen Thread, was heißt den dieses Wort ? vlt. Freier Eimer?


----------



## vierlagig (28 September 2010)

Helmut_von_der_Reparatur schrieb:


> damit ich auch alles verstehe in diesen Thread, was heißt den dieses Wort ? vlt. Freier Eimer?



einwandfrei


----------



## Gerri (28 September 2010)

// DWORD -> BYTE

L DW
SLD 24
SRD 24
T Byte_1

L DW
SLD 16
SRD 24
T Byte_2

L DW
SLD 8
SRD 24
T Byte_3

L DW
SRD 24
T Byte_4

// BYTE -> DWORD

L Byte_4
SLD 24
T DW

L Byte_3
SLD 16
UD DW
T DW

L Byte_2
SLD 8
UD DW
T DW

L Byte_1
UD DW
T DW


----------



## Larry Laffer (28 September 2010)

@Gerri:
was soll das sein ?
Erstmal : nicht "L DW" sondern "L DB*D*"
Und dann : beim Zusammensetzen nicht "UD" sondern "OD"

Gruß
Larry


----------



## Gerri (28 September 2010)

DW war nur meine Bezeichnung für die Doppelword-Variable. U du hast recht OD!


----------



## Gerri (28 September 2010)

du schiebst die bytes nach links, dadurch werden die bits der bytes die du nicht benötigst null.
Anschliessend schiebst du das byte in die andere Richtung und schreibst den Wert in das benötigte byte

zb. Byte 3 ermitteln:

1111_1111_1111_1111_1111_1111_1111_1111
SLD 8

-> 1111_1111_1111_1111_1111_1111_0000_0000
SRD 24

-> 0000_0000_0000_0000_0000_0000_1111_1111

das Byte 3 ist nun selektiert.

in der anderen Richtung schiebt man das byte and die gewünschte stelle des Doppelworts und "fügt es mit" OD "hinzu"


----------



## PN/DP (28 September 2010)

Gerri schrieb:


> du schiebst die bytes nach links, dadurch werden die bits der bytes die du nicht benötigst null.


Warum muß man Bits, die man nicht benötigt, extra nullen? 

Harald


----------



## PN/DP (28 September 2010)

*FB PackBits*



erzteufele schrieb:


> ich grübel seit lägerem ab und zu mal darüber 16 bit´s zu einem word zu machen... bisher is mir nichts gescheites dazu eingefallen
> 
> wie würde das denn gehn  *ganz lieb schau*


Hier mal ein Baustein, der genau das macht, sogar ohne Schmiermerker.
Funktioniert allerdings nicht als FC, sondern nur als FB und benötigt dadurch noch einen IDB.

```
FUNCTION_BLOCK "PackBits"
TITLE =Dieser FB packt 16 Bits in ein Word
//#Bit_0 muß der erste IN-Parameter sein, #Bit_1 .. #Bit_15 müssen direkt folgen!
//Der Programmcode funktioniert nur als FB, nicht als FC!
AUTHOR : PN_DP
VERSION : 0.1

VAR_INPUT
  Bit_0 : BOOL ;
  Bit_1 : BOOL ;
  Bit_2 : BOOL ;
  Bit_3 : BOOL ;
  Bit_4 : BOOL ;
  Bit_5 : BOOL ;
  Bit_6 : BOOL ;
  Bit_7 : BOOL ;
  Bit_8 : BOOL ;
  Bit_9 : BOOL ;
  Bit_10 : BOOL ;
  Bit_11 : BOOL ;
  Bit_12 : BOOL ;
  Bit_13 : BOOL ;
  Bit_14 : BOOL ;
  Bit_15 : BOOL ;
END_VAR
VAR_OUTPUT
  WordVal : WORD ;
END_VAR
BEGIN
NETWORK
TITLE =Eingangsbits in Ausgangsword übertragen

      L     P##Bit_0;      //Adresse des ersten IN-Parameters
      LAR1  ;
      L     W [AR1,P#0.0]; //alle 16 Bool-IN lesen
      TAW   ;              //-> Big Endian
      T     #WordVal;      //auf Ausgang schreiben

END_FUNCTION_BLOCK
```
Doch für diese simple Sache extra einen Baustein einsetzen?
Da ist ja alleine der Code für den Baustein-Aufruf ein vielfaches der eigentlichen Funktion.
Doch OK, es ist natürlich besser lesbar und die Chancen für Tippfehler sind geringer.

Harald


----------



## Gerri (28 September 2010)

was passiert wenn man einen Wert der grösser als ein byte ist auf ein byte transferiert? Bleiben die Bits die nicht verwendet werden (also vom nächst höheren byte) unberücsichtigt. 
Ehrlich gesagt hab ich das noch nie durchdacht dass das so ist


----------



## Ralle (28 September 2010)

Gerri schrieb:


> was passiert wenn man einen Wert der grösser als ein byte ist auf ein byte transferiert? Bleiben die Bits die nicht verwendet werden (also vom nächst höheren byte) unberücsichtigt.
> Ehrlich gesagt hab ich das noch nie durchdacht dass das so ist



Genau so ist es, wenn du ein DWord auf ein Byte schreibst, wird nur das niederwertigste Byte des DWord in das Byte geschrieben, für den Rest ist ja kein Platz, der fällt also in den Gulli.


----------



## Waldi1954 (29 September 2010)

Hallo
Eine weitere Variante


----------



## Ralle (29 September 2010)

Waldi1954 schrieb:


> Hallo
> Eine weitere Variante



ok, aber LD 0 ist häßlich. Besser wäre indir. Adressierung.


----------



## Waldi1954 (29 September 2010)

Hallo,

warum einfach wenns auch kompliziert geht? 
Was meinst du zu diesem Beispiel?


----------



## Ralle (29 September 2010)

Waldi1954 schrieb:


> Hallo,
> 
> warum einfach wenns auch kompliziert geht?
> Was meinst du zu diesem Beispiel?



Na, geht doch. 

Ich finde diese Variante wesentlich sauberer, weil bei Änderungen (Variablen einfügen/löschen) bei den Variablen der FC/FB nicht auch im Code geändert werden muß, weil sich die lokalen Variablenadressen verschoben haben. Natürlich ist es etwas komplizierter, aber bei größeren Bausteinen spart es bei Änderungen Aufwand und Nerven.


----------



## PN/DP (29 September 2010)

*das war wohl nix ...*



Waldi1954 schrieb:


> Hallo,
> 
> warum einfach wenns auch kompliziert geht?
> Was meinst du zu diesem Beispiel?


Wie Ralle schon schrieb, sieht diese Variante wesentlich sauberer aus ...
Doch was nützt das, wenn der Baustein nicht genau das tut, was er soll ?! 

Nur weil ein Baustein genau einen Test mit genau einem Testdatum besteht, 
heißt das nicht, daß der Baustein richtig funktioniert oder gar fehlerfrei ist. 

Wer will, daß *L P##Byte0* oder *L P##OutDW* die Adresse der Übergabeparameter ergibt, der muß schon einen *FB* nehmen. 
Bei FC erhält man die Adresse des beim Aufruf angegebenen Aktualparameters, so daß es z.B. völlig egal ist, was für 
Aktualparameter bei Byte1, Byte2 und Byte3 angegeben sind. Es wird immer mit der Adresse des bei Byte0 angegebenen 
Aktualparameters und dessen nächste 3 Byte-Adressen gearbeitet!
Es ist einfach nur eine reichlich umständlich formulierte Übertragung eines Doppelwords auf ein anderes Doppelword.

Um den Baustein endgültig auf den Müll zu werfen: ruf mal den Baustein mit Aktualparametern aus einem DB auf, z.B. 
Byte0:=DB1.DBB4 ... Byte3:=DB4.DBB4
Mach den/die DB aber vorsichtshalber größer als notig, sonst geht die CPU in STOP. 

Tut mir ja Leid für den Verriß, doch der Baustein ist wirklich unausgegorener Müll. 

[EDIT]Zusatz: mit Konstanten als Aktualparameter für die Eingangsparameter funktioniert der Baustein auch nicht.

Harald


----------



## Ralle (29 September 2010)

@PN/DP
Du hast durchaus Recht, ich mache das auch mit FC, aber ich nutze darin grundsätzlich Temp-Var, um derartige Dinge zu erledigen. Hab nur auf den Code geschaut, der war ok. Genau aus dem Grund den du nennst, FB und FC verhalten sich da leider unterschiedlich. ...das FB/FC-Thema hatte ich doch heut schon mit Larry am Wickel ... Scheiß-Idee von Siemens da Unterschiede zu machen.


----------



## PN/DP (29 September 2010)

Ralle schrieb:


> ...das FB/FC-Thema hatte ich doch heut schon mit Larry am Wickel ... Scheiß-Idee von Siemens da Unterschiede zu machen.


Ich mache niemandem einen Vorwurf, der diese teilweise unverständlichen Unterschiede zwischen FB und FC nicht kennt.
(ich behaupte auch nicht, daß ich alle Unterschiede kennen würde)

Doch bevor man ein Programm stolz veröffentlicht oder gar in eine echte Anlagen-Steuerung lädt, sollte man das Programm schon 
*ausgiebig simuliert und getestet* haben. Besonders wenn man nicht mehr symbolisch arbeitet oder gar mit Pointern 'rummacht!
Das ausgiebige Testen eines Programms in der Simulation und dann nochmal in der echten Umgebung ist noch wichtiger als das 
eigentliche Programmieren.

Da ich fast wöchentlich solche und andere Fehler in Steuerprogrammen meiner Fabrik ausbügeln muß, die die Hersteller selber 
nicht finden, habe ich mittlerweile einen Blick für so "verdächtige" Programmzeilen. 
Daher wohl auch mein etwas harscher Ton im Beitrag #42. Aber trösten werde ich den neuen Waldi jetzt trotzdem nicht. 
Sein Programm ist ja ein schönes Beispiel dafür, wie wichtig RICHTIGES Testen ist.

Harald


----------



## Waldi1954 (30 September 2010)

*Überzogene Reaktion*

Hallo PN/DP,

selbstverstädnlcih war mir klar, dass der Zeigerverweis auf das Byte 0 für die nächsten drei Byte verbindlich ist.
Dieser Baustein war auch nur ein Beispiel der in sich geschlossen war, da er sich nur auf das MW 10 bezog.
Der Out DW Zeiger zeigt immer auf die richtige Adresse, nur der Inhalt richtet sich auf Bezug von Byte 0 bis Byte 3.
Diese 3 Byte wurden nach außen geführt um den Inhalt der einzelnen 4 Bytes darzustellen. 
Normalerweise würde ich da nur eine Bool Adresse darstellen und auf Merker 10.0 verweisen, intern die Adresseninhalte umladen.
Ich nehme an das niemand hingeht und Beispiele aus dem Forum herauszieht und 1 zu 1 auf die Maschine überträgt.

Ein Beispiel in ein Forum zu einer Diskussion hinzuzufügen ist etwas anderes, wie ein Übertrag auf eine reale Steuerung.
Ich bin mir sicher, dass viele dieses Beispiel auch so sehen und damit einen Denkanstoß bekommen.
Viele Porgrammierer sind Einzelkämpfer und sind froh wenn sie andere Denkweisen und Vorgehensweisen sehen können.
Ich denke das Forum ist auch dafür da Gedankengänge auszutauschen.

MIr hat es Spaß gemacht mit anderen über solche Themen zu diskutieren und auch Denkanstöße zu bekommen.

MFG Waldi


----------



## rostiger Nagel (30 September 2010)

*PN/DP hat schon recht*



Waldi1954 schrieb:


> ....
> Ich nehme an das niemand hingeht und Beispiele aus dem Forum herauszieht und 1 zu 1 auf die Maschine überträgt.
> ....


 
aber genau das passiert, hier schauen viele Schüler oder Studierende rein
die keine langjährige Programmier-Erfahrung besitzen, geh davon aus das
sie so ein Beispiel 1:1 umsetzen und als richtigen Weg auffassen, bis zum
nächsten Crash an der Maschine. Erst dann wird das Gehirn eingeschaltet
und das ganze noch mal hinterfragt oder geprüft.



Waldi1954 schrieb:


> ....
> selbstverstädnlcih war mir klar, dass der Zeigerverweis auf das Byte 0 für die nächsten drei Byte verbindlich ist.
> ....


 
Wenn du genau gewußt hast, das dein Beispiel nicht Lupenrein ist, dann
schreib es gefälligst dabei, eine kleine Anmerkung hätte da schon genügt.

Harald (PN/DP) seine Reaktion, ist nach deiner Stellungnahme, erst recht nicht 
überzogen, wenn du genau weißt das du hier Beispiele postest die in der
Praxis kein bestand haben.


----------



## Larry Laffer (30 September 2010)

Na - Na ... nun lasst mal die Wellen nicht zu hoch schlagen.

Selbstverständlich hat Harald absolut Recht ... und selbstverständlich ist es gut darauf hinzuweisen, wie man es am Besten vernünftig macht ... aber ihr lest doch auch alle die Fragen, die so gestellt werden ...
Obwohl manche von uns schon hunderte von Malen geschrieben haben wie es richtig wäre - viele wollen das gar nicht wissen bzw. ist es ihnen zu kompliziert sich mit dem Hintergrund zu beschäftigen. Jetzt könnteman natürlich sagen "Was haben die dann vor dem Programmiergerät zu suchen ?" ... aber das ist auch nicht der Schlüssel zum Glück weil irgendwann wir ja auch mal genauso angefangen haben. Das darf man nicht vergessen.
Was mich am meißten stört ist diese "Wer schreibt mir mein Programm ?"-Mentalität bzw. die "Gibt es da nichts fertiges ?". Genau diese Einstellung verhindert m.E. das "sich mit dem Hintergrund auseinandersetzen", was u.A. ja auch von Harald (aus wahrscheinlich sehr leidvoller Erfahrung) gerne mal (und vollkommen zu Recht) angeprangert wird.

OK ... das wollte ich dazu schreiben - habe fertig ...

Gruß
Larry


----------

