Step 7 Pointer für DB erstellen von Multiinstanz

[Deadmau5]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo,

ich versuche einen aus einem Multiinstanz DB 30 einzelne Bits in einem anderen DB 503 zu verschieben.
Das herauslesen funktioniert, die CPU meldet jedoch einen internen Fehler bei den Pointer-Zeilen (Adressüberschreitung).
Das laden in den 503 funktioniert gar nicht.

Wie würde es richtiger ausschauen? Bin nicht so der Profi wie ihr seht

//--- Pointing first ZM instance
L P#0.0
T #ZM_Adr

L 220                                      //Start adresse
T #ZM_AdrDest


L 64
NEXT: T #ZM_loop
//*** Starting Loop *********

AUF DB 30                                  // Activ DB Read

L #ZM_Adr
//---------------------------
LAR1 

[COLOR=#ff0000]L DBB [AR1,P#25.0]   [/COLOR]               // Load DBB 25 Status
T #ZM_BZM1                          // xxxx xxxx
L B#16#1                               // 0000 0001
UW                                        // ---- ---x 25.0 frg
T #ZM_BZM2                         // 0000 000x

L #ZM_BZM1                         // xxxx xxxx
L B#16#80                          // 1000 0000 
UW                                        // x--- ---- 25.7 SEV
SRW 5                                    // ---- -x--
L #ZM_BZM2                     // 0000 000x
OW 
T #ZM_BZM2                         // 0000 0x0x

[COLOR=#ff0000]L DBB [AR1,P#24.0]    [/COLOR]            // Load DBB 24 Status
T #ZM_BZM1                       // xxxx xxxx
L B#16#1                            // 0000 0001
UW                                  // ---- ---x 24.0 SER
SLW 1                                // ---- --x-
L #ZM_BZM2                         // 0000 0x0x
OW 
T #ZM_BZM2                        // 0000 0xxx

L #ZM_BZM1                           // xxxx xxxx
L B#16#8                           // 0000 1000
UW                                   // ---- x--- 24.3 STO
L #ZM_BZM2                      // 0000 0xxx
OW 
T #ZM_BZM2                       // 0000 xxxx

//--- Pointing next ZM instance

L P#26.0                               // Offset
L #ZM_Adr                           // Adr ZM act
+D                                    // Adr +Offset
T #ZM_Adr                             //=Adr ZM next


[COLOR=#b22222]AUF DB 504                            //Transfer to DB
L #ZM_BZM2
T DBB [#ZM_AdrDest]
L P#1.0
L #ZM_AdrDest
+I [/COLOR][COLOR=#b22222]

// Oder:
[/COLOR][COLOR=#b22222]// L #ZM_AdrDest[/COLOR]
[COLOR=#b22222]// LAR1 [/COLOR]
[COLOR=#b22222]// AUF DB 504[/COLOR]
[COLOR=#b22222]// L #ZM_BZM2[/COLOR]
[COLOR=#b22222]// T DBB [AR1,P#1.0] [/COLOR]



//*** Ending Loop ************
L #ZM_loop
LOOP NEXT

Wäre wirklich dankbar wenn ihr weiter helfen könntet

 

[Larry Laffer]

Hallo,
ich muss gestehen, dass ich aus deinem Code nicht so recht schlau werde.
Beschreib doch mal in Worten, was du von wo laden willst und wohin es dann gespeichert werden soll.
Vielleicht dann auch noch, was so zwischendrin damit passieren soll ...

(ich befürchte, dass es dann von der Code-Umsetzung ggf. ganz anders aussehen würde ...)

Gruß
Larry

 

[RONIN]

Zuviel Werbung?
-> Hier kostenlos registrieren

Also wenn ich deinen Code richtig dechiffriere, dann möchtest du...
Instanz-Bit24.0 auf DbByte-Bit0.1
Instanz-Bit24.3 auf DbByte-Bit0.3
Instanz-Bit25.0 auf DbByte-Bit0.0
Instanz-Bit25.7 auf DbByte-Bit0.2
...schreiben.

Das ganze dann 64mal (laut Wert im Schleifenzähler).
Wie kommst du da auf 30Bits, ich zähl da mehr.

Ist dass der Grund warum du beim Laden eine Adressüberschreitung bekommst?
Die höchste Anfangsadresse für eine Instanz auf welche du hier zugreifen würdest wäre 1638.
Ist dein DB so lang?

Dass das Schreiben in den DB503 (in deinem Code steht 504!!!) nicht klappt ist klar.
Sowohl L DBB[Variable] als auch der Weg über AR1 verlangen Pointer.
Am Anfang lädst du ZM_AdrDest allerdings nur mit 220dez und nicht mit P#220.0
Wenn du mit 220dez arbeitest enspricht das einem P#27.4
Ein Byte-Zugriff auf irgendwas mit einem Bitwert im Pointer führt zum Fehler.

Jetzt zu den ganzen Bit-Geschubse (SRW,SLW).
Du könntest doch gleich direkt die Bits die du willst lesen und schreiben.
Nicht getestet, könnte aber ungefähr so aussehen:

L      P#0.0                      //Startadresse Instanz QuellDB
T      #ZM_Adr
L      P#220.0                      //Startadresse Bytes im ZielDB
T      #ZM_AdrDest

L     64
NEXT: T #ZM_loop

LAR1  #ZM_Adr
AUF   DB30                        //Bits aus Quell-DB lesen
U     DBX[AR1,P#24.0]
=     #Bit24_0
U     DBX[AR1,P#24.3]
=     #Bit24_3
U     DBX[AR1,P#25.0]
=     #Bit24_0
U     DBX[AR1,P#25.7]
=     #Bit24_3

LAR1  #ZM_AdrDes                 //Bits auf Ziel-DB schreiben
AUF   DB504                           //Oder 503?
U     #Bit24_0
=     DBX[AR1,P#0.1]
U     #Bit24_3
=     DBX[AR1,P#0.3]
U     #Bit25_0
=     DBX[AR1,P#0.0]
U     #Bit25_7
=     DBX[AR1,P#0.2]

L     #ZM_Adr                   //Adressen hoch zählen  
L     P#26.0                   
+I
T     #ZM_Adr

L     #ZM_AdrDes  
L     P#1.0
+I
T     #ZM_AdrDes
   
L     #ZM_loop
LOOP  NEXT

Zu guter letzt. Zu Beführworten ist solch ein Bytegeschubse/Speichergestochere generell nicht.
Es ist meist undurchsichtig, fehleranfällig, schwer wartbar und hat keine Querverweise.
Wenn sich irgendwo durch Änderungen mal Adressen verschieben, dann geht alles in die Hose.

Wäre es in diesem Fall nicht einfacher dass du dir dein Bytes innerhalb des Bausteins zusammenflickst zu die Instanz gehört und diese dann per OUT direkt und vor allem symbolisch an das Zielbyte im DB503 schreibst.

Du kannst auch das innerhalb des Bausteins generierte Byte in der Instanz parken und dieses dann ohne Schleife und Adressgemurkse mit einfachen MOVE-Befehlen ans Ziel verschieben.
64 Moves (L/T) sind in AWL schnell getippt.

Das wäre für diejenigen welche dir an dem Projekt nachfolgen sicher leichter zu durchschauen.

 

[Larry Laffer]

@Ronin:
Respekt ...


@TE:
Wenn der Quell- und der Ziel-Datenbereich identisch aussehen dann könnte auch BlockMove noch ein Ansatz sein. Ich würde aber dennoch gerne die verbale Beschreibung sehen ...

 

[Deadmau5]

Sorry für die Verspätung, beim letzen Mal ist mein Antwort-Post sicher nicht "durchgegangen"

Danke sehr für die perfekte Antwort! Ich habe nichts mehr an dem Code ändern müssen.
Der war um einiges einfacher und besser und hat mir sehr weitergeholfen.

"Die höchste Anfangsadresse für eine Instanz auf welche du hier zugreifen würdest wäre 1638.
Ist dein DB so lang?"

->Ja der ist so lang.

​

"Sowohl L DBB[Variable] als auch der Weg über AR1 verlangen Pointer."

->Wieso dieser Teil nicht funktioniert kann ich noch nicht verstehen, ich benutze doch Pointer?
AUF DB 504
L #ZM_BZM2
T DBB [#ZM_AdrDest]
L P#1.0
L #ZM_AdrDest
+I​

 

[PN/DP]

Zuviel Werbung?
-> Hier kostenlos registrieren

->Wieso dieser Teil nicht funktioniert kann ich noch nicht verstehen, ich benutze doch Pointer?
AUF DB 504
L #ZM_BZM2
T DBB [#ZM_AdrDest]
L P#1.0
L #ZM_AdrDest
+I​

Du benutzt den dezimalen Zahlenwert 220 als Pointer --> das entspricht P#27.4 --> das ist eine "krumme" Adresse, auf der kein DBB anfangen kann.
Um den Dezimalwert 220 als Pointer P#220.0 zu benutzen, muß die 220 mit 8 multipliziert werden, was man am cleversten durch 3 Bitstellen nach links shiften macht (SLD 3).

Sowohl L DBB[Variable] als auch der Weg über AR1 verlangen Pointer.
Am Anfang lädst du ZM_AdrDest allerdings nur mit 220dez und nicht mit P#220.0
Wenn du mit 220dez arbeitest enspricht das einem P#27.4
Ein Byte-Zugriff auf irgendwas mit einem Bitwert im Pointer führt zum Fehler.

Harald

 

[Deadmau5]

Ich hatte den Fehler weggemacht und auf P#220 geändert, es wurde aber nichts im DB504 geschrieben. (db503 war ein Tippfehler von mir)
Wenn dieser Programmteil eurer Meinung funktionieren sollte, dann hatte sich vielleicht damals noch irgendwo einen Fehler eingeschlichen