Zwei Pumpenpaare abwechselnd + 1 Pumpe bei hohen Wasseraufkommen

Zuviel Werbung?
-> Hier kostenlos registrieren
// wenn Pumpe bereit, dann als nächste bzw. für den Parallelbetrieb vormerken ...
Mich beschäftigt jetzt schon länger, was genau hinter den Begriffen "ParallelBetrieb" und "PumpenPaar[en]" steckt.
Ist etwa mit beiden dasselbe gemeint?
Legt z.B. der Bediener fest, welche Pumpen jeweils ein Paar bilden und bleibt diese Zuordnung bestehen, bis er sie anders festlegt?
Oder soll das Programm jedesmal aktuell ein Paar anhand der "bevorzugt-einschalten-Kriterien" neu "ausgucken", sobald sich der AnforderungsZustand von "alle Pumpen aus" in "Pumpe[n] einschalten" ändert?

Eine weitere Frage: ist es wichtig, dass bei einem PumpenPaar diejenige Pumpe zuerst deaktiviert wird, die zuletzt aktiviert wurde?
 
Also das soll eine Steuerung sein, die für 3 Anlagen Typen sein soll. Einmal mit 2 pumpen die sich abwechseln .

Einmal 3 Pumpen die sich abwechseln

Und einmal 2 pumpen paaere die sich abwechseln.

Bei jedem Anlagentyp kann optional auch der Parallelbetrieb aktiviert werden dann laufen ab einem bestimmten Pegel 2 pumpen, bzw. Beide Pumpenpaare.

Die ersten beiden Amalgamtypen habe ich mit meiner Schritt Kette versucht abzubilden. Wenn das steht wird die Kette um den dritten Anlagentyp erweitert. Welche mit der Schrittnummer 200 eingeleitet wird.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Wie würdest du es denn anders machen? Oder anders gefragt, wie würdest du sicher stellen, dass die Schleife nur einmal ausgeführt wird? Das auch in den Trigger Bedingung für die Anforderung?

Ich bin auch "ein bisschen" Hochsprachen-Programmierer - von daher wäre hier mein Ansatz eine Funktion/Methode zu erstellen "GetNächstePumpe" oder so ...
Das heißt, ich würde das ermitteln lassen wenn Bedarf besteht. Das kann natürlich auch eine Schleife sein - macht aber bei 3 Pumpen nicht wirklich Sinn ... In deinem Fall ist es aber sowieso so, dass du (wegen des Aufbaus der Funktion) immer das gleiche Ergebnis bekommst - möglicherweise sogar die Nummer der Pumpe, die du sowieso schon benutzt.
In deinem Fall ist das mit den Schleifen sicherlich nicht so kritisch - ich bin aber grundsätzlich kein Fan davon, etwas ständig laufen zu lassen was nicht sein muss - egal welche Ergebnisse es bringt. Stell dir jetzt mal vor, deine Schleife hätte nicht 3 sondern 300 Elemente ständig durchzuackern - das würde dann irgendwann schon auf deine Zykluszeit gehen ...
Aber wie gesagt : für mich machte die Routine selbst so keinen Sinn ...

Gruß
Larry
 
... In deinem Fall ist es aber sowieso so, dass du (wegen des Aufbaus der Funktion) immer das gleiche Ergebnis bekommst ...
Na ja, ganz so langweilig wird's schon nicht werden. Es könnte mal eine Pumpe ausfallen. Und bei nur 3 Pumpen wäre das schon eine drastische Änderung der Situation.
Wenn nur ein Teil der Pumpen läuft, dann ändern sich auch die Laufzeiten der Pumpen unterschiedlich und wirken sich damit auf die Auswahl des nächsten Kandidaten aus.

