Schieberegister Positionsbestimmung

Florin

Level-1
Beiträge
22
Reaktionspunkte
1
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Zusammen

Ich habe ein Förderband von 10 Meter Länge mit einem Sensor am Eingang. Auf diesem Förderband werden Dinge transportiert,
und ich muss zu jedem Zeitpunkt wissen, wo auf dem Band etwas ist.
Ich dachte, ich teile dem Band 100 Bits aus einem Array zu, also pro 10cm 1 Bit.
Wird der Sensor aktiviert, setze ich das erste Bit.
Bei einer Bandgeschwindigkeit von 10cm/s schiebe ich pro Sekunde das Schieberegister einmal hoch,
und so sehe ich dann zB nach 37 Sekunden, dass das Bit Nr. 37 "True" ist, sich also bei 3.70m etwas befindet.

Leider weiss ich nicht, wie ich das mit der indirekten Adressierung realisieren kann.
Ich arbeite mit AWL, S7.

Ich muss das zweithöchste Bit des Arrays in einen Pointer stecken, dieses prüfen, dann je nach Status das nächste Bit setzen/rücksetzen.
Danach muss ich den Bit-Pointer um eins verringern und es geht von vorne los. Bin ich bei Bit 1 angekommen, resette ich dieses und verlasse den Loop.


Pointererstellung stelle ich mir so vor:
l p#5080.2 // Bit nr99
lar 1

Das Prüfen so:
U DBX [AR1,P#0.0]

Mir ist jetzt allerdings unklar, wie ich

- den Pointer um 1 reduziere
- den Offset verändere, dass ich das nächsthöhere Bit setzen kann, ohne den Pointer zu ändern.

Ich hoffe, jemand kann mir helfen und vielen Dank :)

MfG
Florin


-------
Nachtrag:
Wie ich den Offset verändere, ist mir eigentlich klar, zb: U DBX [AR1,P#0.1]
 
Zuletzt bearbeitet:
Sie dir das hier mal an: SLD/SRD für 64 Bit? Da gibt es eine Lösungen für das Schieben von Bits über 64 Bit. Das kann man noch erweitern, irgendwo im Forum gibt es noch mehr davon.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Braucht man hier LAR überhaupt? Ich bin da auch nicht so fit. Vielleicht ist es mit LAR leichter aber ich würde es so versuchen:

L P#5080.2
T #Position

und dann mit
AUF DB100
U DBX[#Position]
die Positionen abfragen. Damit müsste es eigentlich ganz einfach sein, wenn ich nicht etwas wichtiges übersehe.

Den Pointer reduzierst oder erhöhst du dann einfach mit:
L #Position
L 1
+D oder -D
T #Position
oder
T #Offset

Edit: Ich habe Ralles Lösungsvorschlag jetzt erst verstanden. Das wäre auf jedenfall besser (Zykluszeit) und eleganter, wenn du das mit SLD oder SRD hinbekommst!
 
Zuletzt bearbeitet:
Danke euch Beiden

Nach dem, was Marius gepostet hat, habe ich gesucht.
Allerdings stimmts, wenn ich das ganze Array schiebe ist das simpler!
Werde mir das mal genau anschauen..

Nochmals Danke,
Liebe Grüsse
 
ungenau wird es mit beiden Methoden von selbst.
Wenn dann würde ich wenigsten irgendwie mittels einem Positionsschalter versuchen eine definierte Position zu finden wenn ein Teil aufgelegt wird oder wenn das Antriebsrad eine Umdrehung gemacht hat.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Wozu ist das Schieben gut? Warum nicht einfach einen Zähler hochzählen? Falls du alle 100 Bits auswerten willst, hat das Schieberegister wohl einen Sinn. Falls du aber einfach nur bei position 57 etwas besonderes hast und wissen willst, ob dein Fördergut dort angekommen ist, prüfst du einfach ob Zähler=57.
Generell gilt: (Bit n im Schieberegister gesetzt) ist identisch mit (Zähler=n).
Wenn du nun mehrere Dinge (Marken, Ereignisse,...) zugleich schieben möchtest(mußt): Ein Schieberegister kann zwei oder mehr Einsen schieben, sofern sie nicht auf derselben Position sind. Bei Zählern einfach mehrere Zähler (einen pro durchlaufende Sache) verwenden. Hat den Vorteil, dass man auch noch eindeutig jede ihrem Zähler zuordnen kann...
 
Aber im Extremfall bräuchte er 100 Zähler.
Da er nur wissen muss, ob an einer Position was ist oder nicht, und nicht was da ist, ist das mit dem Bit-Schieben von Ralle m.M.n. am Besten geeignet.

Ich würde aber Boxys Hinweis umsetzen und nicht versuchen die Geschwindigkeiten zw. Band und Schieberegister zu synchronisieren. Besser ist sicher z.B. an der Umlenkrolle zu erfassen, wann sich das Band wirklich um 10cm bewegt hat, um dann über einen realen Impuls weiter zu schieben.
 
Ich nutze ja sowas immer zum Lernen. Deshalb hätte ich da mal 'ne Frage:

Dieses Schieberegister (128 Bit) würde ich unter KOP so aufbauen:



und würde das Ganze dann (mittlerweile) folgenderweise in AWL umsetzen:
Code:
[FONT=courier new]      U     #Schieben
[/FONT][FONT=courier new]      FP    #FM[0][/FONT]
[FONT=courier new]      SPBN  Ende[/FONT]

[FONT=courier new]Pos0: L     #Position_A[0][/FONT]
[FONT=courier new]      SLD   1[/FONT]
[FONT=courier new]      T     #Position_A[0][/FONT]

[FONT=courier new]Pos1: L     #Position_A[1][/FONT]
[FONT=courier new]      RLDA  [/FONT]
[FONT=courier new]      T     #Position_A[1][/FONT]

[FONT=courier new]Pos2: L     #Position_A[2][/FONT]
[FONT=courier new]      RLDA  [/FONT]
[FONT=courier new]      T     #Position_A[2][/FONT]

[FONT=courier new]Pos3: L     #Position_A[3][/FONT]
[FONT=courier new]      RLDA  [/FONT]
[FONT=courier new]      T     #Position_A[3][/FONT]

[FONT=courier new]Neu:  U     #Sensor[/FONT]
[FONT=courier new]      SPBN  Ende[/FONT]
[FONT=courier new]      L     #Position_A[0][/FONT]
[FONT=courier new]      OD    DW#16#1[/FONT]
[FONT=courier new]      T     #Position_A[0][/FONT]

[FONT=courier new]Ende: NOP   0[/FONT]

Der Ablauf von Pos0 bis Pos3 ist ja im Grunde immer der Gleiche bis auf den Index des Positions-DW. Kann man das unter AWL als Schleife anlegen, sprich den Index als Variable (außer über AR-Pointer) und wenn ja, wie ist dann der korrekte Syntax? In SCL geht das ja relativ einfach, aber für AWL hab' ich dazu leider nichts in der Hilfe gefunden.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo zusammen
Danke nochmals für eure Antworten.
Das mit dem Inkrementalgeber am Antrieb ist eine gute Idee, vielen Dank.

Freundliche Grüsse
 
Zurück
Oben