Achsbewegung (REAL oder INT) in BOOL ausgeben

MunoRodriguez

Level-1
Beiträge
13
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo zusammen,
als blutiger Anfänger (im Rahmen einer Hausarbeit) habe ich mir die Finger wund gegoogelt und bin meinem Ergebnis kein Stück näher gekommen... Vielleicht gibt es hier Hilfe!

Ich bilde mir ein mein Problem zu verstehen und auch beschreiben zu können, habe jedoch keinerlei Idee wie ich es in CoDeSys (2.3) umsetzen kann!

Es soll überprüft werden, ob sich ein Roboter auf einer Achse bewegt oder nicht. Ich habe in AS ein Mini-Programm geschrieben, dass den Roboter auf der X/Y-Achse (mit gleichem Vorschub) bewegt (bis X=Y=300) und dann von dort wieder zum Ausgangspunkt (X=Y=0) zurück bewegt.

Nun würde ich gerne zwei boolsche Variablen haben:
X+ (*Variable ist TRUE, wenn der Roboter in Richtung positiver X-Achse verfährt*)
X- (*Variable ist TRUE, wenn der Roboter in Richtung negativer X-Achse verfährt*)

Den aktuellen Positionswert habe ich in meinem "AS-Mini-Programm" und kann diesen auch in das "FUP-Hauptprogramm" übernehmen, aber ich weiß net wogegen ich vergleichen soll oder wie ich sonst einer bool Variable sagen kann: "Schau ob sich der Wert verändert und wenn er größer wird sei TRUE" (um es mal umgangssprachlich zu formulieren im Falle der X+ Variable).

Ich hoffe dass irgendjemand trotz unfachmännischer Beschreibung mein Problem versteht und mir weiterhelfen kann.

Grüße,
Mund Rodriguez
 
Nun würde ich gerne zwei boolsche Variablen haben:
X+ (*Variable ist TRUE, wenn der Roboter in Richtung positiver X-Achse verfährt*)
X- (*Variable ist TRUE, wenn der Roboter in Richtung negativer X-Achse verfährt*)

Den aktuellen Positionswert habe ich in meinem "AS-Mini-Programm" und kann diesen auch in das "FUP-Hauptprogramm" übernehmen, aber ich weiß net wogegen ich vergleichen soll oder wie ich sonst einer bool Variable sagen kann: "Schau ob sich der Wert verändert und wenn er größer wird sei TRUE" (um es mal umgangssprachlich zu formulieren im Falle der X+ Variable).
Als erstes brauchst du eine statische (globale) Variable im gleichen Format wie die Position der Achse und benennst sie meinetwegen als "Altwert".
Mit "Start" wird die Istposition auf den Altwert geschrieben.
Nun wird entweder pro Zyklus oder pro einer beliebigen Zeiteinheit verglichen ob die Position größer oder kleiner als der Altwert ist und dementsprechend wird das Bit "X+" oder "X-" gesetzt.
Nach dem Vergleich wird die aktuelle Position wieder auf den Altwert geschrieben und der Vergleich startet nun im nächsten Zyklus oder nächsten Zeittakt erneut.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Paule,
erst mal herzlichen Dank für die schnelle Antwort!
Ich befürchte aber, dass ich noch ein bisschen weitere Unterstützung benötige.
Ich habe nun eine globale Variable "xPosAltwert" angelegt.
Dieser Wert verläuft (wie er soll) analog zum X-Wert. Soweit so gut.

Nun denke ich, dass ich den von dir angesprochene "Vergleich" in irgendeiner Form über die Operatoren LT, GT und EQ abbilden können sollte, oder?

