Codesys Task-Problem und Optimierung

CoDeSys12345 · 2. Oktober 2013 um 09:30

Guten Morgen miteinander,

gleich vorweg ich bin noch Anfänger in Sachen Strukturierter Text und bitte um Eure Hilfe, ins besondere im ersten FallDer Anhang müsste die Endung pro haben (leider konnte sie so nicht hochgeladen werden und habe diese dann in .pdf umgewandelt

1.Problem
Ich habe im beigefügten CoDeSys-Programm ein Programm "Werkstueck_Verwaltung" welches ich mit einem weiteren „Visu_Band“ in einen Task mit einer Zyklenzeit von 1s und der Priorität 5 (niedrigste meines Programms) eingefügt habe.
Ursprünglich hatte ich die Fehlermeldung beim Starten des Programms, in der Simulation, die Fehlermedlung:Endlos-Schleife (nur bei Priorität:2 nicht bei 5). Ich habe die letzte Anweisung (in Werkstueck_Verwaltung in eine IF-Anweisung (zuvor While) umgeändert und es ging

Mein Problem ist nun, wenn ich die Variable „Stueck-Annahme“ auf True setzte/force wird bei Priorität 5 die IF-Anweisung nicht ausgeführt, bei Priorität 2 klappt dies teilweise.

Ich habe bewusst, die zyklische Zeit auf lediglcih 1s gesetzt, da die anderern Programmteile Vorrang haben müssen.

-> Was habe ich falsch gemacht???

2.Frage/Vereinfachung

Auch in diesem Programm „WErkstueck_Verwalt“ habe ich versucht, mit den zwei Case-Anwendungen Werte in die Visu zu schreiben und anschließend programminterne Variable wieder mit dem neuen, evtl. durch Eingabe, veränderten Wert, zu beschreiben. Kann man hier evtl. [i],… arbeiten?

Das Ergebnis sollte sein, es gibt ca. 30 verschiedene Werkstücke mit jeweils ca. 12 Parametern (siehe 1. Zeile Case =vollständig), dass diese Variablen über die Visu geändert werden können.

Wird nun in der Visuvalisierung z.B. das Werkstück 15 aufgerufen, so sollen die 12 Parameter in die Visu PLC_VISU geladen werden (alle 12 Variabeln stammen aus z.B.Werkstueck_15 und werden auf die Variable …_NrX geschrieben).
Wird nun der Wert über die nummerische Anzeige geändert oder boolsche_Elemente angeklickt, müssen anschließend die Änderungen oder einfach alle Parameter wieder in das Programm z.B. Werkstueck_15 geschrieben werden.

3a.Visu-Frage

Ein Linienzug soll mit einem variablen Ende und einem fixen Ende in der Visu angezeigt werden. Wie ist dies möglich, denn das eine Ende darf sich nicht bewegen und das andere Ende bewegt sich lediglich in X-Richtung (Folge: Pfreillänge wird kleiner und gleichzeitg weißt diese dann immer wieder einen anderen Winkel auf +

3b.Visu-Frage

Ein Viereck soll sich in x-richtung bewegen (realisiert) und gleichzeitg soll die X-Länge variabel sein; die y-Richtung jedoch nur eine fixe oder zwei fixe Größen annehmen (=nicht skaliert).

Vielen Dank für Eure Hilfe und Eurer Verständnis, bzgl. der falschen, technischen Ausdrucksweise. Ich freue mich über Eure Ratschläge.

Grüße

Codesys123456

Kopie von Kantenautomat-aktuell-5.pdf (370 KB)

CoDeSys123456 · 5. Oktober 2013 um 12:45

Leider, hat sich noch niemand dem Thema angenommen, evtl. habe ich auch einfach zu viel verschiedenen Punkte auf einmal aufgegriffen.
Daher nochmals ein zweiter Anlauf, bezieht sich nur auf den Punkt Vereinfachung:

Ich möchte kurz erklären, was ich vorhabe; wahrscheinlich ist mein Ansatz völlig falsch:

In der Visuvalisierung (PLC_VISU) habe ich 5 Eingabefelder (Word-Variablen, [%s mm]) und mehrere boolsche „Taster“ [Pfeile und Quadrate mit Nummmern].
Diese Eingabefelder und boolschen Taster können bei den bis zu 30 Werkstücken verschiedene Stellungen und Eingaben annehmen, die im jeweiligen Programm Werkstueck_1, Werksteuck_2, … _30 benötigt und „gespeichert“ werden müssen; zur weiteren Berechnung und falls vom Bediener wieder gewünscht, in die VISU geladen werden.

Ich versuchs nun mal mit einem Beispiel:
Wird das Werkstück 1 (blaues Rechteck in der PLC_VISU) angeglickt oder aber die Werkstücknummer bei den drei roten Fragezeichen (beides noch nicht realisiert) eingegeben so sollen die 5 Eingabefelder (Word-Variablen, [%s mm]) und mehrere boolsche „Taster“ mit den Werten aus dem Programm des angeklickten Werkstücks (z.B. 8 für Werksteuck_8) „beschrieben werden“. Anschließend kann der Benutzer die Werte der Eingabefelder ändern oder boolschen Taster betätigen und dies wird sofort im Werksteuck_8 geändert; innerhalb einer Sekunde (Zyklenzeit, da das Werkstück, bzw. deren Parameter auch eine Stunde lang aufgerufen sein kann.
Wird nun ein anderes Werkstüeck ausgewählt, so muss vom jeweiligen Programm (z.B. Werkstueck_5) die jeweiligen WErte wieder neu geladen werden und anschließend wieder in diesem Programm (z.B. Werkstueck_5) geschieben werden.

Beispiel am Programm:
Ausgangslage, die Variable VISU_WerksteuckNR_Eingabe verändert sich, z.B. in 3 (durch Eingabe ??? = 3, in der VISU).

Zuerst werden die benötigen Variabeln aus dem Programm, hier im Beispiel: Werksteuck_3 [VISU_S1_SX_3] gelesen und zwar nur einmal, deshalb dachte ich an eine Repeat-Schleife und anschließend in der Visu angezeigt [VISU_S1_SX_NrX].

Durch die nachfolgende Gleichsetzung der internen Variable „VISU_WerksteuckNR_Eingabe_Speicherung“, wird die Repeat-Schleife nur einmal durchlaufen und anschließend sorgt die IF-Schleife für die Aktualisierung, bei einer Eingabe in der Visu, der jeweiligen Variabeln im Programm Werksteuck_3 [VISU_S1_SX_3], bis sich die VISU_WerksteuckNR_Eingabe ändert.
.
VISU_WerksteuckNR_Eingabe_Speicherung:= VISU_WerksteuckNR_Eingabe;

REPEAT
CASE VISU_WerksteuckNR_Eingabe OF
1:
VISU_S1_SX_NrX := VISU_S1_SX_1;
VISU_Anfangswert_1_NrX := VISU_Anfangswert_1_WzSt_1; (vereinfacht mit nur zwei Variablen, insgesamt pro
Werkstück >10
2: …
3:
VISU_S1_SX_NrX := VISU_S1_SX_3;
VISU_Anfangswert_1_NrX := VISU_Anfangswert_1_WzSt_3;

END_CASE
UNTIL VISU_WerksteuckNR_Eingabe_Speicherung = VISU_WerksteuckNR_Eingabe END_REPEAT

IF VISU_WerksteuckNR_Eingabe_Speicherung = VISU_WerksteuckNR_Eingabe THEN
CASE VISU_WerksteuckNR_Eingabe OF
1:
VISU_S1_SX_1 := VISU_S1_SX_NrX;
VISU_Anfangswert_1_WzSt_1; := VISU_Anfangswert_1_NrX ;
2: …
3:
VISU_S1_SX_3; := VISU_S1_SX_NrX;
VISU_Anfangswert_1_WzSt_3;:= VISU_Anfangswert_1_NrX;
END_CASE END_IF

Wie kann man dies nun einfacher realisieren, bzw. überhaupt korrekt realisieren?

Beispiel am Programm:
Zu diesem Auslesen/Anzeigen/Eingeben/Schreiben, oder wie auch immer :roll:

Nun kommt noch eine kleine Nebenbedingung hinzu: Die Werte, wie z.B. [VISU_S1_SX_3] müssen, wenn das Stück aktiviert wird (kein Zusammenhang mit der Visu, sondern eine interne Freigabe des Programms Werstueck_1), einmalig mit dem Wert der boolschen Eingabe in der PLC_VISU (rote Rechtecke, auch mit Zahlen, über dem langen grünen Rechteck) [VISU_Supp_1_AN_Allgm] " nur beschrieben werden" und weitere Werte (deklinierte Word-Variablen) werden genullt.
.
[Werkstueck_1], leicht abgeändert
R_TRIG(CLK: Stueck_3_aktiv = FALSE , Q=
VISU_S1_SX_3 := VISU_Supp_1_AN_Allgm;
VISU_Anfangswert_1_WzSt_3 := 0)

(Problem R_TRIG ist keine Funktion, die Ausführung soll einmalig, bei Wechsel von [Steuck_3_aktiv] vonTrue auf False erfolgen)

Ich habe dies erwähnt, nicht dass hieraus eine unmögliche Abhängigkeit entsteht,…

Würde mich über Eure Rückmeldunge freuen, auch evtl. über die anderen Punkte.

viele GRüße

fraggle · 5. Oktober 2013 um 13:34

Hallo,

ich denke Du bist ein wenig im falschen Forum, hier geht es hauptsächlich um IPS.

aber nun zu deinem Problem.

R_TRIG

Deklaration:

VAR
Trigger:R_trig;
Stueck_3_aktiv:Bool;
VISU_S1_SX_3:?was auch immer?;
VISU_Supp_1_AN_Allgm:?was auch immer?;
VISU_Anfangswert_1_WzSt_3:?was auch immer?;
END_VAR

Code:

Trigger(CLK:=Stueck_3_aktiv);
If Trigger.Q Then
VISU_S1_SX_3 := VISU_Supp_1_AN_Allgm; 
VISU_Anfangswert_1_WzSt_3 := 0;
End_If

Gruß

Frank

exchange · 5. Oktober 2013 um 21:05

Hallo,
Du bist im falschen Forum.

Was hälst Du denn davon bei Schleifen oder Bedingungen mal was einzurücken? Das liest sich dann viel viel besser.
Normalerweise macht man zuerst den Code und testet das dann durch. Wenn das alles funktioniert kommt die Visualisierung. Außerdem solltest Du die Eingaben und Sensorendaten überprüfen und nicht einfach zu verarbeiten.

Zum Problem:
Die Bedingung wird doch ausgeführt. Sogar schon beim Start des Programms.

Ich glaube auch nicht, dass es hier einen gibt der sich mit der Codesys Visualisierung beschäftigt. Dafür nutzen die Leute hier IP Symcon. Versuch dein Glück mal im SPS Forum oder Du kaufst Dir von Emerson DeltaV, dann kann ich Dir auch bei der Visualisierung helfen

Gruß

fraggle · 5. Oktober 2013 um 21:39

Hi,

ich glaube der hat so was noch nie gemacht und sucht einen Dummen der im sein Programm schreibt…
Die Frage ist in mehreren Foren…

Gruß

Frank

CoDeSys12345 · 7. Oktober 2013 um 08:15

Hallo exchange,

das mit der Lesbarkeit werde ich versuchen zu berücksichtigen. Mit der Ausführbarkeit hängt es wohl bei mir daran, dass die Variablen von verschiednen Tasks mit verschiedenen Zyklenzeiten und Prioritäten gelsen und geschrieben werden, …

Trotzdem Danke für den Ratschlag

CoDeSys12345 · 7. Oktober 2013 um 08:19

Hallo Frank,

nein, ich suche keinen Dummen, … Lediglich, da hast Du recht, habe ich bisher mehr Gebäudautomation gemacht, mit LOGO-Steuerungen, … Mit Arrays habe ich halt noch nie gearbeitet und hoffe jemand kann mir dies erläutern.

Jeder fängt mal an, der eine bekommt ne Schulung, der andere nicht, …
Ja, die Frage habe ich in dem anderen Froum, in dem Du mir bereits geantwortet hast, auch gestellt; einfahc, da mir wohl keiner antworten möchte - evtl. mein Text zu lang ist, …

Übrigens,as urdprüngliche Problem mit der Realisierung der austauschbaren Variablen über die Visu und das Programm haben sich erledigt.

Nachfolgend habe ich einen Programmabschnitt, der sich zwölf mal wiederholen würde und dieses Paket wiederum zwanzig Mal.
Voerst würde ich gerne wissen, kann man diesen nachfolgenden Programmteil (ersichtlich ist 1. und 2., wie gesagt es ginge bis 12.)vereinfachen (z.B. mit Arrays)?

Diese „Abschnitte“ sollten jedoch immer parallel bzw. direkt nacheinander abgearbeitet werden, sofern z.B.

Stueck_1_aktiv = TRUE AND VISU_S1_SX_[1] = TRUE
Stueck_1_aktiv = TRUE AND VISU_S1_SX_[1] = TRUE, … sind;also in einem Zyklus, nacheinander???

Ich habe nun die Variabeln, die sich zwischen 1. und 2. bzw. bis 12. verändern, orange markiert und die, die bereits ein Array erhalten und dich ändern sowie die bereits vorhandenen Arrys grün, diese verändern sich in 1-12 nicht. Siehe auch nachfolgendes Programm

(Support 1. Standart-Bearbeitung oder Sonderstück-Bearbeitung) 1.


IF  Stueck_1_aktiv = TRUE AND VISU_S1_SX_[1] = TRUE
     THEN    IF VISU_S1_SX_AKTIV_[1] = TRUE AND VISU_Anfangswert_1_WzSt_[1] >0
                           THEN    IF  VISU_S1_MsNullp +  VISU_S1_Start_Sonder + VISU_Anfangswert_1_WzSt_[1] < Anfangspos_Maschine_1         THEN A1 :=TRUE;  ELSE A1 :=FALSE; END_IF
                           ELSE     IF  VISU_S1_MsNullp - VISU_S1_StRefp                                                                           < Anfangspos_Maschine_1          THEN A2 :=TRUE;  ELSE A2 :=FALSE; END_IF END_IF
                    IF VISU_S1_SX_AKTIV_[1] = TRUE AND VISU_Anfangswert_3_WzSt_[1] >0
                           THEN    IF  VISU_S1_MsNullp -  VISU_S1_Ende_Sonder  > Anfangspos_Maschine_1 - VISU_Bearbeitungswert_2_WzSt_[1] - VISU_Anfangswert_1_WzSt_[1]      THEN B1 :=TRUE;  ELSE B1 :=FALSE; END_IF
                           ELSE     IF  VISU_S1_MsNullp + VISU_S1_EndRefp           > Anfangspos_Maschine_1 - Stuecklaenge_1                                                                                                       THEN B2 :=TRUE;  ELSE B2 :=FALSE; END_IF END_IF
                    IF VISU_S1_SX_AKTIV_[1] = TRUE AND VISU_Bearbeitungswert_4_WzSt_[1] >0
                           THEN    IF  VISU_S1_MsNullp +  VISU_S1_Start_Sonder + VISU_Anfangswert_3_WzSt_[1] + VISU_Bearbeitungswert_2_WzSt_[1] + VISU_Anfangswert_1_WzSt_[1]  < Anfangspos_Maschine_1   THEN C :=TRUE;  ELSE C :=FALSE; END_IF END_IF
                    IF VISU_S1_SX_AKTIV_[1] = TRUE AND VISU_Endwert_5_WzSt_[1] >0
                           THEN    IF  VISU_S1_MsNullp -  VISU_S1_Ende_Sonder  > Anfangspos_Maschine_1 - Stuecklaenge_1 + VISU_Endwert_5_WzSt_[1]     THEN D1 :=TRUE;  ELSE D1 :=FALSE; END_IF
                           ELSE     IF  VISU_S1_MsNullp + VISU_S1_EndRefp           > Anfangspos_Maschine_1 - Stuecklaenge_1                                                           THEN D2 :=TRUE;  ELSE D2 :=FALSE; END_IF END_IF END_IF
IF (A1 =  TRUE OR A2 = TRUE) AND (B1 =  TRUE OR B2 = TRUE OR C =TRUE) AND (D1 = TRUE OR D2=TRUE) THEN  S1_AN := TRUE; ELSE  S1_AN := FALSE; END_IF

(Support 2. Standart-Bearbeitung oder Sonderstück-Bearbeitung) -2.


IF  Stueck_1_aktiv = TRUE AND VISU_S2_SX_[1] = TRUE
     THEN    IF VISU_S2_SX_AKTIV_[1] = TRUE AND VISU_Anfangswert_1_WzSt_[1]>0
                           THEN    IF  VISU_S2_MsNullp +  VISU_S2_Start_Sonder + VISU_Anfangswert_1_WzSt_[1]< Anfangspos_Maschine_1         THEN A21 :=TRUE;  ELSE A21 :=FALSE; END_IF
                           ELSE     IF  VISU_S2_MsNullp - VISU_S2_StRefp                                                                           < Anfangspos_Maschine_1          THEN A22 :=TRUE;  ELSE A22 :=FALSE; END_IF END_IF
                    IF VISU_S2_SX_AKTIV_[1] = TRUE AND VISU_Anfangswert_3_WzSt_[1] >0
                           THEN    IF  VISU_S2_MsNullp -  VISU_S2_Ende_Sonder  > Anfangspos_Maschine_1 - VISU_Bearbeitungswert_2_WzSt_[1] - VISU_Anfangswert_1_WzSt_[1]      THEN B21 :=TRUE;  ELSE B21 :=FALSE; END_IF
                           ELSE     IF  VISU_S2_MsNullp + VISU_S2_EndRefp           > Anfangspos_Maschine_1 - Stuecklaenge_1                                                                                                       THEN B22 :=TRUE;  ELSE B22 :=FALSE; END_IF END_IF
                    IF VISU_S2_SX_AKTIV_[1] = TRUE AND VISU_Bearbeitungswert_4_WzSt_[1] >0
                           THEN    IF  VISU_S2_MsNullp +  VISU_S2_Start_Sonder + VISU_Anfangswert_3_WzSt_[1] + VISU_Bearbeitungswert_2_WzSt_[1] + VISU_Anfangswert_1_WzSt_[1]  < Anfangspos_Maschine_1   THEN C2 :=TRUE;  ELSE C :=FALSE; END_IF END_IF
                    IF VISU_S2_SX_AKTIV_[1] = TRUE AND VISU_Endwert_5_WzSt_[1] >0
                           THEN    IF  VISU_S2_MsNullp -  VISU_S2_Ende_Sonder  > Anfangspos_Maschine_1 - Stuecklaenge_1 + VISU_Endwert_5_WzSt_[1]     THEN D21 :=TRUE;  ELSE D21 :=FALSE; END_IF
                           ELSE     IF  VISU_S2_MsNullp + VISU_S2_EndRefp           > Anfangspos_Maschine_1 - Stuecklaenge_1                                                           THEN D22 :=TRUE;  ELSE D22 :=FALSE; END_IF END_IF END_IF
IF (A21 =  TRUE OR A22 = TRUE) AND (B21 =  TRUE OR B22 = TRUE OR C2 =TRUE) AND (D21 = TRUE OR D22=TRUE) THEN  S2_AN := TRUE; ELSE  S2_AN := FALSE; END_IF

Bitte um Eure Ratschläge
Vielen Dank

wupperi · 7. Oktober 2013 um 08:25

Hat ja gut geklappt … Habe deinen Code mal in

brackets gesetzt. Viel lesbarer wird er aber auch nicht IMHO.

exchange · 7. Oktober 2013 um 10:55

wenn Du einen Code mehrfach benötigst, solltest Du Dir Gedanken über eine Schleife machen. Die zwei Variablen musst Du zu einem Array abändern und in der Schleife lässt Du eine Variable die Schleifendurchgänge mitzählen (z.B. i). Diese Varaible nutzt Du dann als Index für das Array (z.B. variable1[i]).

Variablen wie A, B, C sind in 3 Jahren auch für den Entwickler nicht mehr aussagekräftig genug. Da siehst Du dann den Wald vor lauter Bäumen nicht mehr.

Bzgl. deines ersten Problems. Du darfst bei einer SPS in die Variable immer nur in einem Task reinschreiben. Wenn Du mehrere hast, schreibt der eine eine 1 rein und der andere eine 0. Der letzte gewinnt natürlich.

Es ist ja schön, dass Du dein Problem so ausführlich immer beschreibst. Das Problem ist aber, es liest sich kein Mensch durch. Du solltest mal überlegen ob Du deine Frage nicht in 3-6 Sätzen untergebracht bekommen hättest. Denn die eigentliche Frage ist ja: Wie führe ich ein und den selben Programmteil x mal aus.

Bei der For-Schleife hast Du allerdings auch ein Timing Problem. Denn die geht immer nur einmal weiter bei jedem Task Durchlauf. Bei Sicherheitseinrichtungen darfst Du so nicht arbeiten.

Schau Dir das mal an: http://www.ipsta.de/download/automationstechnik/Kap14_Daten%20.pdf

Gruß

CoDeSys12345 · 7. Oktober 2013 um 12:54

Hallo exchange, vielen Dank für Deine Antwort.
Leider verstehe ich nicht, wie man dem „Array“ „erklären soll“, es soll bei einer die Daten aus einem Array nehmen und beim nächsten dann ist eine andere Variable zu verwenden.
Oder geht dies nicht und man muss für alles Arrays anlegen.

Wie würde das bei meinem Besipiel aussehen und werden die „Ausgänge/Ergebnisse“ die ich nicht korrekterweise mit nur einem Buchstabe „z.B. B“ benannt habe.

Das Programme welches aus den untrigen 12 Teilen (-> 1 x Array) besteht würde dann bei jedem Zyklus nur immer nur 1 Teil abgearbeitet und im nächsten Zyklus der zweite Teil, bis alle 12 Teile berechnet wurden und anschließnd von vorne.
Liste ich das so umständlich, wie ich es jetzt für 1 und 2 getan habe, auf; so wird das Programm in einem Zyklus abgearbeitet. Bei der Variante würde der komplette Ablauf 12 mal so lange dauern?

VISU_S1_SX_[1]muss/kann hier ein Text zur Deklaration des ersten und zweiten Arrays eingefügt werden?[1] = TRUE

IF Stueck_1_aktiv = TRUE AND VISU_S1_SX_[1] [1]/color] = TRUE
oder wäre es auch so möglich:
THEN IF [color=#FF0000]VISU_S[1]SX_AKTIV[1] = TRUE AND VISU_Anfangswert_1_WzSt_[1] >0
THEN IF VISU_S1_MsNullp [1] + VISU_[1]Start_Sonder + VISU_Anfangswert_1_WzSt[1] < Anfangspos_Maschine_1 THEN A1 [1] :=TRUE; ELSE A1[1] :=FALSE; END_IF
ELSE IF VISU_S1_MsNullp[1] - oder so VISU_[1]_StRefp …

exchange:

Variablen wie A, B, C sind in 3 Jahren auch für den Entwickler nicht mehr aussagekräftig genug. Da siehst Du dann den Wald vor lauter Bäumen nicht mehr.

Bzgl. deines ersten Problems. Du darfst bei einer SPS in die Variable immer nur in einem Task reinschreiben. Wenn Du mehrere hast, schreibt der eine eine 1 rein und der andere eine 0. Der letzte gewinnt natürlich.

Es ist ja schön, dass Du dein Problem so ausführlich immer beschreibst. Das Problem ist aber, es liest sich kein Mensch durch. Du solltest mal überlegen ob Du deine Frage nicht in 3-6 Sätzen untergebracht bekommen hättest. Denn die eigentliche Frage ist ja: Wie führe ich ein und den selben Programmteil x mal aus.

Bei der For-Schleife hast Du allerdings auch ein Timing Problem. Denn die geht immer nur einmal weiter bei jedem Task Durchlauf. Bei Sicherheitseinrichtungen darfst Du so nicht arbeiten.

Schau Dir das mal an: http://www.ipsta.de/download/automationstechnik/Kap14_Daten%20.pdf

Gruß

Vielen Dank für den Link, hierzu habe ich noch eine Frage, was genau mein Problem betriffr; wie ist folgendes zu verstehen, bzw. es sind die selben Variabeln und wie können diese nun geändert werden -> Seite 5:

Wenn veränderliche Wert eines Prozesses in die
Liste eingetragen werden sollen, kann dies durch
Zugriff auf die Einzelelemente erfolgen:
A
nstelle
Liste [i]:=Daten
ist dann zu schreiben:
Liste[i].Auswahlbit:=Auswahlbit_1;
Liste[i].Kontrollbit:=Kontrollbit_1;
Liste[i].Fehlermeldung:=Fehlermeldung_1;
Liste[i].Stoff_A1:=Stoff_A1_1;
Liste[i].Stoff_A2:=Stoff_A2_1;
Liste[i].Zuschlagsto
ff:=Zuschlagstoff_1;
Liste[i].Mischzeit:=Mischzeit_1;
Liste[i].Zeitstempel:=Zeitstempel_1;

vielen Dank für Eure Mühe und Eurem Verständnis, gegenüber einem „Anfänger“

Grüße

CoDeSys12345 · 8. Oktober 2013 um 09:47

Hallo miteinander,

ich habe nun, das Ganze in ein Programm integriert, mit einanderverflochtene Arrays. Nun meine Frage, wie kann dieser Komplez am schnellsten abgearbeitet werden, sodass die Berechnung gleich schnell erfolgt, wie wenn man das ganze komplett ausführlich (12*20) aufgliedern würde.

MEines Erachtens ist nun ein Schleife mit:

Zähler 1-12 [Supp]
Zähler 1-20 [Werks]
einzufügen.
= [Werks]= 1, Zähler 1=+1: [Supp] 1,2,3,…12 , dann Zähler 2+1
dann
= [Werks]= 2, Zähler 1=+1: [Supp] 1,2,3,…12
…
= [Werks]= 12, Zähler 1=+1: [Supp] 1,2,3,…12, dann Zähler 1 und 2 = wieder Reset:1

[list=]Wäre dies so korrekt? Und was für eine Schleife oder wie wäre der Zählring auzubauen?
Wie sind die Tasks aufzubauen (freilaufend oder zyklisch? des weiteren sind noch andere Programmteile, die die gleiche Priorität haben sowie einige, die z.B. nur jede Sekunde ablaufen brauchen, vorhanden???[/list]

VAR_GLOBAL RETAIN PERSISTENT
IF1pos_Supp_ay2_vWerk_ay1_On: ARRAY [0…20] OF ARRAY [1…12] OF BOOL;
IF1neg_Supp_ay2_vWerk_ay1_On: ARRAY [0…20] OF ARRAY [0…12] OF BOOL;
IF2pos_Supp_ay2_vWerk_ay1_On: ARRAY [0…20] OF ARRAY [1…12] OF BOOL;
IF2neg_Supp_ay2_vWerk_ay1_On: ARRAY [0…20] OF ARRAY [1…12] OF BOOL;
IF3pos_Supp_ay2_vWerk_ay1_On: ARRAY [0…20] OF ARRAY [1…12] OF BOOL;
IF4pos_Supp_ay2_vWerk_ay1_On: ARRAY [0…20] OF ARRAY [1…12] OF BOOL;
IF4neg_Supp_ay2_vWerk_ay1_On: ARRAY [0…20] OF ARRAY [1…12] OF BOOL;
S_ay2_Werks_ay1AN: ARRAY [0…20] OF ARRAY [1…12] OF BOOL;
VISU_SUP_ay1_MsNullp_: ARRAY [1…12] OF WORD; (Support 1-12 Maschienennullpunkt)
VISU_SUP_ay1_StRefp_: ARRAY [1…12] OF BYTE; (Support 1-12 Startrefernzpunkt vom Mittelpunkt des Supports + Bearbeitung*)
VISU_SUP_ay1_EndRefp_: ARRAY [1…12] OF BYTE; (Support 1-12 Endtrefernzpunkt, vom Mittelpunkt des Supports + Bearbeitung)
VISU_SUP_ay1_Start_Sonder_: ARRAY [1…12] OF BYTE; (Support 1-12 Startrefernzpunkt, vom Mittelpunkt des Supports - SonderBearbeitung)
VISU_SUP_ay1_Ende_Sonder_: ARRAY [1…12] OF BYTE; (Support 1-12 Endtrefernzpunkt, vom Mittelpunkt des Supports - SonderBearbeitung) VISU_Anfangswert_1_WzSt_: ARRAY [0…20] OF WORD; (Eingabe in Visu Anfangswert_1_ von Werkstueck 1-20 keine Bearbeitung; Visuvalisierung Stueck-Berabeitungs-Laengen)
VISU_Bearbeitungswert_2_WzSt_: ARRAY [0…20] OF WORD; (Eingabe in Visu Bearbeitungswert_2_ von Werkstueck 1-20 Bearbeitun; Visuvalisierung Stueck-Berabeitungs-Laengen)
VISU_Anfangswert_3_WzSt_: ARRAY [0…20] OF WORD; (Eingabe in Visu Anfangswert_3_ von Werkstueck 1-20 keine Bearbeitung; Visuvalisierung Stueck-Berabeitungs-Laengen)
VISU_Bearbeitungswert_4_WzSt_: ARRAY [0…20] OF WORD; (Eingabe in Visu Bearbeitungswert_4_ von Werkstueck 1-20, keine Bearbeitung; Visuvalisierung Stueck-Berabeitungs-Laengen)
VISU_Endwert_5_WzSt_: ARRAY [0…20] OF WORD; (Eingabe in Visu Bearbeitungswert_5_ von Werkstueck 1-20 keine Bearbeitung; Visuvalisierung Stueck-Berabeitungs-Laengen)
VISU_Stuecklaenge_: ARRAY [0…20] OF WORD; (Visu-Stuecklänge)
VISU_SUP_ay2_ST_ay1_: ARRAY [0…20]OF ARRAY [1…12]OF BOOL; (*Support 1-12, für jeweiliges Werkstueck 1-20, Bearbeitung aktiv, Visuvalisierung Support Zustand Bearbeitung aktiv *)
VISU_SUP_SONDERaktiv_ay2_ST_ay1_: ARRAY [0…20]OF ARRAY [1…12]OF BOOL; (*Support 1, füR jeweiliges Werkstueck 1-20, Sonderlaengen-Bearbeitung aktiv, Visuvalisierung Support Zustand Sonderlaengen-Bearbeitung aktiv *)
END_VAR

(Werkstueck 1 bis 20 für je Support 1-12. Standart-Bearbeitung oder Sonderstück-Bearbeitung)

FOR Werks:=1 TO 20 DO OR 1 TO (Stueckzahlnummer)
FOR Supp:=1 TO 12 DO


IF  Stueck_ay1_aktiv_[Werks] = TRUE AND VISU_SUP_ay2_ST_ay1_[Werks][Supp] = TRUE
     THEN   
               IF VISU_SUP_SONDERaktiv_ay2_ST_ay1_[Werks][Supp] = TRUE AND VISU_Anfangswert_1_WzSt_[Werks] >0
                           THEN   
                                 IF VISU_SUP_ay1_MsNullp_[Supp] +  VISU_SUP_ay1_Start_Sonder_[Supp] + 
                                     VISU_Anfangswert_1_WzSt_[1] < Anfangspos_Maschine_ay1_[Werks]       
                                            THEN 
                                                  1pos_Supp_ay2_vWerk_ay1_On :=TRUE;  
                                             ELSE    
                                                  1pos_Supp_ay2_vWerk_ay1_On[Werks][Supp] :=FALSE ; END_IF
                           ELSE  
                                 IF VISU_SUP_ay1_MsNullp_[Supp] - VISU_SUP_ay1_StRefp_[Supp]  
                                    <Anfangspos_Maschine_ay1_[Werks]
                                             THEN 
                                                   1neg_Supp_ay2_vWerk_ay1_On :=TRUE;  
                                              ELSE 
                                                   1neg_Supp_ay2_vWerk_ay1_On[Werks][Supp] :=FALSE; END_IF END_IF

                IF VISU_SUP_SONDERaktiv_ay2_ST_ay1_[Werks][Supp] = TRUE AND VISU_Anfangswert_3_WzSt_[Werks] >0
                           THEN  
                                  IF  VISU_SUP_ay1_MsNullp_[Supp] - VISU_SUP_ay1_Ende_Sonder_[Supp]  > 
                                       Anfangspos_Maschine_ay1_[Werks] - VISU_Bearbeitungswert_2_WzSt_[Werks] - 
                                       VISU_Anfangswert_1_WzSt_[Werks]     
                                             THEN
                                                     2pos_Supp_ay2_vWerk_ay1_On[Werks][Supp] :=TRUE;  
                                              ELSE 
                                                     2pos_Supp_ay2_vWerk_ay1_On :=FALSE; END_IF
                            ELSE    
                                  IF  VISU_SUP_ay1_MsNullp_[Supp] + VISU_SUP_ay1_EndRefp_[Supp]          > 
                                       Anfangspos_Maschine_ay1_[Werks] - Stuecklaenge_ay1_[Werks]
                                              THEN  
                                                      2neg_Supp_ay2_vWerk_ay1_On[Werks][Supp] :=TRUE; 
                                              ELSE
                                                      2neg_Supp_ay2_vWerk_ay1_On :=FALSE; END_IF END_IF

                IF VISU_SUP_SONDERaktiv_ay2_ST_ay1_[Werks][Supp] = TRUE AND VISU_Bearbeitungswert_4_WzSt_[Werks] >0
                            THEN  
                                      IF  VISU_SUP_ay1_MsNullp_[Supp] + VISU_SUP_ay1_Start_Sonder_[Supp] + 
                                           VISU_Anfangswert_3_WzSt_[Werks] + VISU_Bearbeitungswert_2_WzSt_[Werks] +
                                           VISU_Anfangswert_1_WzSt_[Werks]  < Anfangspos_Maschine_ay1_[Werks]   
                                                 THEN 
                                                         3pos_Supp_ay2_vWerk_ay1_On[Werks][Supp] :=TRUE;  
                                                  ELSE 
                                                         3pos_Supp_ay2_vWerk_ay1_On[Werks][Supp :=FALSE; END_IF END_IF

                 IF  VISU_SUP_SONDERaktiv_ay2_ST_ay1_[Werks][Supp] = TRUE AND VISU_Endwert_5_WzSt_[Werks] >0
                           THEN    
                                       IF VISU_SUP_ay1_MsNullp_[Supp] -  VISU_SUP_ay1_Ende_Sonder_[Supp]   > 
                                           Anfangspos_Maschine_ay1_[Werks] - Stuecklaenge_ay1_[Werks] + 
                                           VISU_Endwert_5_WzSt_[Werks]    
                                                THEN 
                                                        4pos_Supp_ay2_vWerk_ay1_On[Werks][Supp] :=TRUE; 
                                                 ELSE 
                                                        4pos_Supp_ay2_vWerk_ay1_On[Werks][Supp] :=FALSE; END_IF
                              ELSE   
                                       IF VISU_SUP_ay1_MsNullp_[Supp] + VISU_SUP_ay1_EndRefp_[Supp]            > 
                                           Anfangspos_Maschine_ay1_[Werks] - Stuecklaenge_ay1_[Werks] 
                                                THEN
                                                        4neg_Supp_ay2_vWerk_ay1_On[Werks][Supp] :=TRUE;  
                                                ELSE 
                                                        4neg_Supp_ay2_vWerk_ay1_On[Werks][Supp] :=FALSE; END_IF END_IF END_IF

IF         (pos_Supp_ay2_vWerk_ay1_On[Werks][Supp] =  TRUE OR 1neg_Supp_ay2_vWerk_ay1_On[Werks][Supp] = TRUE) 
     AND 
           (2pos_Supp_ay2_vWerk_ay1_On[Werks][Supp] = TRUE OR  2neg_Supp_ay2_vWerk_ay1_On[Werks][Supp] = TRUE
            OR    3pos_Supp_ay2_vWerk_ay1_On[Werks][Supp] =TRUE) 
     AND 
           (4pos_Supp_ay2_vWerk_ay1_On[Werks][Supp] = TRUE OR 4neg_Supp_ay2_vWerk_ay1_On[Werks][Supp=TRUE) 

             THEN  
                     S_ay2_Werks_ay1AN[Werks][Supp] := TRUE; 
             ELSE  
                     S_ay2_Werks_ay1AN[Werks][Supp] := FALSE; END_IF[/color]

END_FOR
END_FOR

exchange · 8. Oktober 2013 um 16:15

Hallo,
wie definierst Du gleich schnell?
Was ist denn das für eine SPS? Kann die Multitasking?

Hast Du dir mal überlegt, wie schnell ein Prozess in der SPS abgearbeitet wird und wie schnell die Maschine dafür benötigt? Es bringt nichts, wenn die SPS schneller ist.

Gruß

CoDeSys123456 · 8. Oktober 2013 um 18:49

Hallo exchange,

also dieser Prozess (Teilprogramm) mit 12 Arrays * 20 Arrays = 240 Aufrufe. Darf maximal 100 ms benötigen, sollte der Prozess sich öffters wiederholen, wäre dies kein Problem.

Grüße

CoDeSys