@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.
Code:
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.
Code:
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.
Code:
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.
Code:
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.
Code:
[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
Code:
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
Code:
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.
