Kann man Zugriffe auf DB's adressieren/ berechnen ?

[mega_ohm]

Zuviel Werbung?
-> Hier kostenlos registrieren

Folgendes Problem:
Ich habe ein Masch.Progi geschrieben, welches EIGENTLICH funktioniert.

Es ist eine Erweiterung einer Anlage.
(Die Doku und E- Pläne müßten angepaßt werden)

Ich habe ein Progi am "Schreibtisch" gebastelt, welches so (wie es ist)
einfach 'fast' perfekt funktioniert.
Leider habe ich mir erst danach die Anbindung in das bestehende Masch.-Progi näher angeschaut. Das war sicher ein Fehler !!


Jetzt folgende Frage>:
(erstmal zum Verständnis ein Teil der Struktur des DB)

DB- Struktur:
Adresse       Name        Typ    Anfangswert      Kommentar
  0.0         Num_Proc    INT    1                Prozeßnummer
  2.0         Pr1_Dat1    REAL   5.500000e+000    Prozeß 1, Daten 1
  6.0         Pr1_Dat2    REAL   4.800000e+000    Prozeß 1, Daten 2
 10.0         Pr1_Dat3    REAL   4.300000e+000    Prozeß 1, Daten 3
 14.0         Pr1_Dat4    REAL   4.000000e+000    Prozeß 1, Daten 4
 18.0         Pr1_Dat5    REAL   3.800000e+000    Prozeß 1, Daten 5
 22.0         Pr2_Dat1    REAL   5.300000e+000    Prozeß 2, Daten 1
 26.0         Pr2_Dat2    REAL   4.800000e+000    Prozeß 2, Daten 2
 30.0         Pr2_Dat3    REAL   4.400000e+000    Prozeß 2, Daten 3
 34.0         Pr2_Dat4    REAL   4.000000e+000    Prozeß 2, Daten 4
 38.0         Pr2_Dat5    REAL   0.000000e+000    Prozeß 2, Daten 5
...
...
...
 82.0         Pr5_Dat1    REAL   4.900000e+000    Prozeß 5, Daten 1
 86.0         Pr5_Dat2    REAL   4.630000e+000    Prozeß 5, Daten 2
 90.0         Pr5_Dat3    REAL   0.000000e+000    Prozeß 5, Daten 3
 94.0         Pr5_Dat4    REAL   0.000000e+000    Prozeß 5, Daten 4
 98.0         Pr5_Dat5    REAL   0.000000e+000    Prozeß 5, Daten 5
...
...
...

Jetzt meine Frage:
Diesen DB würde ich folgend 'auseinander' pflücken:
- Ich würde die 'Num-Proc' (Adresse 0.0) prüfen

Gibt es eine Möglichkeit, diese Adi als Multiplikator zu verwenden ??
z.B.:
DB1.?variable?

db1?variable? = db1. dbw * db1.dbw0 ????

Mich springt diese Idee förmlich an, weil die Datenstruktur [real] ja auch immer die gleiche ist....

Die Struktur des DB wiederholt sich. Ich möchte (natürlich könnte ich das)
nicht 20x diesen DB vergleichen, nur um zu bestimmen, welche Eingaben
für mich relevant sind.

An dem DB kann und darf ich nix ändern. Es ist vergleichbar mit einer 'Rezeptur'.
Mittels dieses DB's wird die Drehzahl mehrerer Antriebe gesteuert, Statistik geführt...

 

[Andy]

Indirekte Adressierung:
L 4 //Adressensprung
L DB1.DBW 0 //Multiplikator 0,1,2,3,4,5,6,7,8
*I
L 2 //Anfangsadresse DBD 2
+I
SLW 3
T MD 30
AUF DB 1
L DBD [MD 30]

 

[godi]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo!

Ich würds übers Adressregister machen.