Das ändert aber nichts daran, dass man nicht in jedem Zyklus den aktuell nächsten Kandidaten ermitteln muss.
Die Länge der Zykluszeit muss man selbstverständlich im Auge behalten ... aber auch die Stärke der Schwankungen der Zykluszeit! Es kommt auch auf eine gute Balance zwischen beiden Aspekten an. Das sollte man schonmal im Blick haben, wenn z.B. eine spätere Erweiterung auf mehr ArrayElemente/SchleifenDurchläufe abzusehen ist.
 
Also ich hab das jetzt so umgebaut..dass ich in die Schleife rein springe nur wenn die Anforderung zum Satzwechsel kommt (wo ich dann auch den aktuellen Satz mit dem nächsten schreibe), oder wenn not Pumpe[nächsterSatz].Status.bereit ist.

Also nicht mehr jeden Zyklus. So noch einmal die Frage in die Runde.. wie geht man an solchen Pumpensteuerungen generell rann..ich muss mir eine Routine bzw. Ein Baukasten erstellen..damit ich nicht immer vor dem gleichen Herausforderungen stehe..
 
Zuviel Werbung?
-> Hier kostenlos registrieren
.. wie geht man an solchen Pumpensteuerungen generell ran.
Ich versuche, die Aufgabe in separate Hauptpunkte und diese in möglichst einfache, universelle Abläufe zu zerlegen.
Deine Aufgabe hier würde ich in etwa so umsetzen...


Für mich gibt es 3 Hauptpunkte ->

  1. Motorenanforderung:
    • Anzahl notwendiger Motoren (z.B. nach Niveau) bestimmen
    • Motorenanforderung an die notwendigen Motoren anpassen
    Die Anforderung bestimmt nur, wieviele Motoren benötigt werden, aber nicht welche(r).
    Die Anpassung der angeforderten Motoren kann z.B. auch zeitlich hoch/runter gesteuert werden, so dass nicht alle notwendigen Motoren zeitgleich ein- (oder aus-) geschaltet werden, auch wenn das Niveau das eigentlich erfordern würde.
    Laufzeitkontrolle der einzelnen Motoren u.ä. spielen bei der reinen Anforderung auch keine Rolle.


  2. Motorenpendel:
    • Motorenzählungen (Anzahl in Dauer-EIN, in AUTO und in BETRIEB)
    • Auswahl zur Erhöhung bzw. Verringerung der Anzahl von AUTO-Motoren in BETRIEB je nach Anforderung (EIN-Motoren + AUTO-Motoren größer/kleiner Anforderung)
    Die Anzahl der Motoren wird durch das angelegte Array bestimmt. Durch Dauer-AUS kann man Motore aus dem Pendel komplett heraus nehmen.

    Beim Erhöhen wird jeweils der freigegebene Motor mit der höchsten Priorität als Nächstes ausgewählt, beim Verringern der mit der niedrigsten.
    Die Priorität kann z.B. bestimmt werden durch die Gesamtlaufzeit (Beispiel-Link weiter vorn im Thread), den letzten EIN-/AUS-Schaltpunkt oder einer Rangliste der Motoren.
    Mit Letzterem kann man z.B. einen täglichen, wöchentlichen ... Wechsel der Priorität erwirken.


  3. (Einzel-) Motorensteuerung:
    • Steuerung Betriebs-Modus (Dauer-AUS, -EIN, AUTO)
    • Ablaufsteuerung (Schrittkette) beim BETRIEB-AKTIV-Schalten und beim BETRIEB-INAKTIV-Schalten durch die Laufzeitüberwachung.
    • Datenerfassung wie totale/aktuelle Laufzeit, Anzahl Starts, letzter Ausschalt-Zeitpunkt u.ä.
    • ggf. Laufzeitüberwachung (mit BETRIEBssperre bei Überschreitung)
    Jeder Motor hat seine eigene (aber für alle die gleiche) Steuerung, unabhängig von den Zuständen und Abläufen der anderen Motoren (Aktivierung/Deaktivierung der AUTO-Motoren macht das Pendel).
    Dadurch braucht es keine speziellen Parallelschritte oder -ketten, insbesondere wenn sich die Motorenanzahl (= Größe des Motorenarrays) ändert.
    Störungen wirken wie ein Dauer-AUS des jeweiligen Motors.

    Motorenpaare werden unterschieden nach Haupt- und Nebenmotor(en).
    Nur die Hauptmotoren (kein Verweis auf einen anderen Motor) werden beim Paarmodus vom Pendel gezählt und ggf. ein-/ausgeschaltet.
    Nebenmotoren (Verweis auf einen anderen Motor) folgen im Paarmodus mit Verzögerung dem BETRIEBszustand des Hauptmotors. Das bewirkt zwar eine Umkehr der Abschaltreihenfolge gegenüber Deiner Beschreibung, dafür kann die Ablaufsteuerung aber immer gleich und separat für jeden Motor bleiben und man benötigt nur ein einziges Ablaufszenarium (ich vermute mal, das aus diesem Grund auch Heinilein hier am Ende danach gefragt hat).
    Und dadurch kann man dann mit entsprechender Anzahl von Motoren auch ohne weitere Programmänderung bei Bedarf auch 3er, 4er ... Gruppen bilden. Der 3. Motor folgt dann einfach dem 2. usw..
 