Mir ist aber in jedem Fall noch nicht klar, wie ich den Wert (in einem bestimmten Intervall) speichere und danach zurücksetze. Ich habe mich gerade (mal wieder) versucht im Handbuch schlau zu machen und bin dabei auf die "Watschlist" gestoßen. Weiter gebracht hat es mich aber auch nicht... :-(

Wenn du mir nochmal ein bisschen Support geben könntest, wäre ich dankbar!

Grüße, MR
 
Auf die schnelle mal ein Codeschnipsel, ich hoffe er hilft dir weiter:
Code:
// xPos Altwert initialisieren
   IF Achse_Start AND NOT Achse_Ein THEN
        Achse_Ein := TRUE;
        xPosAltwert := xPos;
   END_IF;
 
// Abfrage über Zyklus oder Zeittakt
   IF Abfrage THEN
 
        X- := FALSE:
        X+ :=FALSE;
 
        IF xPos < xPosAltwert THEN
             X- := TRUE;    
        ELSIF xPos > xPosAltwert THEN
             X+ := TRUE;
        END_IF;
 
// Neue Position auf Altwert schreiben 
        xPosAltwert := xPos;
 
   END_IF;
 
Hallo Paule,
vielen Dank!
Da wir in FUP arbeiten müssen fällt es mir ein bisschen schwer deinen Code in ST (?) zu lesen, aber ich denke ich kann es im groben nachvollziehen, was da passiert bzw. passieren soll.
Ich habe aber keinen Ansatz, wie ich das in FUP umsetzen kann. :-(
Mir fehlt vor allem das Verständnis, wie ich den Wert in bestimmten Intervallen (z.B. 1 x pro Sekunde) "speichern" kann um dann den aktuellen Wert damit zu vergleichen.
Ich habe den Kern des Problems nun mal in ein eigenes Projekt geladen und davon einen Screenshot gemacht. Vielleicht hilft das ja.

Grüße, MR
 

Anhänge

  • Test.JPG
    Test.JPG
    191,4 KB · Aufrufe: 31
Zuviel Werbung?
-> Hier kostenlos registrieren
Hier ist noch ein weiterer Shot mit einem Teil deines Codes.
Es scheitert aber (wie gesagt) daran, dass xPos und xPosAltwert ja bisher die gleichen Werte sind...:cry:
 

Anhänge

  • Test2.JPG
    Test2.JPG
    243,6 KB · Aufrufe: 19
Ich habe die Funktion nun über den Baustein "SEL" realisiert.
Ein vorgeschalteter Baustein SEL liefert das TRUE/FALSE Eingangssignal für den SEL-Baustein und dieser schreibt dann den Wert weg.
So kann ich den aktuellen und den weggeschriebenen Wert vergleichen.
Versuche nun das aus meiner Bastellösung in das Original zu übertragen. Dann muss ich noch das blinken abstellen, so dass ich ein Dauersignal habe. Danke für die Hilfe!
 
Hallo Muno,

du hast oben geschrieben, du sollst mit FUP arbeiten. Dein letzter Screenshot hat ein AS-Teil und einen ST-Teil.

Denke mal an die FUP-Bausteine, EQ (Vergleich zweier Werte auf gleich), LE (kleiner gleich) und GE (größer gleich).

Gruß, Voxe
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Voxe,
über die Bausteine hatte ich ja weiter oben schon geschrieben.
Hier ein aktueller Shot, wie ich es realisiert habe. Fachmännisch ist das aller Voraussicht nach nicht, ist aber auch mein erstes "Projekt"...
Den AS Teil benötige ich (nach meinem Verständnis) damit sich auch was "bewegt" (Verfahrbefehl für Roboter).
Der ST Teil war nur ein eingelesener Teil des Codes von Paule (siehe oben).
Nach wie vor habe ich aber das Problem, dass die Signale "move..." nicht gehalten werden, sondern (in Abhängigkeit vom Impuls) blinken. Diesen Impuls benötige ich (bei meinen Kenntnissen) aber, da ich sonst nicht weiß, wie ich den Wert xPosAlt bzw. yPosAlt "speichern" kann...
Grüße, MR
 

Anhänge

  • Test3.JPG
    Test3.JPG
    242,6 KB · Aufrufe: 15
Hallo,

mache mal aus dem AS-Teil ein FUP-Teil mit dem Gedanken, das wenn es in die eine Richtung geht nicht die andere angesteuert wird. Um mehr Aussagen treffen zu können, gibt dein Screenshot nicht alles her. Was passiert in den AS-Aktionen ?

Gruß
 
Hallo Voxe,
falls du meinst das AS in FUP konvertieren, das geht (jedenfalls bei mir) nicht (ist nicht auswählbar).
In den AS-Aktionen passiert nichts tolles. Das ist nur damit sich überhaupt was bewegt und ich eine Achsbewegung generiere (die ich ja dann "nachweisen" soll).
Hier die einzelnen AS-Aktionen:
move_xy:
xPos:=xPos+1;
yPos:=yPos+1;

X/Y 300:
xPos=300 AND yPos=300

move_xy_back:
xPos:=xPos-1;
yPos:=yPos-1;

X/Y 0:
xPos=0 AND yPos=0

Grüße,
MR

P.S.: Ich werd nicht richtig schlau aus der Sache. Habe nun seit gestern Mittag ca. 10 Stunden "verdödelt" und komme nicht richtig voran. Ich glaube, dass ich schon zu kompliziert denke und den einfachsten Weg nicht mehr sehe... Ich denke es muss einen einfacheren Weg geben (zumindest der Punktezahl in der Hausarbeit nach zu urteilen).
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

AS in FUP konvertieren kann nicht gehen. Meinte diesen kleinen Teil musst du in FUP neu schreiben. Deinen Blinkimpuls, brauchst du nicht. Weil du über die Bewegungserkennung deine Motoransteuerung machen kannst.

Gruß, Voxe

PS: Eine fertige Lösung, gibt es hier natürlich nicht.
 
1) Ich muss in dem Fall prüfen, wie ich in FUP eine Bewegung erzeugen kann, damit ich den AS Teil nicht benötige.
2) "Weil du über die Bewegungserkennung deine Motoransteuerung machen kannst." Sorry, verstehe nur Bahnhof!

