DB indirekt beschreiben

lounsome

Level-1
Beiträge
41
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

folgendes Problem:

ich habe zwei DB´s in einem DB werden Daten (DB20.DBW0 bis DB20.DBW500) abgelegt, diese muss ich weiter verarbeiten.
Je 4 bit ergeben mein ASCII.

Bis jetzt sieht es so aus:

Code:
U DB20.DBx 0.3 
S M200.0

U DB20.DBx 0.2 
S M200.1

U DB20.DBx 0.1 
S M200.2

U DB20.DBx 0.0 
S M200.3

L MB200
L 48                   //lt. ASCII-Tabelle
+I

L MB 200
T DB 21.DBB0    //erstes ASCII

L 0
T MB 200
// usw.


könnte man das nicht irgendwie in eine Schleife packen, das ganze 2000 mal schreiben ist ja Wahn.

Gruß lounsome
 
Geht das mit DB20.DBX 0.4 oder DB20.DBX 1.0 weiter ?

Ach, ja die gute alte Schmiermerkerzeit ab Merkerwort 200 in der S5 - habe ich schon lange nicht mehr gesehen. Das muss man so nicht mehr machen, dafür gibt es die temporäre Variablen.
 
Also wenn das Schmiermerker sind ist das mit dem Setzebefehl eher ungünstig. Solltest vorher vielleicht das Byte ablöschen.
Und was soll das:

L MB200
L 48 //lt. ASCII-Tabelle
+I ? danach verwirfst Du das ganze. Aber Du wolltest wissen wie es auch geht ohne das Ganze 500 mal zu schreiben. L 0 T #Alarmz // Schmiermerkerdoppelwort anf: NOP 0 L #Alarmz L L#1 +D T #Alarmz // Schleifenzähler L P#0.0
L #Alarmz +D LAR1 AUF DB20 U DBX [AR1,P#0.0] L P#0.0L #Alarmz
+D
LAR1
AUF DB21
= DBX [AR1,P#0.0]

L #Alarmz
L L#500 // L#100
<D
SPB anf // Wenn 500 abgearbeitet Schleife ende
So in etwa. Ich weiss jetzt aber nicht was mit dem +48 bezweckt wird. Im moment wird einfach nur ein Bit vom DB20 auf Db21 umgeschaufelt. Das müsste man halt noch dementsprechend anpassen. Ist nur ein Beispiel für einen Schleifenzähler mit indirekter Adressierung. Mein Beispiel überspringt jetzt auch das Byte 0.
 
Hilfe.... das Format ist verschwunden beim Posten.
L 0 T #Alarmz // Schmiermerkerdoppelwort
anf: NOP 0
L #Alarmz
L L#1
+D
T #Alarmz // Schleifenzähler L P#0.0
L #Alarmz
+D
LAR1
AUF DB20
U DBX [AR1,P#0.0]
L P#0.0
L #Alarmz
+D
LAR1
AUF DB21
= DBX [AR1,P#0.0]

L #Alarmz
L L#500 // L#100
<D
SPB anf // Wenn 500 abgearbeitet Schleife ende
 
Zuviel Werbung?
-> Hier kostenlos registrieren
ich kriege die Krise
L 0
T #Alarmz // Schmiermerkerdoppelwort
anf: NOP 0
L #Alarmz
L L#1
+D
T #Alarmz // Schleifenzähler L P#0.0
L #Alarmz
+D
LAR1
AUF DB20
U DBX [AR1,P#0.0]
L P#0.0
L #Alarmz
+D
LAR1
AUF DB21
= DBX [AR1,P#0.0]

L #Alarmz
L L#500 // L#100
<D
SPB anf // Wenn 500 abgearbeitet Schleife ende
 
Ich weiss jetzt aber nicht was mit dem +48 bezweckt wird.

Hallo Uwe, so ändert man den Bytewert einer Zahl in den ASCII-Wert um. Siehe ASCII-Tabelle.

Ach ja, da gibt es eine Vorschau-Funktion, damit Du Dir das Format ansehen kannst, bevor Du die Antwort postest. Einfach mal auf "Erweitert" klicken und dann auf "Vorschau". Da gibt es auch ein Symbol "#" (Code) in der Symbolleiste, damit kannst Du Quellcode einbetten.
 
Zuletzt bearbeitet:
Leute, vielen dank schon mal.
Aber irgendwie check ich das nicht ganz,
mit dem Code kopiere ich doch nur von einem DB in den anderen, oder?
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Danke für den Tip. Hmm. Dann wird das Bitbearbeite eher nix.
Ich habe mit Ascii nicht oft was zu tun. Aber es ist doch so dass ein Byte ein Zeichen ist, oder?
Byteweise würde das dann doch so aussehen:
L #Schmierwort /diesmal Integer
SLW 3
T #Schmier1
AUF DB20
L DBB [#Schmier1]
L 48
+i
t #schmierbyte2
L #Schmierwort /diesmal Integer
SLW 3
T #Schmier1
AUF DB21
l#schmierbyte2
T DBB [#Schmier1]
sorry dass mit der Vorschau finde ich nicht.
Das wäre jetzt einfach nur Byte DB20 + 48 nach DB21.
Das Ganze müsste dann noch in die Schleife eingebettet werden. Wobei der Schleifenzähler dann in Integer umgebaut werden muss.
 
... mit dem Code kopiere ich doch nur von einem DB in den anderen, oder?

Hallo,
das würde ich auch so sehen.
Ich würde solche Konstrukte heute nicht mehr in AWL sondern in SCL machen. Vielleicht solltest du auch darüber nachdenken.

Wenn es aber AWL sein soll, dann mußt du mit 2 Zeigern (einen für die Quelldaten und einen für die Zieldaten) arbeiten - würde ich jedenfalls so machen ...
Dann würde ich mir nicht die Bits einzeln laden sondern gleich das erste Byte. Hier maskierst du dann die unteren 4 Bits mit "L w#16#F" und "UW" aus. Auf das Ergebnis dann die Hex 30 oder dezimal 48 draufaddieren. Das (neue) Byte dann wegschreiben und den Schreibzeiger um P#1.0 erhöhen. Nun nochmal das gleiche Quellbyte laden und mit "SRW 4" und "L w#16#F" und "UW" die oberen 4 Bit ausmaskieren. Damit dann verfahren wie vorher. Nun Lesezeiger um "P#1.0" erhöhen und das Ganze wiederholen bis du alle Bytes geschrieben hast.

Gruß
Larry
 
Hallo,
das würde ich auch so sehen.
Ich würde solche Konstrukte heute nicht mehr in AWL sondern in SCL machen. Vielleicht solltest du auch darüber nachdenken.

Wenn es aber AWL sein soll, dann mußt du mit 2 Zeigern (einen für die Quelldaten und einen für die Zieldaten) arbeiten - würde ich jedenfalls so machen ...
Dann würde ich mir nicht die Bits einzeln laden sondern gleich das erste Byte. Hier maskierst du dann die unteren 4 Bits mit "L w#16#F" und "UW" aus. Auf das Ergebnis dann die Hex 30 oder dezimal 48 draufaddieren. Das (neue) Byte dann wegschreiben und den Schreibzeiger um P#1.0 erhöhen. Nun nochmal das gleiche Quellbyte laden und mit "SRW 4" und "L w#16#F" und "UW" die oberen 4 Bit ausmaskieren. Damit dann verfahren wie vorher. Nun Lesezeiger um "P#1.0" erhöhen und das Ganze wiederholen bis du alle Bytes geschrieben hast.

Gruß
Larry

Meine volle Zustimmung...
 
Hallo,
hab gerade Nachtschicht und Ausnahmsweise etwas Zeit :lol:

Code:
     FUNCTION FC 2 : VOID
TITLE =
VERSION : 0.1

VAR_INPUT
  Startpos_DB : BLOCK_DB ; 
  Startpos_Pos : INT ; 
  Zielpos_DB : BLOCK_DB ; 
  Zielpos_Pos : INT ; 
  Laenge : INT ; 
  Start : BOOL ; 
END_VAR
VAR_TEMP
  Hilfsdoppel : DINT ; 
  Hilfsdoppel_2 : DINT ; 
  Speicherzelle : BYTE ; 
  Speicherzelle_2 : BYTE ; 
  Durchlaeufe : INT ; 
END_VAR
BEGIN
NETWORK
TITLE =

//----------Startbedingung 

     U     #Start; 
      SPBN  ende; 
      L     #Startpos_Pos; //Lade die Byteadresse der Startposition
      T     #Hilfsdoppel; //Zwischenspeichern
      L     #Zielpos_Pos; //Lade die Byteadresse der Zielposition
      T     #Hilfsdoppel_2; //Zwischenspeichern
      L     0; //Lade 0
      T     #Durchlaeufe; //nullen der Durchläufe

// -----------Schleife lesen der Werte
loop: AUF   #Startpos_DB; //Öffnen des Start DB´s
      L     #Hilfsdoppel; //Lade Zwischenspeicher Startpos
      SLD   3; //schiebe links Pointerformat
      LAR1  ; //in Adressregister schieben
      L     DBB [AR1,P#0.0]; //Lade erstes Byte des Zwischenspeichers
      L     B#16#F; //maskieren der unteren 4 Bit
      UW    ; //verunden
      L     B#16#30; //für ASCI +48
      +I    ; //addition
      T     #Speicherzelle; //transfer in Speicherelle
      L     DBB [AR1,P#0.0]; //Lade Zwischenspeicher Startpos
      SRW   4; //schiebe rechts für die linken 4 Bit
      L     B#16#F; //maskieren
      UW    ; //verunden
      L     B#16#30; //für ASCI +48
      +I    ; //addition
      T     #Speicherzelle_2; //transfer in Speicherelle_2

//------------schreiben auf Zielbereich
 
      AUF   #Zielpos_DB; //Öffnen des Start DB´s
      L     #Hilfsdoppel_2; //Lade Zwischenspeicher Zielpos
      SLD   3; //schiebe links Pointerformat
      LAR1  ; //in Adressregister schieben
      L     #Speicherzelle; //Laden der ersten Speicherzelle
      T     DBB [AR1,P#0.0]; //Transfer nach Zielpos erstes Byte
      L     #Speicherzelle_2; //Laden der zweiten Speicherzelle
      T     DBB [AR1,P#1.0]; //Transfer nach Zielpos zweites Byte

//-------Offset für Schleife einrichten

      L     #Hilfsdoppel; //Lade Hilfsdoppelwort für Offset
      L     1; //Lade 1 zum erhöhen des Offsets Byte 
      +D    ; //addition
      T     #Hilfsdoppel; //Transfer nach Hilfsdoppelwort für Offset
    
  L     #Hilfsdoppel_2; //Lade Hilfsdoppelwort für Offset
      L     2; //Lade 2 Byte für Wortoperation
      +D    ; //addition
      T     #Hilfsdoppel_2; //Transfer nach Hilfsdoppelwort für Offset

//incrementieren des Schleifenzählers
    
  L     #Durchlaeufe; //Lade Anzahl der bisherigen Durchläufe 
      L     1; //Lade 1
      +I    ; //addition
      T     #Durchlaeufe; //Transfer nach bisherige Durchläufe

//------ prüfen der Anzahl Durchläufe für Abbruchbedingung    
   
L     #Laenge; //Lade Bausteinlänge
      L     #Durchlaeufe; //Lade bisherige Durchläufe
      >=I   ; //vergleich auf größer gleich
      SPB   loop; //Sprunbedingung für Schleifendurchlauf

//----nullen der Speicher nach Schleifendurchlauf

      L     0; //laden Wert null
      T     #Speicherzelle; //nullen der Speicherzelle
      T     #Speicherzelle_2; //nullen der Speicherzelle
ende: NOP   0; 


END_FUNCTION

bitte vorher Testen übernehme keine Garantie, @Larry kannst du nochmal drüber
schauen ? Danke


gruß Thomas
 
Zuletzt bearbeitet:
@Thomas:
Ich habe mal drüber geschaut, finde den AWL-Code sehr schön und vor Allem : "sehr schön dokumentiert" und nach meiner Einschätzung kann das funktionieren. Das Weitere sollte dann aber (wie du auch schreibst) halt ein Test ergeben ...

Gruß
Larry
 
Zuviel Werbung?
-> Hier kostenlos registrieren
@thomas_1975 & Larry Laffer

ganz großes Mercy
:s17:, ich werd das leider erst nächsten Montag testen können,
bin auf einer Inbetriebnahme und hab den RFID-Leser nicht dabei.

Melde mich dann wens funktioniert.

Gruß lounsome
 
Zurück
Oben