(ich vermute mal, das aus diesem Grund auch Heinilein hier am Ende danach gefragt hat)
Ach hucki, wenigstens einer, der mich versteht! ;) DANKE!

Deine Unterscheidung in HauptMotor und NebenMotor gefällt mir. Auch der "Trick", die Verknüpfung / den Verweis "unkonventionellerweise"(?) nur und ausgerechnet beim NebenMotor einzutragen.
Aber wie löst man damit die Aufgabe, in der ersten Stufe 2 Motoren zu aktivieren, in der zweiten Stufe jedoch nur 1 Motor des anderen Paares?
In der ersten Stufe den NebenMotor anfordern und der HauptMotor wird dann anhand des Verweises auf den HauptMotor mitgezogen?
Und in der zweiten Stufe den HauptMotor anfordern und der weiss mangels Verweises auf den NebenMotor nicht, dass er "nur" ein halbes Paar ist?

Wie siehst Du das mit der Unterscheidung zwischen PumpenPaaren und dem ParallelBetrieb?

Gruss, Heinileini
 
Aber wie löst man damit die Aufgabe, in der ersten Stufe 2 Motoren zu aktivieren, in der zweiten Stufe jedoch nur 1 Motor des anderen Paares?
In der ersten Stufe den NebenMotor anfordern und der HauptMotor wird dann anhand des Verweises auf den HauptMotor mitgezogen?
Und in der zweiten Stufe den HauptMotor anfordern und der weiss mangels Verweises auf den NebenMotor nicht, dass er "nur" ein halbes Paar ist?
(Noch) keine Ahnung.
Diese Aufgabe ist bis dato so völlig an mir vorbei gegangen.

Ich hab' mich nur an dem hier orientiert:
Folgendes Szenario, 2 Motoren, 3 Motoren oder 2x2 Motoren

in den ersten 2 Fällen:
  • läuft bei einer Bedingung 1 Motor bis Abschaltbedingung kommt oder durch die Laufzeitkontrolle abschaltet.
  • Bei einer andere Bedingung startet zusätzlich ein weiter Motor, dann gibt es für beide keine Laufzeitkontrolle.
  • die 2. Pumpe läuft bis eine Abschaltbedingung erfüllt ist.

Beim 2x2 ist es so, dass es 2 Paare gibt.
  • dabei schalte bei Anforderung, P1 ein nach einer Verzögerung P2,
  • beim Ausschalten erst P2 dann P1.
  • Beim nächsten Start soll P3 und P4 starten.
  • Auch hier soll es eine Laufzeitkontrolle geben.
