# Anfängerfrage Merkerwort



## Claudi (2 Februar 2007)

Hallo,

ich habe mich hier angemeldet, weil ich am Di eine Klausur über SPS schreibe. Ich habe aber sonst damit nichts am Hut & brauch es nicht wieder(gehört aber leider zur Studienordnung). 
Zur Prüfungsvorbereitung haben wir einige Fragen bekommen: Ich hoffe ihr könnt mir erklären was passiert:

1. Die Eingänge 1.7 bis 0.0 sind mit 0 belegt außer E0.3 (mit 1 ): dazu besteht die AWL:
LEW 0
SLW 3
LAR1
LMW 100
T AW(AR1,P#0.0)

Frage: was steht in MW 100?

Also das die Eingänge um 3 Stellen verschoben werden ist klar, sodass die 1 dann beim Eingang0.6 steht. Dann wird das Arbeitsregister geladen in Akku1. Ich vermute das kommt die Adresse 8.0 dadurch raus. Jetzt weiß ich nicht was es mit dem MW 100 aufsich hat? Es ist nicht meine letzte Frage, aber ich hoffe ihr könnt sie einem Leihen logisch erklären.

Danke, Claudia


----------



## Andi F (2 Februar 2007)

Hallo Claudia,

- LAR1 bedeutet: Lade Adressregister 1 mit Inhalt von Akku 1
- Im Eingangswort 0 steht der dezimale Wert 2048
- Was im MW100 steht ist in Deinem Beispiel nicht ersehbar, das wird dort nicht beschrieben
- Das Ergebnis ist aber folgendes: Das was im MW100 steht wird auf das Ausgangswort 2048 geschrieben.

  Wenn aber die verwendete CPU diese hohe Adresse 2048 nicht kann geht die CPU auf Stopp.

Gruss

Andi F


----------



## Claudi (2 Februar 2007)

Hallo Andi,

Danke für deine schnelle Antwort. Wie ist das mit den Pointern? Als im Adressregister 1 steht ja das um 3 Stellen nach links verschobene EW. somit ergibt sich die Adresse 8.0. Das steht dann im Akku 1. So jetzt kommt das unbekannte MW 100. Das steht dann in Akku1 und AR1 rutscht in Akku2? Was genau bringt das laden von dem AR1?

 Also die Adresse vom AW wäre doch jetzt das aus AR1 (8.0) + P#0.0 = 8.0...Ich weiß halt auch nicht warum in der Aufgabenstellung dieses LMW 100 geucht ist wenn, es gar nicht bekannt ist?

sorry für die bestimmt sehr leihenhaften Fragen, aber ich hab da keine Vorstellung


----------



## Unregistrierter gast (2 Februar 2007)

Claudi schrieb:


> Wie ist das mit den Pointern? Als im Adressregister 1 steht ja das um 3 Stellen nach links verschobene EW. somit ergibt sich die Adresse 8.0.



NEIN ! Wie kommst du da drauf ??  Das high - byte ist EB 0 !!



Claudi schrieb:


> somit ergibt sich die Adresse 8.0. Das steht dann im Akku 1.
> So jetzt kommt das unbekannte MW 100. Das steht dann in Akku1 und AR1 rutscht in Akku2? Was genau bringt das laden von dem AR1?



Das AR1 kann nicht in Akku 2 rutschen! Die AR und die AKKUs sind 2 unterschiedliche Dinge !!
Zwar steht im Akku 2 nun derselbe _Wert _wie im AR1, aber im AR1 steht immer noch der Wert, der mit LAR1 geladen wurde !

Akkus laden und Adressregister laden sind 2 unterschiedliche Sachen !!




Claudi schrieb:


> Also die Adresse vom AW wäre doch jetzt das aus AR1 (8.0) + P#0.0 = 8.0...Ich weiß halt auch nicht warum in der Aufgabenstellung dieses LMW 100 geucht ist wenn, es gar nicht bekannt ist?



Die Adresse kommt aus dem AR1, das mit dem wert von EW0 geladen wurde, das ist aber nicht 8 !

In *dieses *AW wird nun der Wert geschrieben, der im Akku 1 steht, und da steht der (unbekannte) Wert aus MW 100.



Claudi schrieb:


> Sorry für die bestimmt sehr leihenhaften Fragen, aber ich hab da keine Vorstellung



Deine Fragen sind nicht Laienhaft.
Man merkt, das du sich mit der Materie bereits auseinandergesetzt hast.

Seltsam nur, das du dich hier als Mädchen ausgibst, obwohl du ein Junge bist ....


----------



## Andi F (2 Februar 2007)

Claudi schrieb:


> Hallo,
> ...
> 1. Die Eingänge 1.7 bis 0.0 sind mit 0 belegt außer E0.3 (mit 1 ): dazu besteht die AWL:
> LEW 0
> ...


 
Hallo Claudia,

ich denke wir sollten das Schritt für Schritt durchgehen.

1. Anweisung: L EW0  --> Lade Eingangwort 0, das besteht aus Eingangsbyte 0 und 1. Das Byte 0 ist das höherwerte (linke), das Byte 1 das niederwertige (rechte). Somit ergibt sich:

|0.7|0.6|0.5|0.4|0.3|0.2|0.1|0.0|1.7|1.6|1.5|1.4|1.3|1.2|1.1|1.0|


Wenn jetzt nur der Eingang 0.3 "1" ist ergibt das die dezimal Zahl 2048

Verstanden ?


Gruss
Andi F


----------



## Unregistrierter gast (2 Februar 2007)

2 hoch 11 = 2048.

EB0 = links = high byte.
EB1 = rechts = low byte.


----------



## Ralle (2 Februar 2007)

Ein nochmal, um sicherzustellen das du das wirklich verstanden hast.

Wenn du das AW 2048 mit einem beliebigen Wert laden willst, indirekt über den Pointer, dann mußt du den Wert 2048 nehmen und mit SLW3 in das Pointerformat überführen, die rechten 3 Bit sind die Bitadressen.

Nur Bit 0.3 gesetzt bedeutet dezimal 2048, wie schon geschrieben wurde.
SLW 3 bringt das ins Pointerformat, wobei man besser SLD 3 nimmt, der Pointer ist schließlich auch im DWord-Format. SLW3 funktioniert zwar, aber bei Datenbausteinen und weiten Sprüngen geht das schief, durfte ich selbst schon erleben.  Aus Fehlern wird man klug .
Warum wird gefragt, was im MW100 steht, das hat doch mit dem Pointer hier gar nichts zu tun? Sowas nenne ich schon gemeine Frage, was für Heinis habt ihr da nur?


----------



## Unregistrierter gast (2 Februar 2007)

Ralle schrieb:


> wobei man besser SLD 3 nimmt, der Pointer ist schließlich auch im DWord-Format.



Jau, sehr richtig!

Auch im vorgelegten Beispiel ging das in die Hose, wenn z.B. E0.5 gesetzt wäre !

Gut aufgepasst !


----------



## Claudi (3 Februar 2007)

Erstmal vielen Dank für eure Antworten! Ihr bringt mir das wirklich schon viel näher! mal ne kurze Zwischenfrage! Warum soll ich kein Mädel sein? Also ich bin auf jeden Fall von der Sorte!

@Andi: ja so Schritt für Schritt ist für mich wahrscheinlich das beste! Das war jetzt schon gut von dir! Die Prüfung soll wohl nicht so schwer werden, aber wir sollen noch ein Programm am Ende schreiben können. Die Prüfung ist am Di!

@Ralle: ja das sind Heinis!Das fängt aber schon damit an, das ich mich als fast fertiger Biotechnologe mit leider mehr techn/informat Sachen beschäftigen muss. Und der, der uns das beibringen sollte, hat da eigetlich total versagt. Aber wie geschrieben, mit der Schritt für Schrittmethode helft ihr mir sehr!

Ok! Was ist jetzt mit der Pointeradresse? bzw der nächste Schritt?

Danke nochmal für eure Hilfe!:-D


----------



## Unregistrierter gast (3 Februar 2007)

Claudi schrieb:


> das ich mich als fast fertiger Biotechnologe mit leider mehr techn/informat Sachen beschäftigen muss.



BIOtec hat Prüfung in SPS - Adressregistern ?

Haben wir hier noch eine multiple Persönlichkeit ?


----------



## Claudi (3 Februar 2007)

Was meinst du genau?

Das ist halt das technische an Biotechnologie! Noch schlimmer war Signal & Messwertverarbeitung. Da waren nur noch Amplituden & Frequenzen und das hatte nichts mit Bio zu tun! Aber das ist meine letzte Prüfung für dieses Studium( außer der Diplomverteidigung später)! Und die will ich jetzt noch gut meistern:-D


----------



## Andi F (3 Februar 2007)

Hallo Claudia,

bitte gib einen Zwischenbescheid. Ist es jetzt der E0.3 der nur "1" ist, oder ist es jetzt der E1.3?

E0.3  auf 1 -->  Wert 2048 und somit Zeiger auf AW 2048

E1.3  auf 1 -->  Wert 8 und somit Zeiger auf AW 8

Gruss

Andi F


----------



## Claudi (3 Februar 2007)

ja also aus der Aufgabenstellung raus ist E0.3 = 1 ....

ich muss jetzt mal dazuschreiben, das die Aufgabe opisch anders ist, als hier. Also ich hab eine Auflostung der Eingänge absteigend und beginnend bei E1.7 :

E1.7|E1.6...|E0.0. Also nicht nach höher / und lower byte sortiert?! und wegen der Pointeradresse hab ich als Bsp.: P#0.2 --> 0.010 und P#1.3 --> 1.011 und da bei mir nach der SLW 3 die Reihenfolgeso ist: 1000.000 Deswegen komm ich auf die Adresse 8.0...


----------



## Andi F (3 Februar 2007)

Claudi schrieb:


> ...
> SLW 3
> ...


 
2.Anweisung: SLW 3  --> Schiebe den Inhalt von Akku 1 (niederwerte Wort) um drei bits nach links. Also im Akku geschieht hier was und nicht bei den Eingängen. 

Anmerkung: Ein Akku ist 32 Bit bzw 4 Byte bzw 2 Wort bzw 1 Doppelwort lang.

Verstanden ? Wenn ja, dann geht weiter.

Gruss

Andi F


----------



## Claudi (3 Februar 2007)

Ja das ist mir klar! Wie ist das mit dem Pointerformat? ich hab da noch eine ähnliche Aufgabe, wo aber nur um eine bzw 2 Stellen nach links verschoben wird. ist das dann was anderes oder ist das trotzdem Pointerformat?


----------



## Andi F (3 Februar 2007)

Claudi schrieb:


> ja also aus der Aufgabenstellung raus ist E0.3 = 1 ....
> 
> ich muss jetzt mal dazuschreiben, das die Aufgabe opisch anders ist, als hier. Also ich hab eine Auflostung der Eingänge absteigend und beginnend bei E1.7 :
> 
> E1.7|E1.6...|E0.0. Also nicht nach höher / und lower byte sortiert?! und wegen der Pointeradresse hab ich als Bsp.: P#0.2 --> 0.010 und P#1.3 --> 1.011 und da bei mir nach der SLW 3 die Reihenfolgeso ist: 1000.000 Deswegen komm ich auf die Adresse 8.0...


 
Hallo Claudia,

das ist doch egal wie die Auflistung in Deiner Aufgabenstellung ist. Wenn definitiv der E0.3 "1" ist, dann ergibt das nach der Anweisung "L EW0" im Akku 1 den dezimalen Wert 2048.
Eine Frage am Rande: Für welchen Typ von SPS ist diese Aufgabe eigentlich gestellt worden?

Gruss 
Andi F


----------



## Andi F (3 Februar 2007)

Claudi schrieb:


> Ja das ist mir klar! Wie ist das mit dem Pointerformat? ich hab da noch eine ähnliche Aufgabe, wo aber nur um eine bzw 2 Stellen nach links verschoben wird. ist das dann was anderes oder ist das trotzdem Pointerformat?


 
Langsam, eins nach dem anderen. so schnell kann ich nicht tippen.

Das mit dem Schieben muss nicht immer mit dem Pointer zusammenhängen.
Mit Schieben kann man auch einfache Berechnungen anstellen, zb im Akku Werte multiplizieren.

Beispiel: Schiebe um 1 Bit nach links --> Wert im Akku wird mit 2 multipliziert
            Schiebe um 2 Bit nach links --> Wert im Akku wird mit 4 multipliziert

Gruss 
Andi F


----------



## Claudi (3 Februar 2007)

Ich dacht nur, wenn E0.3 so weit hinten steht, dann wäre für mich das dann statt 2^11 dann nur 2^3....ich fange ja beim letzten an mit 2^0 bis 2^x und bei meiner vorgebenen Liste steht ja E0.3 an einer anderen Stelle... bei deiner sortierten liste steht E0.3 ja viel weiter hinten... So intensiv hatten wir das gar nicht...

welcher Typ? Oje die Aufgaben hab ich auf nem anderen Rechner, wenns überhaupt dazu stand. Also was wir immer hatten war Step 7 und Simatic300/400 . ist das das, was du meinst?

Edit: Oh da beschreib ich die anderen Bsp dann nochmal, wenn das geklärt ist... sonst komm ich durcheinander


----------



## Andi F (3 Februar 2007)

Claudi schrieb:


> Ich dacht nur, wenn E0.3 so weit hinten steht, dann wäre für mich das dann statt 2^11 dann nur 2^3....ich fange ja beim letzten an mit 2^0 bis 2^x und bei meiner vorgebenen Liste steht ja E0.3 an einer anderen Stelle... bei deiner sortierten liste steht E0.3 ja viel weiter hinten... So intensiv hatten wir das gar nicht...
> 
> welcher Typ? Oje die Aufgaben hab ich auf nem anderen Rechner, wenns überhaupt dazu stand. Also was wir immer hatten war Step 7 und Simatic300/400 . ist das das, was du meinst?


 
Hallo Claudia,

Step 7 und Simatic 300/400 ist ein wichtiger Hinweis in dieser Sache. Ich denke wir sollten erst mal bei elementaren Datentypen anfangen. Ist Dir der Begriff "Dualzahl" klar und kannst damit etwas anfangen.

Gruss 
Andi F


----------



## Andi F (3 Februar 2007)

Hallo Claudia,

hier nochmal anders dargestellt:


------------- EW0 ------------
------ EB0 ----|---- EB1 ------
7 6 5 4 3 2 1 0 | 7 6 5 4 3 2 1 0 
-------------------------------
H---<---<---<---<---<---<---L

L= niedrigste Bit einer (Wort) Dualzahl
H= höchste Bit einer (Wort) Dualzahl (normalerweise ist dass das Vorzeichenbit bei einer Integerzahl)

Dezimalwerte:

H--------------------<---------------------<-------------------<--------------------<------------------L

32768 oder Vorzeichen | 16384 | 8192 | 4096 | 2048 | 1024 | 512 | 256 | 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |

Jetzt klar ?

Gruss 
Andi F


----------



## volker (3 Februar 2007)

das ew hat andif ja jetzt gut erklärt.

ein pointer ist folgendermassen aufgebaut(bild).
(aus der hilfe von s7)
für dich interessant sind die 3 rechten bits und die weiteren 16 links daneben.

wie du siehst, sind die 3 rechten die bitadresse. genau deswegen muss auch um 3 nach links geschoben werden um eine gewünschte zahl im pointerformat darstellen zu können.

beispiele:
L 10
SLD 3
LAR1 //im AR1 steht nun P#10.0
U E[AR1,P#0.0] //fragt e10.0 ab
L EW[AR1,P#0.0] //lädt das ew10

nun gibt es noch p#0.0. das ist der 'versatz'.
U [AR1,P#0.4] //fragt e10.4 ab

auch der versatz kann indirekt erzeugt werden.
L 10
SLD 3
LAR1 //im ar1 steht p#10.0
L 4
+AR1 //die 4 werden zum ar1 hinzuaddiert. im ar1 steht jetzt p#10.4
U E[AR1,P#0.0] //fragt e10.4 ab
L EW [AR1,P#0.0] //das würde die cpu in stop bringen, da es das ew10.4 nicht gibt. nur bei bitoperationen darf die bitadresse <>0 sein.


----------



## Unregistrierter gast (3 Februar 2007)

*An PLC_Tippser*

Hallo PLC_Tippser.

Bring doch bitte den Post vom Volker mit Anhang in die FAQ !
Das braucht man öfter !


----------



## Claudi (3 Februar 2007)

Hallo!

Wir haben das halt trotzdem noch nie gemacht, mit dem EW0 und EW1! und das da E0.3 soweit hinten steht. Wie schimpft sich denn jetzt in meinem Fall der Pointer? 2048.0 oder wie?

@Volker: dein erstes Bsp versteh ich noch, aber beim 2. hörts auf.(das da auf einmal P#10.4 steht). Aber ich will erstmal auf der einen Baustelle durchblicken & nicht schon wieder eine neue eröffnen! Dafür hab ich dann selber noch paar Bsp Fragen....

Danke!

und wie gehts jetzt weiter? Also Akku1 EW0--> wird um 3 Stellen verschoben (aber nur im Ar1 oder generell?)--> AR1 laden-->Pointer# ???--> mW100 in Akku1 und EW0 in Akku 2(verschoben oder nicht?)--> irgendwie transferieren....


----------



## volker (3 Februar 2007)

@ug
im prinzip steht das schon *hier* in der faq.  
nur das mit der indirekten bitadresse ist dort noch nicht drin.
habe den beitrag aus der faq überarbeitet und an plc-tippser gesendet damit er das in die faq stellt.

@claudi
bevor ichs 2 mal erkläre. folgendes lesen. wenn dann noch fragen sind, erneut fragen. 


> Also Akku1 EW0--> wird um 3 Stellen verschoben (aber nur im Ar1 oder generell?)--> AR1 laden-->Pointer# ???--> mW100 in Akku1 und EW0 in Akku 2(verschoben oder nicht?)--> irgendwie transferieren....


ew0 vor dem schieben 
2#0000_1000_0000_0000 (dez 2048 )
ew0 nach dem schieben
2#0100_0000_0000_0000 (dez 16384, dieser wert steht jetzt im akku1)
mit lar1 wird nun der pointer (2048.0) im ar1 erzeugt. das hat nichts mit akku zu tun. der bleibt bei dieser anweisung unberührt.
dann wird mw100 in den akku1 geladen und akku1 (also 16384) nach akku2 verschoben.
mit T AW(AR1,P#0.0) wird nun der inhalt von akku1 (also mw100) in die durch das ar1 bezeichnete adresse kopiert
konventionell würde das so aussehen
L MW100
T AW 2048

-------------------------------------------------------------------------------------
*hier der geänderte beitrag für die faq. werde folgendes durch den link zur faq ersetzen solbald plc-tippser das in der faq geändert hat.*
==================================================================================
Hier ein paar Beispiele zur indirekten Adressierung / Pointer

Ein Merkerwort laden indem wir den *Pointer direkt laden*.

```
L P#30.0
T MD 10
L MW [MD 10] // lädt das mw30
```
Dies ist unflexibel.
-----------------------------------

Eleganter geht es, indem wir den *Pointer selbst erzeugen* und über das Adressregister ansprechen.

```
L     30
  SLD   3
  LAR1                    // ergibt einen pointer von P#30.0 in adressregister1 
  L     MW [AR1,P#0.0]    // lädt das mw30
```
Schon besser. Aber warum schieben wir 3 nach links?
Das liegt am *Aufbau des Pointer*. vereinfacht: *Byteadress(16Bit).Bitadress(3Bit)*. (genauerers im Bild im Anhang)
Die 30 liegt also durch das schieben in der Byteadresse. die Bitadresse ist 0.
-----------------------------------

Nun gibt es noch den *Versatz* (p#0.0). Dieser wird zum Pointer im Adressregister hinzuaddiert.

```
L     MW [AR1,P#2.0]    // lädt das mw32 (30 + 2.0)
  U     M [AR1,P#4.4]     // fragt M 34.4 ab
```
Fast perfekt.
-----------------------------------

Nun wollen wir auch noch die *Bitadresse fexibel gestalten*.

```
L     30
  SLD   3
  LAR1                    // im ar1 steht p#30.0
  L     4
  +AR1                    // die 4 wird zum ar1 hinzuaddiert. im ar1 steht jetzt p#30.4
  U     E [AR1,P#0.0]     // fragt e30.4 ab
  L     EW [AR1,P#0.0]    // das würde die cpu in stop bringen, da es das ew30.4 nicht gibt.
                          // nur bei bitoperationen darf die bitadresse <>0 sein.
```
-----------------------------------

Um indirekt *auf ein Datenwort zugreifen* zu können, ist es zwingend erforderlich den Datenbaustein vorher zu öffnen.

```
[COLOR=red]L db10.dbw [AR1,P#0.0]   // dies funktioniert nicht[/COLOR]
 
  AUF   DB    10
  L     DBW [AR1,P#0.0]    // so ist es richtig
```
-----------------------------------

*Anwendungsbeispiel *mit einer Schleife

```
FILO für Datenbyte (FirstInLastOut)
FiLo         __\ byte1 \________________
            |  /       /                |
            |    byte2 \_________    /__|3.
            |          /         |   \
            |    byte3 \__    /__|2.
            |          /  |   \
            |    byte4 /__|1.
            |          \
            |
            |
quelle    4.|__/ byte
               \
Ablauf: 
1. zielbyte  3 wird nach zielbyte 4 kopiert. das alte byte 4 geht verloren.
2. zielbyte  2 wird nach zielbyte 3 kopiert
3. zielbyte  1 wird nach zielbyte 2 kopiert
4. quellbyte 1 wird nach zielbyte 1 kopiert
```


```
AUF   #Datenbaustein      //Typ: Block_DB
      L     #Datenende          //Typ: INT
      L     1
      -I    
      T     #index              //Typ: DINT
anf:  NOP   0                   //Schleifenanfang
      L     #index
      SLD   3                   //pointer erzeugen
      LAR1                      //in das Adressregister laden
      L     DBB [AR1,P#0.0]
      T     DBB [AR1,P#1.0]
      L     #index
      L     1
      -I                        //Index um 1 verringern
      T     #index
      L     1
      +I    
      L     #Datenanfang        //Typ: INT
      <=I                       //prüfen ob fertig
      SPB   ende                //wenn ja ende
      SPA   anf                 //sonst schleife wiederholen
ende: NOP   0
      L     #Eintrag            //Typ: BYTE
      T     DBB [AR1,P#0.0]     //neues byte eintragen
```
-----------------------------------

Es kann auch *Adressregister2 (AR2)* verwendet werden.
*Aber Vorsicht:*
Das DI-Register und das Adressregister AR2 werden systemseitig für den *FB- und Multiinstanz-CALL* verwendet. Bei FC's braucht ihr euch nicht darum zu kümmern.


----------



## Claudi (3 Februar 2007)

Hallo Volker,

Ok das hat mich wieder einen (kleinen) Schritt nachvorn gebracht!Danke! 

ist da der Anfang der AWL nur dafür da, um einen Pointer zu bestimmen oder welchen Sinn hat das?Damit wurde ja hier nicht weiter gearbeitet?!

Claudia


----------



## volker (3 Februar 2007)

Claudi schrieb:


> ist da der Anfang der AWL nur dafür da, um einen Pointer zu bestimmen oder welchen Sinn hat das?Damit wurde ja hier nicht weiter gearbeitet?!


 weiss jetzt nicht genau was du meinst.

LEW 0
SLW 3 //wobei SLD 3 richtiger wäre
LAR1

diese 3 zeilen dienen einzig und allein dazu den pointer zu bilden.
(ist im prinzip das, was oben unter *Pointer selbst erzeugen* zu finden ist)


----------



## Claudi (3 Februar 2007)

volker schrieb:


> ew0 vor dem schieben
> 2#0000_1000_0000_0000 (dez 2048 )
> ew0 nach dem schieben
> 2#0100_0000_0000_0000 (dez 16384, dieser wert steht jetzt im akku1)
> ...


 
Ja, volker, das meinte ich! Die zahl die dann im Akku2 ist, hat dann keine weitere Bedeutung.

Noch mal kurz zur letzten Anweisung: ums wörtlich zu bezeichnen, heißt das dann: nehme den Inhalt Akku1(MW100) und transferiere ihn auf die Adresse im AR1, die ich dir mit meinem pointer 2048.0 zeige... diese Adresse 2048.0, heißt das dann , das das MW100 an die Stelle gesetzt wird wo 2^11 ist im AR1 oder wie genau muss ich mir das vorstellen?


----------



## Ralle (3 Februar 2007)

Ich vertrete mal kurz den Volker .



> Noch mal kurz zur letzten Anweisung: ums wörtlich zu bezeichnen, heißt das dann: nehme den Inhalt Akku1(MW100) und transferiere ihn auf die Adresse im AR1, die ich dir mit meinem pointer 2048.0 zeige... diese Adresse 2048.0, heißt das dann , das das MW100 an die Stelle gesetzt wird wo 2^11 ist im AR1 oder wie genau muss ich mir das vorstellen?



Fast richtig, würde ich sagen.
Volker hat es eigentlich schon geschrieben.
Der Speicher für die Ausgänge ist linear adressiert. Man kan ihn beschreiben, indem man  eine Zahl lädt und diese  auf ein Ausganswort schreibt. Wenn im EW0, bit 0.3 True ist und alle anderen Bit False, dann entspricht das dezimal der Zahl 2048.

Ohne indirekte Adressierung mußt du zum Zeitpunkt des Programmierens wissen, wohin diese Zahl soll, die bei dir im MW100 steht.

Also: 
L MW100
T AW 2048

Wenn du zum Zeitpunkt des Programmierens nicht weißt, wohin die Zahl im MW100 einmal soll (weil es zum Beispiel vom zu produzierenden Produkt abhängig ist), dann mußt du das indirekt adressieren.
Das Pointerformat ist also die Nummer des Ausgangswortes, um 3 bit nach links geschoben, weil die 3 Bit rechts die Bitadresse sind, damit man bei Bedarf mit einem Pointer auch auf einzelne Bits zugreifen kann, ganz einfach eigentlich.

Hoffe, alle Klarheiten beseitigt?


----------



## Claudi (3 Februar 2007)

So ich denke bei der Aufgabe ist das meiste geklärt! jetzt mal zu einer ähnlichen.

Und zwar sind die Eingänge 0.3,0.2,0.1 und 0.0 mit 1 belegt und der Rest ist 0. Die AWL lautet:

LEB 0
SLW1
LAR1
LMW 50
TAW (AR1,P#2.2)

So wenn ich das anordne kommt als Dezzahl 3840 raus. Jetzt schiebe ich das aber um 1. Was passiert da jetzt anderes, wg dem multuplizieren?


----------



## Unregistrierter gast (3 Februar 2007)

Claudi schrieb:


> So ich denke bei der Aufgabe ist das meiste geklärt! jetzt mal zu einer ähnlichen.
> 
> Und zwar sind die Eingänge 0.3,0.2,0.1 und 0.0 mit 1 belegt und der Rest ist 0. Die AWL lautet:
> 
> ...



:sm8: 

Na, jetzt wirds ja richtig kniffelig...


----------



## volker (3 Februar 2007)

wenn du die obige faq genau liest kennst du die lösung.
das prinzip ist das gleiche wie vorher.


----------



## Andi F (3 Februar 2007)

Claudi schrieb:


> So ich denke bei der Aufgabe ist das meiste geklärt! jetzt mal zu einer ähnlichen.
> 
> Und zwar sind die Eingänge 0.3,0.2,0.1 und 0.0 mit 1 belegt und der Rest ist 0. Die AWL lautet:
> 
> ...


 

Hallo Claudia,

wie kommst Du jetzt auf 3840. In der AWL steht doch jetzt LEB 0, also "Lade Eingangsbyte 0 in Akku 1".

|--------------EB0----------------|
| ...7 | ..6 | ..5 | .4 | 3 | 2 | 1 | 0 |          Die Punkte bitte ignorieren !
| 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |

Gruss
Andi F


----------



## Claudi (3 Februar 2007)

Aha, da nimmt man nur das! gut wieder was gelernt! Also steht im Akku 1 jetzt 8, schiebe ich das um 1 kommt 16 in Akku 1. Kommt da jetzt als Pointer 3.6 raus? Dann das MW 50 in Akku 1 und der Wert des MW50 ins AR1 mit Zeiger 5.0?    zumindest waren das meine ersten versuche, als ich die Aufgaben, vor paar Tagen gemacht hab?

bei den pointern (vorrausgesetzt meine These stimmt) müsste man ja 3.6 + 2.2 machen. Da es aber ja nur bis x.7 geht wird das mit Überhang gemacht?!

011.110
           +
010.010
_________
101.000  =   5.0


----------



## Ralle (3 Februar 2007)

011.110
           +
010.010
_________
110.000  = 6.0


----------



## Claudi (3 Februar 2007)

Ok da hab ich schief geschaut! Zu dem Übertrag hab ich gleich mal ne Frage!

1+1 = 2 --> 10 dual, ergibt 0 Übertrag 1
1+1+1 = 3 ->11 dual, ergibt 1 Übertrag 1? Das hatten wir nie in unseren beispielen, deswegen ist das jetzt geraten!

Was bringt diese pointeraddition für einen Sinn?


----------



## volker (4 Februar 2007)

wie bei jedem mathematischem system gibt es auch beim oktalsystem rechenoperationen die einen übertrag haben

http://de.wikipedia.org/wiki/Oktales_Zahlensystem


----------



## Ralle (4 Februar 2007)

@volker 

Stimmt, sogar das Oktalsystem hat einen Übertrag .

@Claudi

Du hast eine Datenbank, jedes Produkt belegt darin 100 Byte für Daten. Je nach Produkt ist die Anfangsadresse der Datenbank variabel, von der Anfangsadresse an stehen die einzelnen Daten immer am selben Platz. Also errechnest du den Pointer zum Anfang des Produktes, auf den Rest kannst du dann über Pointeraddition ganz prima zugreifen.


----------



## Claudi (4 Februar 2007)

hmmm, so richtig fehlt mir die Vorstellung. Mal kurz zurück zu der Aufgabe! Stimmt das jetzt, das der Pointer 3.6 entsteht? und das MW50 an das AW kopiert wird, wo der Pointer 6.0 hinzeigt?

Kann ich kurz ne Zwischenfrage stellen? und zwar sollten wir die hexzahl 3F als BCD zahl laden! So und der Ladebefehl ist ja L C# xxx mit dem Wertebereich 0-999 (unsere Arbeitsunterlagen). Wie soll der Ladebfehl dann aussehen?

Wir hatten ein anderes Bsp, da hieß es LC#200 -> daraushaben wir dual Zahl gemacht. 0010 0000 0000 und das war dann die Dezzahl 512. Wenn ich nach dem gleichen Prinzip wie hier geh, müsste das für oben, dann LC#3F sein ?! Aber das glaub ich nicht.....


----------



## volker (4 Februar 2007)

eigentlich hat ralle das doch ausreichend erklärt
im ar1 steht p#3.6. der versatz ist p#2.2
-->p#3.6 + p#2.2 = p#5.8
da es 8 im oktalsystem nicht gibt erfolgt ein übertrag => p#6.0

bei dez. 9 + 1 = 10
bei hex. f + 1 = 10

klar ?!

mw50 wird also nach aw6 transferiert.

2.
L w#16#3f


----------



## Claudi (4 Februar 2007)

Mir hat aber keiner bestätigt, ob meine theorie stimmt, sorry! Und dass das ein Oktalsystem ist hör ich auch das erste mal. Wir haben das mit dual erklärt bekommen, also : 1+1 = 10 (dez = 2) Und 1+1+1 = 11 und ich addiere doch auch Dualzahlen und keine Oktalzahlen.?! 
Das die Eingänge nur bis .7 gehen, hab ich wahrgenommen, aber nicht gewusst warum.

Für mich ist dieses Thema einfach nur schrecklich, weil sämtliche Grundlagen fehlen & ich mit bits & bytes einfach nichts anfangen kann.

zu 2.: es soll doch eine BCD Zahl geladen werden. und jetzt wurde doch eine Hexzahl geladen!

Wir sollen das umwandeln und mit LC# xxx darstellen! nicht mit LW#xx

W ist doch das zeichen für hex oder nicht?


----------



## Unregistrierter gast (4 Februar 2007)

Claudi schrieb:


> W ist doch das zeichen für hex oder nicht?



Nein, iss es nicht. 16# ist das Zeichen für hex.


----------



## Ralle (4 Februar 2007)

3F hex = 63 Dez

Dann würde ich nehmen L C#63.
In der Praxis mach ich das nie, ich nehme auch immer hex und wandle das im Notfall. Anbei mal als Grafik, die Hilfe aus Step7, da wird der Unterschied zwischen Dezimal- und BCD-Format gut ersichtlich.

Mit Oktalsystem wollte dir Volker nur verdeutlichen, daß nach 5.7 nicht 5.8 sondern 6.0 folgt, was einen Übertrag darstellt.


----------



## Claudi (4 Februar 2007)

Also das mit LC#63 hätte ich am liebsten auch gemacht, aber wenn ich eben an dieses Bsp mit LC#200 denke, war die zahl 200 eben nicht die zahl mit der danach gerechnet wurde. Da wurde ja dann 512 als Dezzahl draus...

Und wenn ich 63 wieder als dual darstelle, kommt ja nicht 63 wieder daraus...63--> 0110 0011 --> 99 (vgl 200-->0010 0000 0000-->512), zumindest wenn ich das gleiche Schema wie bei der Aufgabe nutze.... Wir hatten das aber nur 1x


Gibt es da keine Regel, was genau nach LC# kommt?


----------



## Ralle (4 Februar 2007)

@Claudi

Schau dir die Grafik an. Ob Dezimal oder BCD, es ist halt eine andere schreibweise.
Bei BCD stellt man mit je 4 Bit eine Zahl dar und schreibt die dann nebeneinander, das ist eigentlich alles.

Bin mir nicht sicher, ob das richtig ist C#200 als 512 Dezimal????
Für mich ist das 200 dezimal, vielleicht kann das jemand anders hier nochmal bestätigen oder widerlegen.


----------



## Unregistrierter gast (4 Februar 2007)

Ralle schrieb:


> @Claudi
> 
> Schau dir die Grafik an. Ob Dezimal oder BCD, es ist halt eine andere schreibweise.
> Bei BCD stellt man mit je 4 Bit eine Zahl dar und schreibt die dann nebeneinander, das ist eigentlich alles.
> ...



c# ist BCD - codiert, lieber Ralle.


----------



## Ralle (4 Februar 2007)

@ug

Also ist C#200 umgerechnet in eine Dezimalzahl nicht 512 Dezimal, sondern 200 Dezimal, richtig?

Zusatz

C#200 repräsentiert die Dezimalzahl 200 in BCD-Schreibweise. Das sind 200 und bleiben 200.
Wenn man diese C#200 in ein Word lädt und sich ansieht, was dies als Dezimalzahl darstellen würde, sind das 512,
aber das darf man natürlich so nicht umrechnen!


----------



## Claudi (4 Februar 2007)

Also unser prof hats halt definitiv so hingeschrieben. Diese ganzen codierungsachen sind mir in der Form schon klar, das man die eine Zahl verschieden darstellen kann.... Das Bsp mit dem 3f haben wir nicht wirklich fertig gemacht..

er hat dann hingeschrieben LC#0110 0011  das wäre ja 63... so find ichs logisch .... aber in der Formatvorlage steht ja LC# 0 bis LC# 999  . das passt irgendwie alles nicht zusammen...

das mit dem LC#200 kam aus der Anweisung: 
LPEW 256
LC#200
/I         // und er wollte uns damit sagen das das PEW durch 512 zu teilen ist


----------



## Ralle (4 Februar 2007)

Claudi schrieb:


> das mit dem LC#200 kam aus der Anweisung:
> LPEW 256
> LC#200
> /I         // und er wollte uns damit sagen das das PEW durch 512 zu teilen ist



Na prima, das ist in etwa so, als wenn er einen Apfel hingeschrieben hat, aber die 27 Kerne im Apfel zum rechnen nehmen will. So bringt er euch ja komplett durcheinander. Er teilt wirklich durch 512, aber wer schreibt denn dann diesen Code dafür ? Das kann nur ein Professor , echt!


----------



## Unregistrierter gast (4 Februar 2007)

Ralle schrieb:


> @ug
> 
> C#200 repräsentiert die Dezimalzahl 200 in BCD-Schreibweise. Das sind 200 und bleiben 200.



Stimmt.

Deswegen heist es ja auch *B*inär *C*odiert *Dezimal*


----------



## Unregistrierter gast (4 Februar 2007)

Ralle schrieb:


> Das kann nur ein Professor , echt!



Glaub ich nicht so ganz.


----------



## Ralle (4 Februar 2007)

@ug

Schick, das erklärt so manches .


----------



## Oberchefe (4 Februar 2007)




----------



## Claudi (4 Februar 2007)

Ralle schrieb:


> Na prima, das ist in etwa so, als wenn er einen Apfel hingeschrieben hat, aber die 27 Kerne im Apfel zum rechnen nehmen will. So bringt er euch ja komplett durcheinander. Er teilt wirklich durch 512, aber wer schreibt denn dann diesen Code dafür ? Das kann nur ein Professor , echt!


 
Also stimmt das jetzt doch mit der Umwandlung in 512? Wieso jetzt? Woran erkenn ich das?


----------



## Ralle (4 Februar 2007)

@Claudi

Wie erklär ich das nur?
Nehmen wir den String "Zweihundert".
Nimm an, irgendein Zähler, braucht einen String-Codierten Input (warum auch immer das so ist) als Startwert. Du nimmst also die Zeichenfolge "Zweihundert" und gibt die vor, schon klappt es, er zählt von 200dez an rückwärts, weil er "weiß", das "Zweihundert" für ihn 200dez bedeutet.
Wenn du aber den String "Zweihundert"  in Hex ansiehst steht da 3F772A0034 (der Hex-Wert ist schnell mal frei erfunden!!!) Diesen Hex-Wert kannst du als auch als Dezimalzahl interpretieren, wenn du willst, da kommt raus *7848364794762347857* (Wert auch frei erfunden!!!). 
Das ist alles.

Dein Prof. hat also folgendes gemacht:

Er wollte eine Zahl durch *7848364794762347857* teilen.
Weil er superklug ist hat er gedacht, ha, das ist doch rein numerisch das gleiche, wie der String "Zweihundert" und hat das für euch so hingeschrieben. Der SPS ist ja egal, was die Bytes, denn wirklich repräsentieren, ob einen String, ein Real, ein Int oder ebend eine BCD-codierte Zahl.

 Ob das einer versteht???? 

PS. Ich hoffe ja auf eNDe, der sollte das erklären können, mit geht da das pädagogische Geschick etwas ab!


----------



## Claudi (5 Februar 2007)

Ich vermute was du meinst, aber woher sollen wir das wissen, das man da so vorgeht. Er hat ja richtig ein Prinzip verwendet, um von 200 auf 512 zu kommen... normaler weise sollte man doch annehmen, das er mit LC#200 die Dezzahl 200 lädt.....


----------



## Claudi (5 Februar 2007)

*Übung*

wenn noch was zum Thema 512 kommt, würd ich mich noch freuen!

ich hab mit nem Komilitonen ein Bsp durch gerechnet! Könntet ihr mich bitte korrigieren, ob falsch/richtig?

Eingänge:
0.7|0.6|0.5|0.4|0.3|0.2|0.1|0.0|1.7|1.6|1.5|1.4|1.3|1.2|1.1|1.0|
0 _ 0__ 0___0__1__0___1__1___ 0__0___0__0___0__0__0___0

Aufgabe:

LEW 0
SLW2
LAR1
LMW 100
TAW(AR1,P#1.4)

Geben sie an,an welche Ausgänge der Steuerung das MW100 ausgegeben wird!

also: LEW 0--> Dez: 2816
SLW 2--> Dez: 11264 in Akku 1
LAR1---> 1408.0
LMW 100 --> Akku1 und 11264 in Akku 2
TAW() --> MW100 wird auf AW gelegt, das mit
Pointer 1409.4 adressiert wird (oder steht die Adresse des AW im AR 1 an stelle 1409.4?)

zu den Ausgängen: also wir haben uns das so gedacht, das man jetzt den Pointer in Dual darstellt: 0101 1000 0001.100 . Lässt man jetzt den Punkt weg, ergäbe sich eine 1 bei den Ausgängen:1.2 1.3 0.2 0.3 0.5.... stimmt diese Theorie?


----------



## Ralle (5 Februar 2007)

@Claudi

3 Fragen erstmal.
1. Veräppelst du uns?
2. Tun das eure Ausbilder mit euch?
3. Haben eure Ausbilder keine Ahnung, was sie da tun?

Zu deiner Frage:

wenn ihr einen Simulator habt testet folgenden Code:


```
L     2#1010101
      T     MW   100

      L     2816
      T     MW     0

      L     MW     0
      SLW   2
      LAR1  
      L     MW   100
//      T     MW [AR1,P#1.4]
      T     MW [AR1,P#0.0]
```
Wenn du diesen Code testest, wird im MW1408 der Inhalt von MW100 stehen. MW0 ist dein EW0, MW1408 ist dein AW1408.
Wenn du die Kommentarstriche "//" löscht und dafür die letzte Zeile auskommentierst, geht deine SPS in STOP.

Fehler: "Ausrichtungfehler beim Schreiben"

Hilfe: 



> Ursache:
> 
> Bei einem Byte-, Wort-, Doppelwortzugriff wurde eine  Bitadresse (Bit 0-2) angegeben.
> 
> ...


Wenn man ein Byte, Wort oder Doppelwort adressieren will, muß P#0.0, P1.0, P2.0 ... angegeben werden ! Nur bei der Adressierung von Bits mit = A[LAR1, P#1.1] darf die Bitadresse <> 0 sein.


----------



## Ralle (5 Februar 2007)

Claudi schrieb:


> Ich vermute was du meinst, aber woher sollen wir das wissen, das man da so vorgeht. Er hat ja richtig ein Prinzip verwendet, um von 200 auf 512 zu kommen... normaler weise sollte man doch annehmen, das er mit LC#200 die Dezzahl 200 lädt.....



Er lädt aber eine BCD-codierte Zahl und die ist dann 512, wenn man einach so mit ihr weiterrechnet. So kann man Leute vollkommen aus dem Konzept bringen oder testen, ob sie verstanden haben. Zugegeben, das ist gemein .


----------



## Claudi (5 Februar 2007)

Ralle schrieb:


> @Claudi
> 
> 3 Fragen erstmal.
> 1. Veräppelst du uns?
> ...


 
zu1: Nein, um Gottest willen! Wir haben nur alle keine Ahnung von dem Stoff! Und Geräte zum Testen haben wir so wie so nicht... Wie kapieren es einfach nicht...

zu 2:weiß ich nicht! aber sie haben uns nicht wrklich was beigebracht. Und unser Prof so wie so nicht, aber eine Prüfung wird eben morgen geschrieben 

zu3:irgendwie schon

Heißt das jetzt, wenn P#0.0 oder irgendwas mit .0 da gestanden hätte, hatte das funktioniert? Wir hätte die Antwort mit den Ausgängen dann ausgesehen?

Wäre schön, wenn hier ne ständig nackte Weiber wären. Ich hab echt ein Problem mit dem Stoff und da ist das einfach mal unpassend....

Und zu der Aufgabe mit der 512: also wenn in einer Anweisung steht Lc#... dann muss ichs umwandeln, aber wie ist das,wenn ich selber die Zahl in LC# Form bringen muss? Alsop das mit den 3F dann?


----------



## Ralle (5 Februar 2007)

@ug

Denke su verstehst die Bitte .

@Claudi

In den Ausgängen hätte das gestanden, was ihr vorher irgendwann einmal in das MW 100 geschrieben habt. Achtung, bei P#0.0 im AW1408, bei P#1.0 im AW1409, das wird dann beim ungeraden beginnen, das funktioniert. Ansonsten wie ich schrieb:


```
L 2#1010101
T MW 100
```
*2#1010101* landet dann einfach im AW1408.
Alle bits im AW1408 sind wie die Bits im MW100.

BCD:

Zum Umwandeln gibts Befehle, siehe hier:
http://www.sps-forum.de/showpost.php?p=70087&postcount=42

Die Tabelle unten zeigt wie es dann aussieht am Beispiel -413. Das kannst du auch zu Fuß haben, immer in 4 Bit steht eine Ziffer deiner Zahl, das ist Alles.


----------



## volker (5 Februar 2007)

> irgendwas mit .0 da gestanden hätte, hatte das funktioniert?


jein.

entscheidend ist diese stelle

T AW [AR1,P#0.2]

AR1 + P#0.2 muss etwas ergeben, was mit .0 endet. sonst cpu=stop
wenn im ar1 jetzt 0.6 stehen würde, wäre das völlig ok da ja 0.6 + 0.2 = 0.8.
da oktalsystem, erfolgt ein übertrag was 1.0 ergeben würde.

*hier klicken*

*klaro?*


----------



## Ralle (5 Februar 2007)

Ah ja, Volker hat vollkommen Recht, so weit hab ich das noch nie getrieben:


```
L     2#1010101
      T     MW   100

      L     2816
      T     MW     0

      L     MW     0
      SLW   2
      L     4                            //das ergibt dann 1408.4
      +D    
      T     MW     4
      LAR1  
      L     MW   100
      T     MW [AR1,P#1.4]
```

Das Ergebnis erscheint dann in AW1410.


----------



## TobiasA (5 Februar 2007)

Hölle. Auf sowas kommt bloß 'n Professor... Und 'n Servicetechniker dreht am Rad. Aber jetzt habe ich das auch mit den Pointern verstanden. Vielen Dank, ihr seid spitze  

Gruß, Tobias


----------



## Claudi (5 Februar 2007)

Oh ja das wird logisch! Danke euch 2en!   Jetzt noch mal ne kleine Randfrage dazu: Was bringt die Addition von P#0.0 (Offset Pointer)? kann man da nicht gleich nur AR1 nehmen?

Für weitere Fragen, werd ich wohl mal ei neues Thema eröffnen....


----------



## volker (5 Februar 2007)

p#0.0 ist ohne funktion. aber die syntax des befehls muss ja eingehalten werden.


----------



## Ralle (5 Februar 2007)

@claudi

Spart ein wenig rechnen, das ist eigentlich alles.
Beispiel Datenbank. 
Du brauchst 3 Werte.
Auf ersten Wert zeigt dein errechnetes AR1.

Dann z.Bsp.


```
L DW[AR1, P#0.0]
T ...
L DW[AR1, P#2.0]
T ...
L DW[AR1, P#4.0]
T ...
```

statt den Pointer immer hochzurechnen und das AR1 neu zu laden.


----------



## Unregistrierter gast (6 Februar 2007)

volker schrieb:


> @ug
> im prinzip steht das schon *hier* in der faq.
> [/COLOR]



Aber nicht der Anhang ! Papp den noch dabei in die FAQ !


----------



## KalEl (6 Februar 2007)

stimmt. ich habe keinen zugriff dadrauf.
habe plc-tippser aber alles nötige geschickt, damit er das reinstellt.


----------