Grüße, MR
 
Hallo,

deine Achsen haben doch sozusagen zwei Ziele, x, y = 0 und x, y = 300. Dann gibt es noch die Fahrt nach 0 und 300. Damit ergeben sich 4 Zustände, mit denen du deine Ansteuerung der Achsen machst.

1. Stillstand an 0, Aktion = Achsen nach 300 fahren.
2. Stillstand an 300, Aktion = Achsen nach 0 fahren.
3. Istwert wird größer, Aktion = weiter nach 300 fahren.
4. Istwert wird kleiner, Aktion = weiter nach 0 fahren.

Und damit, sollte deine kleine Aufgabe einen Sinn haben. Alles andere macht es unnötig kompliziert.

Gruß
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Okay. In "normaler" Sprache verstehe ich das erstmal.

Aber nur um jetzt nochmal sicher zu gehen:
Diese Anweisungen lassen sich also in irgendeiner Form in FUP programmieren, richtig?

Und dann kann ich da irgendwie die Bewegung "abgreifen" und diese so "wahrnehmen", auch richtig?

Grüße, MR
 
Klar,

du musst also nur die normale Sprache in FUP umsetzen.

Ein Netzwerkerk steuert deine Motore, dann brauchste noch vier um die Zustände zu erfassen, mit denen du die Motore steuerst.

Gruß
 
Aha. Dann komme ich vermutlich also jetzt zu meinem eigentlichen Problem, da ich glaube zu wissen, wie man die Zustände abbildet (womit wir wieder bei LT, GT, EQ wären) und das somit schonmal nicht mein Problem zu sein scheint.
Soweit war ich am Anfang mal und habe diesen Weg als nicht realisierbar "abgestempelt" weil ich in FUP keine Verfahrbefehle "kann". (Das ist dann wohl mein eigentliches Problem)

Das Handbuch hat mich soeben auf die Schnelle da auch nicht weitergebracht. Ich werde also wieder googeln und versuchen rauszufinden, wie ich das hin bekomme.

Was bleibt ist
a) dank an euch hilfsbereite Foren-User!
b) die ärgerliche Erkentniss, dass ich mir etliche Stunden ersparen hätte können...

Grüße,
MR
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

zu deinem letztem Problem kann ich nur vermuten, das du ein Robotermodul nutzt. Welches ich nicht kenne.

Aber meine Glaskugel sagt mir irgendwie, das das nur Programmaufrufe sind und somit in FUP ein Baustein ist, den du nur richtig beschalten musst.

Gruß, Voxe

PS: Wäre schön, wenn du eine kleine Rückmeldung gibst, ob es so ist.
 
Sorry, jetzt verstehe ich wieder die Hälfte nicht.
Was heißt "ein Robotermodul das ich nicht kenne".

Ich werde nun erstmal ein komplett neues Projekt anlegen und dann rausfinden müssen, wie ich in FUP Verfahrbefehle zu programmieren habe! Ganz rudimentäre Angelegenheit. :-(

Wenn ich das habe, kann ich über die schon mehrfach geannnten operatoren(LT, GT, EQ) prüfen wo sich der Roboter (oder was auch immer halt die Verfahrbewegung ausführt) gerade "aufhält" und dann (wenn ich es einmal kann) als jeweilige Aktion eben z.B. auch eine Verfahrbewegung (z.B.: weiter in Richtung 300 verfahren) angeben.
 
Hallo,

mache mal einen Screenshot von den AS-Aktionen, die du in Beitrag 11 beschrieben hast. Da steckt deine Lösung drin. Wollte dich nicht verwirren.

Gruß
 
Zurück
Oben