L 4 //Adressensprung
L DB1.DBW 0 //Multiplikator 0,1,2,3,4,5,6,7,8
*I 
SLW 3  //Bilde Pointer
LAR 1   //Schreibe Pointer in Adressregister 1
AUF DB1 //Dieser Bausteinaufruf ist nicht unbedingt erforderlich weil Baustein in 2ter Zeile aufgemacht wurde
L DBD [AR1,P#2.0]  //bei P#2.0 kannst du dein Offset einstellen (in deinem Fall 2.0 => 2Byte

 

[Larry Laffer]

Hallo,
in deinem Fall bildet sich der Adresszeiger m.E. aus 2 Angaben : Prozess_Nummer und Datensatz_Nr.
D.h. du müßtest diese beiden Angaben irgendwo stehen haben. Daraus würde ich dann den Pointer berechnen in Anlehnung an den Vorschlag von Andy :
L Prozess_Nr
L 1
- 1
L 20 // 1 Block sind 20 Byte
* I
SLW 3
T hPointer

L Datensatz_Nr
L 1
- I
L 4 // 1 Block sind 4 Byte
* I
L 2 // Pointer 2 Byte weitersetzen wegen "Num_Proc"
+ I
SLW 3
L hPointer
+I
T hPointer

und nun zum Auslesen der Speicher-Adresse

AUF DB xyz
L DBD [hPointer]
T Hilfsvariable

oder zum hereinschreiben in selbige

AUF DB xyz
L Hilfsvariable
T DBD [hPointer]

 

[Ralle]

@Alle
Ok, alles richtig, aber bitte beachten, ein Pointer ist ein DWord. Man kann zwar mit 16-Bit-Operationen arbeiten (*I, +I, SLW3...), aber ab einer bestimmten Sprungweite gibt es dann Probleme, weil das nicht meht in ein Word paßt!

Bis hierher alles mit 16-Bit-Operatinen berechnen, dann

L My_Adresse (INT) //berechnete Adresse für den Datensatz
ITD //wandeln 16-Bit nach 32-Bit
SLD 3 //Der Pointer ist ein DWord, kein Word!
T hPointer (DWord)

AUF DBx
L DBD [hPointer]

oder

LAR 1
AUF DBx
L DBD [AR1, #P0.0]

 

[godi]

Zuviel Werbung?
-> Hier kostenlos registrieren

@Alle
Ok, alles richtig, aber bitte beachten, ein Pointer ist ein DWord. Man kann zwar mit 16-Bit-Operationen arbeiten (*I, +I, SLW3...), aber ab einer bestimmten Sprungweite gibt es dann Probleme, weil das nicht meht in ein Word paßt!

Bis hierher alles mit 16-Bit-Operatinen berechnen, dann

L My_Adresse (INT) //berechnete Adresse für den Datensatz
ITD //wandeln 16-Bit nach 32-Bit
SLD 3 //Der Pointer ist ein DWord, kein Word!
T hPointer (DWord)

AUF DBx
L DBD [hPointer]

oder

LAR 1
AUF DBx
L DBD [AR1, #P0.0]

Ups ist mir entgangen....

godi

 

[mega_ohm]

Indirekte Adressierung:
L 4 //Adressensprung
L DB1.DBW 0 //Multiplikator 0,1,2,3,4,5,6,7,8
*I
L 2 //Anfangsadresse DBD 2
+I
SLW 3
T MD 30
AUF DB 1
L DBD [MD 30]

Wieso ???

L 4 //Adressensprung....

(warum muß ich ausgerechnet eine 4 laden ???
Die Adresse der 1. Einstellung ist doch db???.dbd2 )


L DB1.DBW 0 //Multiplikator 0,1,2,3,4,5,6,7,8
*I
L 2 //Anfangsadresse DBD 2
+I
SLW 3
T MD 30
AUF DB 1
L DBD [MD 30]


Könntest Du Deine Lösung (ich konnte sie noch nicht testen) Anfängern erklären ??? Gaanz laaangsam... so das auch ich sie verstehe?

 

[mega_ohm]

Hallo!

Ich würds übers Adressregister machen.

L 4 //Adressensprung
L DB1.DBW 0 //Multiplikator 0,1,2,3,4,5,6,7,8
*I 
SLW 3  //Bilde Pointer
LAR 1   //Schreibe Pointer in Adressregister 1
AUF DB1 //Dieser Bausteinaufruf ist nicht unbedingt erforderlich weil Baustein in 2ter Zeile aufgemacht wurde
L DBD [AR1,P#2.0]  //bei P#2.0 kannst du dein Offset einstellen (in deinem Fall 2.0 => 2Byte

Ja.... ich glaube, einen grundsätzlichen Fehler für mein Progi erkannt zu haben.
Mein Bit 0.0 --- 0.3 ist für >aktiv< verantwortlich.
Mein Bit 0.4 --- 0.7 speichert die Fehler von Bit 0.0 bis 0.3 ...
Ich befand, daß ist eine sehr bequeme Lösung.
Dementsprechend funktioniert >SLW< natürlich überhaupt nicht. Meine "Fehler-Bits" würden im Nirvana verschwinden.

Na gut...

Dann muß ich eben die Datenstrukturen nochmal überdenken.
(Für den Zugriff auf z.B. db1.dbd2 waren meine Gedanken nicht die 'schlechtesten', aber nicht dynamisch)

 

[Larry Laffer]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo Mega_Ohm,
das ist bis jetzt noch kein Widerspruch ... du kannst deine Fehler-Bits ja ausmaskieren ...

Wenn du deinen DB aber noch mal neu machen möchtest, dann ginge das auch so wie in beiliegenden PDF's (Die eine zeigt die Deklarations-Sicht des DB , die anderen die Datensicht der Deklaration). Im Endergebnis das gleiche, was du schon hattest, aber flexibler für Änderungen / Erweiterungen ...

 

[Ralle]

Ja.... ich glaube, einen grundsätzlichen Fehler für mein Progi erkannt zu haben.
Mein Bit 0.0 --- 0.3 ist für >aktiv< verantwortlich.
Mein Bit 0.4 --- 0.7 speichert die Fehler von Bit 0.0 bis 0.3 ...
Ich befand, daß ist eine sehr bequeme Lösung.
Dementsprechend funktioniert >SLW< natürlich überhaupt nicht. Meine "Fehler-Bits" würden im Nirvana verschwinden.

Na gut...

Dann muß ich eben die Datenstrukturen nochmal überdenken.
(Für den Zugriff auf z.B. db1.dbd2 waren meine Gedanken nicht die 'schlechtesten', aber nicht dynamisch)

Bist du sicher, daß du wirklich richtig verstanden hast, was da gemacht wird? Mit SLW3, bzw. SLD3 werden nicht deine Datenbits verschoben, sondern die berechnete Adresse deiner Daten wird in das Pointerformat überführt! Siehe in der Forumsuche unter "indirekte Adressierung" bzw. in der FAQ.

 

[Larry Laffer]

@Ralle : ich habe das so verstanden, dass die Bits in der Index-Variablen (Prozess_Nr) am Kopf liegen. Sonst hast du natürlich vollkommen recht ...!