Könnte mir aber auf die Schnelle vorstellen, dass z.B. jeder Nebenmotor anhand der bereits laufenden Hauptmotoren (werden ja im Pendel eh' ständig gezählt) selbst entscheidet, ob er (noch) mit anspringen muss oder nicht. Durch die Verzögerung sollte auch mehr als genügend Zeit für diese Entscheidung sein.




Wie siehst Du das mit der Unterscheidung zwischen PumpenPaaren und dem ParallelBetrieb?
Ich hätte an ein Flag gedacht, das anzeigt ob im Parallel- oder Paarbetrieb gefahren werden soll.
Im Parallel-Betrieb wird dann nicht zwischen Haupt- und Nebenmotor unterschieden bzw. sind dann einfach alles Hauptmotoren.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Auch der "Trick", die Verknüpfung / den Verweis "unkonventionellerweise"(?) nur und ausgerechnet beim NebenMotor einzutragen.
Keine Ahnung, ob das unkonventionell ist.
Meine Gedanken waren, dass sich jeder Motor möglichst nur um seinen eigenen Betrieb kümmert und dabei einfach nur rüber schielt, was sein "Chef" (so denn er einen hat) so macht.

Und ich bin mit immer nur einer Partnerangabe IMHO trotzdem flexibler:
Ich kann z.B. Motor 2 sagen, er soll der 1 folgen. Dann kann ich z.B. der 3 sagen, er soll widerrum der 2 folgen. Alternativ könnte ich aber die 3 auch direkt der 1 folgen lassen.
Umgekehrt müsste ich im letzten Fall die 1 schon über 2 Follower informieren.
 
...

Was du beschreibst ist ja eine Suche nach der nächsten Pumpe - das darf nur einmal und auf Anforderung geschehen. Wenn du aber tatsächlich nur max. 3 Pumpen an den Start bringst dann kannst du das genauso über einen IF-ELSE_IF-Abfrage machen - das ist dann auch nicht mehr Aufwand (und für dich vielleicht auch einfacher umzusetzen ...

Magst du mir ein Beispiel zeigen?

Denn es kann ja sein ,dass Pumpe 1 aktiv ist aber Pumpe 2 nicht bereit, dann müsste ja die Pumpe 3 als nächste gewählt werden.
 
Magst du mir ein Beispiel zeigen?

Denn es kann ja sein ,dass Pumpe 1 aktiv ist aber Pumpe 2 nicht bereit, dann müsste ja die Pumpe 3 als nächste gewählt werden.

Klar ... du könntest dir für die aktibe Pumnpe einen "Merker" setzen oder in eine INT-Variable deren Nummer hineinschreiben. Das benutzt du dann als Anwahl - ich nehme mal die INT-Variante ... das könnte dann vielleicht so aussehen :
Code:
zweite_Pumpe := 0 ;
if (aktuelle_Pumpe = 1) then
   if Pumpe_2_bereit then
      zweite_Pumpe := 2 ;
   els_if Pumpe_3_bereit then
      zweite_Pumpe := 3 ;
   end_if ;
els_if (aktuelle_Pumpe = 2) then
   // ... entsprechend wie oben ...
els_if (aktuelle_Pumpe = 3) then
   // ... entsprechend wie oben ...
End_if ;
Enthält nun die Variable zweite_Pumpe einen Zahlenwert ungleich 0 dann würdest du die dazuschalten ...

Gruß
Larry
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ja statAktiverSatz und statNächsterSatz sind ja beide int Variablen. OK das kann man dann wirklich so machen.

Dachte aber dass so ein Code unnötig aufgebläht wird.

Das mit dem getNachstePumpe oder Revierbetrieb könnten man ja auch als Sprung im Case dann machen..also wenn die Anforderung für den reversierbetrieb da ist, setze aktuellen Schritt z.B. = 1000 und dann noch einen vorherigen als statische Variable um zum letzen Schritt zu springen um dann die Ablaufkette zum Beispiel mit statAktuellerScheitt := StatLetzterSchritt + 1 oder mit if then else arbeiten und je nachdem mit der Konstante dea Schrittes setzten.

Hast du vielleicht eine gute Lektüre als Tipp für mich wo man entweder, typische Algorithmen für SPS oder Herangehensweise zum nachschlagen hat?

Aktuell habe ich das Buch, SPS Theorie und Praxis. Was ich nicht sehr gut finde..
 
Hast du vielleicht eine gute Lektüre als Tipp für mich wo man entweder, typische Algorithmen für SPS oder Herangehensweise zum nachschlagen hat?

Nach meiner Meinung gibt es nicht DAS Nachschlagewerk - wie sollte es auch. Viele Dinge sind doch spezifisch - auch wenn sie sich wiederholen ...
Ich würde dir empfehlen, hier generell mitzulesen - auch bei Themen, die dich im Augenblick vielleicht nicht betreffen. Hier bekommst du auf die Weise dann viel mit ... und im Zeifel kannst du dann ja sogar nachfragen ...

Gruß
Larry
 
Zuletzt bearbeitet:
Hast du vielleicht eine gute Lektüre als Tipp für mich wo man entweder, typische Algorithmen für SPS oder Herangehensweise zum nachschlagen hat?
Nach meiner Meinung gibt es nicht DAS Nachschlagewerk ...
Wie sollte es auch aussehen und was sollte es alles beinhalten?
Und auf welche verschiedenen Typen von Interessenten/Lesern mit welchen Vorkenntnissen und Fähigkeiten soll/könnte "DAS Nachschlagewerk" zugeschnitten sein?

Ich sehe eine Bandbreite von Leuten mit extrem schlechtem Gedächtnis bis hin zu Leuten mit extrem gutem Gedächtnis.
Ich gehöre zu denen mit schlechtem Gedächtnis. Was ich nicht verstanden habe, kann ich mir nicht merken. Was ich verstanden habe, muss ich mir nicht merken - das ist für mich irgendwie selbstverständlich und zur Not kann ich es mir wieder herleiten.
Beneidet habe ich Leute mit gutem Gedächtnis durchaus, musste aber hin und wieder feststellen, dass ihnen manchmal das gute Gedächtnis bei ProblemLösungen nicht geholfen hat, weil sie gelegentlich hilflos waren, das Gelernte in die Praxis umzusetzen.

Selber [mit-]denken war für mich immer sehr wichtig. Auch, keine Scheu davor zu haben, das Rad (oder nur ein kleines, unbedeutendes Rädchen) mal neu zu erfinden, hat mir geholfen. Gelesenes zu hinterfragen und nicht einfach nur "abzunicken" ist auch nicht verkehrt.
Wenn man über eine fertige Lösung stolpert, auch mal überlegen, wie hätte ich das (Teil-)Problem angepackt/gelöst und dann mal vergleichen, welche Vor- und Nachteile sich da gegenüberstehen.

Logisch denken sollte man können und man muss erkennen und sich eingestehen, wenn man in zu grossen/groben Schritten (zu sprunghaft) denkt.
ComputerProgramme erfordern es, dass man die Anweisungen fein säuberlich Schrittchen für Schrittchen durchdenkt/aufbereitet.

Programme bzw. ProgrammStückchen testen. Verhält sich der verwendete Befehl oder die Funktion wirklich so, wie ich glaube, die Beschreibung verstanden zu haben?

Bei SPS-Programmen die zyklische Bearbeitung akzeptieren, verstehen und verinnerlichen. Verstehen, dass das gesamte zyklische Programm in einer "EndlosSchleife" vom BetriebsSystem aufgerufen, aber nicht als Schleife sichtbar wird.

Verstehen, dass die Aufteilung in verschiedene Tasks (GrundProgramm, Alarme/ZeitAlarme/WeckAlarme und wie sie noch so genannt werden) manchmal nötig und/oder hilfreich ist, aber oft zu weiteren "Problemchen" führt, spätestens wenn sie Einfluss auf die DatenKonsistenz oder die effektive ZyklusZeit hat.

Verstehen, dass viele Funktionalitäten (z.B. Datei öffnen, lesen/schreiben, schliessen oder "Streams", also DatenAustausch mit anderen Geräten) i.A. mehrere bis viele Zyklen benötigen, bis sie fertig und somit auswertbar oder wieder benutzbar sind.

Den Umgang mit Schrittketten verstehen. Sie dienen dazu, im Wesentlichen WarteZeiten auf Reaktionen zu "verbraten" und gelegentlich zur nächsten TeilAufgabe einer Aufgabe weiterzuschalten. Nutzlos Wartezeiten "verbraten" tun sie aber nicht, sie erlauben der CPU, sich während dieser Wartezeiten mit anderen Aufgaben zu beschäftigen.

Das Thema FlankenErkennung finde ich so wichtig, dass man sie m.E. zunächst "zu Fuss" programmieren sollte, bis man sie wirklich verstanden hat.
Oft hat man es mit FlankenErkennungen zu tun, die man nicht unbedingt als solche wahrnimmt, z.B. bei Timern, Zählern und auch anderen Bausteinen, die flankengetriggert reagieren.

Die korrekte Verarbeitung von sog. "A/B-Signalen" liegt mir auch sehr am Herzen. Es ist so simpel und trotzdem findet man erschreckend oft Beispiele (sogar in "guten" Büchern und Lehrgängen) dafür, wie man es keinesfalls machen sollte, wenn man sich nicht unnötige (weil leicht vermeidbare) Probleme einfangen will.

Das Rätsel der HexadezimalDarstellung von Zahlen. Wird überwiegend in der Dokumentation von seriellen Schnittstellen verwendet und führt immer wieder zu der Frage, "wie wandele ich denn Format x in hexadezimal bzw. umgekehrt?". Meistens lautet die Antwort "[am besten] gar nicht!". Erst, wenn es darum geht, eine in ASCII vorliegende oder zu erzeugende Zeichenfolge zu interpretieren oder bilden, wird es etwas aufwändiger.

Der eigentlich triviale Hinweis, dass die IF-Selektion nicht grundsätzlich überflüssig ist, oft aber doch ... und dann produziert sie Unübersichtlichkeit allein durch die überflüssige Menge an zu schreibendem Code. Z.B.:

Code:
IF MotorAn = TRUE THEN
    MotorAktiv := TRUE ;
ELSE
    MotorAktiv := FALSE ;    
END_IF ;
Wie überflüssig dieser Aufwand ist, sieht man gut, wenn man die einfache Variante als Einzeiler gegenüberstellt:

Code:
MotorAktiv := MotorAn ;
Warum die beiden Alternativen auseinanderpfriemeln, um sie dann sofort wieder zusammenzuführen?
Übrigens sind die Vergleiche '= TRUE' oder '<> FALSE' oder 'NOT (...) = FALSE' immer überflüssig.

Sich an die Verwendung von Arrays heranwagen!
Zunächst bzw. bevorzugt erstmal auf 1-dimensionale Arrays beschränken.
Sucht man nach einem Array, das unterschiedliche DatenTypen enthält, besteht die Lösung nicht darin, eine oder mehrere Dimensionen hinzuzufügen!
Man verwendet dann ein 'Array Of Struct' und erhält damit eine (quasi "Excel"-)Tabelle.
Der Index des Array entspricht der ZeilenNr und alle Zeilen haben denselben, allerdings einen zusammengebastelten, "benutzerdefinierten" DatenTyp, in dem man für jede Spalte den jeweils benötigten DatenTyp festgelegt hat.
Benötigt man eine 2. oder auch 3. Dimension, um z.B. in den Daten das Abbild eines Regals mit seinen in Zeilen und Spalten angeordneten Fächern und dann noch mehrere Reihen solcher RegalWände zu schaffen, dann bleibt die Angelegenheit nachvollziehbar und durchschaubar.
Aber Vorsicht! Wenn man plötzlich feststellt, dass man zu wenig Platz im Array eingeplant hat, lässt man sich allzu leicht dazu verleiten, auf die Schnelle einfach eine weitere Dimension hinzuzufügen. Man sollte sich dann sehr gut überlegen, ob diese Massnahme wirklich den gewünschten Zweck erfüllt oder nur den benötigten SpeicherPlatz verschwendet oder "explodieren" lässt.

Weitere FingerÜbungen für Arrays bzw. Arrays Of Struct:
- Sortieren von Listen/Tabellen (für "Fortgeschrittene": Sortierung über einen Index, ohne die "eigentlichen" Daten(-Sätze) im Speicher umzuräumen; Sortierung nach verschiedenen Kriterien; mehrstufiges Sortieren).
- FIFOs und LIFOs.

Hierfür findet man meistens die verschiedensten vorgefertigten Lösungen. Aber das SichBeschäftigen mit eigenen Ansätzen und kleinen Experimenten kann nicht schaden.
Selbst, wenn die gesammelten Erfahrungen "nur" dazu dienen, aus den verschiedenen vorgefertigten Lösungen die geeigneteste herauszupicken.
Nicht zuletzt, wenn es um Arrays mit sehr vielen Elementen geht und die ZyklusZeit akut bedroht ist, kann eine massgeschneiderte (selbst realisierte) Lösung
schon mal in Betracht gezogen werden!
 
Zuletzt bearbeitet:
Ich finde ja Arrays auch sehr gut, doch leider sind diese schlecht zu debuggen, Also wenn ich eine For Schleife habe, ist es schwierig diese zu debuggen, oder ich raff das nicht wie man die Haltepunkte bei Siemens benutzt für SCL. Bei anderen Hochsprachen bzw. Skriptsprachen wie C#, Java oder javaScript ist es viel besser gelöst.

Gerade in der Simulation bei PLC Sim würde ich gerne sehen, was in der Schleife passiert, das hat beim Letzten Projekt echt zu Try and Error geführt, daher denke ich, dass wenn ich nur 5 Pumpen habe wohl ab jetzt nur noch mit IF THEN ELSE arbeiten werde.

Es sei denn man erklärt mir, wie man ein einer FOR Schleife vernünftig Debuggen kann.
 
Kannst du meines Wisserns nach nicht ...
Du musst hier verstehen, dass ein SPS-Programm ständig zyklisch abgearbeitet wird. Du kannst es nicht an einer Stelle "anhalten". Das ist z.B. bei .Net komplett anders - hier ist der Ablauf erstmal ereignisgesteuert ... und das Ereignis kannst du unterbinden ... oder das Programm auch so einfach "festhalten".
Hältst du ein SPS-Programm irgendwo an so würdest du sofort eine Zykluszeit-Überschreitung bekommen da die CPU im Hintergrund eine maximale Zykluszeit sicherzustellen versucht - du musst immer dran denken, dass du ja eigentlich eine Maschine steuern willst und z.B. ein Abschalten von irgendetwas sicherstellen willst / musst ...

Gruß
Larry
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Deshalb die Frage ob es geht zumindest in PLC Sim. Aber Haltepunkte Setzen geht, auf jeden Fall! Nur innerhalb einer Schleife bekomme ich das nicht hin. Aber anhalten und zeilenweise den Code durchgehen funktioniert komischer weise.
 
Nicht wirklich und nicht 100%ig zuverlässig.
Hier wird im Prinzip versucht, das Ergebnis an einer bestimmten Stelle im Programm abzufragen - der Zyklus läuft deswegen trotzdem "ganz normal" weiter ...
 
Deshalb die Frage ob es geht zumindest in PLC Sim. Aber Haltepunkte Setzen geht, auf jeden Fall! Nur innerhalb einer Schleife bekomme ich das nicht hin. Aber anhalten und zeilenweise den Code durchgehen funktioniert komischer weise.
Haltepunkt.PNG
 
Zurück
Oben