TIA Anfängerfrage Flankenerzeugung

TommyLee0815

Level-1
Beiträge
7
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Forum,
Newbie-Frage:
Ich arbeite (halbwegs) erfolgreich auf einer S7-1200 mit angeschlossenem CM1241.
Ich kommuniziere mit einem elektronischen Board und kann (in KOP) auch den vom Board erhaltenen Text splitten, die Informationen auf eine HMI verteilen etc.

Aber ich stehe bei einer Sache auf dem Schlauch:
SEND_PTP erfordert zum Senden am REQ-Eingang eine positive Flanke. Aktuell gehe ich (vor lauter Verzweiflung) über "Clock_2.5 Hz" darauf, was aber ab und zu zu Timing-Problemen führt: Geht mal - geht mal nicht.
Ein pauschales Setzen auf "TRUE" funktioniert auch nicht (da eine Flanke verlangt wird).
Ashampoo_Snap_Montag, 19. Oktober 2020_14h28m33s_002_.png
Peinlich, aber ich weiß es nicht: Wie erzeuge ich denn in KOP am Eingang jedes Mal, wenn in das Netzwerk mit dem Send_PTP-Baustein verzweigt wird, am REQ-Eingang eine positive Flanke?
Mit einem echten Hardware-Schalter (und Setzen der Variablen hierzu "vorm REQ-Eingang") funktioniert das jedes Mal, mit Variablen, die ich (in vorigen, "oberen" Netzwerken setze) nicht.

Danke im Voraus,

Tom
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

wenn du so schnell wie möglich senden möchstest, kannst du auch an REQ das invertierte DONE schreiben.
Dann bekommt er immer wenn er fertig ist, eine neue Flanke.
 
Gibt es denn keinen Baustein für die Erzeugung einer positiven Flanke?
Der von Dir gewählte Takt %M0.2 erzeugt schon positive Flanken jedesmal, wenn der Zustand von LOW (0) auf HIGH (1) wechselt!
Bei Dir besteht jedoch das Problem, dass nicht jede der Anforderungen durch diese Flanken verarbeitet werden kann, weil noch die letzte Anforderung bearbeitet wird.

Deshalb der Vorschlag von Windoze:
Solange der Baustein eine Anforderung bearbeitet, ist mit dieser Lösung Dein Anforderungssignal auf LOW.
Mit Beendigung der Abarbeitung wechselt es auf HIGH (die gewünschte Flanke!) und das nächste Senden wird veranlasst.
Usw...
 
Gibt es denn keinen Baustein für die Erzeugung einer positiven Flanke?
P_Trig, R_Trig

Tip: rechts oben in der Taskcard "Anweisungen" einfach "Flanke" eintippen und Enter.


Du brauchst aber keinen Baustein zur Erzeugung einer positive Flanke, der SEND_PTP erkennt schon selber die positive Flanke des an REQ anliegenden Signals. Du musst nur dafür sorgen, daß das Signal an REQ zur rechten Zeit von 0 zu 1 wechselt. Wann das Signal dann wieder von 1 zu 0 wechselt ist egal, Hauptsache vor dem nächsten gewünschten 0-1-Wechsel.

Wann willst/musst Du denn senden? Zyklisch immer wieder oder nur bei bestimmten Ereignissen? Wie braucht Dein Partnergerät das?

Harald
 
Ja, eben nicht zyklisch. Und durch alle möglichen Hilfstricks wie eingestreute SCL-Schnipsel versuche ich das zu "verbiegen", also wie in einem Skript schön Programmfluss-kontrolliert zu machen. Wahrscheinlich sonderlich SPS-konform..

Mein Partnergerät braucht ASCII-Befehle mit einem "$R" am Schluss - das funktioniert alles wunderbar, auch das Empfangen.

Aber an der Send_PTP-REQ-Eingang-Geschichte hakt es. Ich hatte immer den Eindruck, dass der Send_PTP immer geht, aber das war wohl Zufall.
Auch ein "Warten" auf Done=TRUE ist mir nicht gelungen, damit es im Netzwerk erst gar nicht weitergeht: Ein JMP-Befehl mit Abfrage führt zu einem Fehler an der S7-1200; kompilieren tut er es noch.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

Grundsätzlich solltest du nicht innerhalb eines SPS Zyklus auf irgendwas warten.
Eine SPS ist eigentlich ein großes Kooperatives Multitasking. Abarbeiten was gerade geht und weiter mit dem nächsten Programmteil.


Um einen Ablauf / eine Sequenz hinzubekommen solltest du dich mal mit State-Machines beschäftigen.
 
Du könntest mit einer Schrittkette arbeiten. In dem Schritt wo Du senden möchtest, setzt Du eine Sendeanforderung-Variable und schaltest zum nächsten Schritt. Im nächsten Schritt rücksetzt Du die Sendeanforderung (wodurch die Sendeanforderung nur einen Zyklus lang 1 ist) und wartest auf das DONE oder ERROR vom SEND_P2P.

Oder Du schließt die Sendeanforderung Send_Req so an:
Code:
                             Send_Active       "Send_P2P_DB"
                              +-------+      +----------------+
 Send_Req        (*)          |   SR  |      |    SEND_P2P    |
----| |-----------------------|S     Q|------|REQ
                              |       |      |
"Send_P2P_DB"                 |       |      |...
   .DONE                      |       |      |
----| |-------------------+---|R1     |
                          |   +-------+
"Send_P2P_DB"             |
   .ERROR                 |
----| |-------------------+
                          |
              +-------+   |
Send_Active   |  TON  |   |
----| |-------|IN    Q|---+
        T#5s--|PT     |
              +-------+
Send_Req sollte möglichst nur 1 Zyklus lang sein. Wenn Send_Req länger anliegt bis zum Zyklus nach DONE oder ERROR, dann wird nochmal gesendet. Bei Bedarf kann bei (*) ein P_TRIG eingefügt werden, dann wird erst wieder gesendet, wenn Send_Req einmal auf 0 gewechselt hat und wieder 1 wird. Der TON soll Send_Active irgendwann rücksetzen, falls SEND_P2P "spinnt" und kein DONE/ERROR kommt.

Harald
 
Gibt es denn keinen Baustein für die Erzeugung einer positiven Flanke?
Da gibt's diverse, z.B.
- AND-Verknüpfung liefert eine positive Flanke, sobald alle Eingänge True sind.
- OR-Verknüpfung liefert eine positive Flanke, sobald nicht mehr alle Eingänge False sind.
- XOR-Verknüpfung liefert eine positive Flanke, sobald sich die Zustände an beiden Eingänge unterscheiden.
- VergleichsOperationen liefern eine positive Flanke, sobald die VergleichsBedingung erfüllt ist.
- RS-FF liefert eine positive Flanke, sobald der S-Eingang True ist.
- SR-FF liefert eine positive Flanke, sobald der S-Eingang True und der R-Eingang False sind.
- u.s.w. ...

Deute ich Deine ProblemBeschreibung richtig, dass Du den SendeBaustein bedingt aufrufst, also nur dann, wenn Du meinst, ihn aktivieren zu müssen?
Das wäre grundlegend falsch. Immer aufrufen und nur mit Deinem "positiveFlankenSignal" aktivieren!
Wie schnell Du dieses Signal dann wieder auf False setzen darfst, weiss ich nicht. Ein Impuls von 1 Zyklus Länge könnte/dürfte zu kurz sein, weshalb ich P-Trig und R-Trig vorsichthalber vermeiden würde.
Status, Error und Done sagen Dir aber, ob der Baustein bereit ist für neue Taten. Also für eine neue positive Flanke, ABER eine neue positive Flanke kann es nur geben, nachdem eine negative Flanke erfolgt ist!

Nicht so viel über "alle möglichen Hilfstricks" nachdenken, sondern möglichst "geradeaus" programmieren! ;)
 
Erstmal herzlichen Dank an Alle! Da sind reichlich Ideen und vor allem grundlegende Konzepte dabei.

Ich muss auch empfangen, aber das ist unproblematisch: Ab ins Array of Chars => in einen String umgewandelt => an den Stellen mit Semikolon splitten => Werte berechnen/umwandeln => sind HMI-Variablen und landen schön in den dafür vorgesehenen Feldern (inkl. Beschriftung) auf dem KTP700 basic.

Heinileins "Deute ich Deine ProblemBeschreibung richtig, dass Du den SendeBaustein bedingt aufrufst, also nur dann, wenn Du meinst, ihn aktivieren zu müssen? Das wäre grundlegend falsch. Immer aufrufen und nur mit Deinem "positive FlankenSignal" aktivieren!" ist hier für mich sehr wichtig - ich versuche das bis dato immer (irgendwie) in ein Skript-ähnliches Konzept zu fassen, dass ausschließlich bedingt arbeitet.
Der Hinweis auf die state machines ist auch hilfreich.
Ich werde das KOP-Gerüst entsprechend entwirren und "paralleler" Arbeiten.
Danke auch für die ausführlichen KOP-Schemata von PN/DP.

Eine Frage hätte ich noch:
Beim Übergang von KOP zu SCL (was mir von Anfang an sympathischer war...): Wird es hier "für mich besser"? Kann ich hier meine verinnerlichten "Grundsätze" aus Python, C#, Delphi eher anwenden?

Danke,

Tom
 
Beim Übergang von KOP zu SCL (was mir von Anfang an sympathischer war...): Wird es hier "für mich besser"? Kann ich hier meine verinnerlichten "Grundsätze" aus Python, C#, Delphi eher anwenden?
Das kommt ganz drauf an, welche Grundsätze Du verinnerlicht hast. ;)
Du musst bedenken, dass ein SPS-Programm MultiTasking sehr vieler von einander abhängigen oder auch unabhängigen Aufgaben in einer einzigen Task (oder sehr wenigen Tasks) darstellt.
Für "Frischlinge" ein ungewohntes Konzept. In jedem Zyklus wird alles durchgekaut und trotzdem darf der Zyklus nicht lange dauern, weil sonst die Reaktionen auf einen TastenDruck oder eine Änderung einer SensorMeldung mit viel zu grosser Verzögerung erfolgen. Schnelle Änderungen "hin und zurück" (also kurze Impulse) können dann vom Programm nur noch "rein zufällig" wahrgenommen werden.
ProgrammSchleifen (um z.B. den nächsten freien Platz im Regal zu finden) sind durchaus möglich, aber sie dürfen natürlich nur "wohl dosiert und sehr sparsam" die ZyklusZeit verlängern.
Darum ist auch besonders darauf zu achten, dass das EndeKriterium einer Schleife sorgfältig gewählt wird und nicht in irgendwelchen Fällen (z.B. Daten-abhängig), von denen man gemeint hat, sie würden wohl so gut wie nie auftreten, dann doch aus einer Schleife eine EndlosSchleife machen.
Ich hatte zuvor geschrieben, dass bedingtes Aufrufen bzw. Durchlaufen von ProgrammStücken "grundlegend falsch" ist. Das kann man nicht so kategorisch behaupten. Ausnahmen gibt es natürlich.
Aber man kann davon ausgehen, dass die KommunikationsBausteine von z.B. Siemens so programmiert sind, dass ein zyklisches Aufrufen erforderlich ist. Sie prüfen zunächst, ob es etwas zu tun gibt und wenn nicht, dann geben sie auf schnellstem Wege die Kontrolle an das aufrufende Programm zurück - wie Du siehst, ist dies eine Anwendung eines bedingten Sprunges oder einer ProgrammVerzweigung, um die Du Dich aber nicht zu kümmern brauchst, das haben Dir andere schon abgenommen. ;)

KOP ist eine ProgrammierSprache "von Elektrikern für Elektriker". Sie ahmt die Darstellung von Relais-/Schütz-Schaltungen in SchaltPlänen nach. SerienSchaltung ist eine UND-Verküpfung und ParallelSchaltung ist eine ODER-Verküpfung. Soweit, so einfach. Dies ist auch für Nicht-Elektriker leicht zu erlernen und anschaulich. Sobald es nicht mehr um BitVerknüpfungen geht, greift die KOP-Darstellung auf die Mittel der FUP-Darstellung (FunktionsPlan) zurück.

SCL (oder ST) bedient sich der SprachElemente, die "HochsprachenProgrammierern" geläufig sind.
WertZuweisungen sehen aus wie mathematische Formeln. Links vom ':=' steht, wo das Ergebnis abgespeichert werden soll und rechts davon steht, was gerechnet werden muss.
HochsprachenProgrammierer wissen schon, dass dies keine Gleichungen sind und erschrecken deshalb nicht, wenn sie z.B. 'X := X + 1' sehen.
HochsprachenProgrammierer erschrecken schon eher, wenn sie 'X := A = B' sehen oder 'X := A <> B'. Denn komischerweise ... hmmm ... erklär Du es mir!!!

Klipp und klar: Nein, es wird nicht besser für Dich. Nicht in dem Sinne, dass Du dann vergessen darfst, ein zyklisches Programm zu lesen oder zu schreiben!
 
Mit euren Tipps habe ich es hinbekommen. RS485 über ASCII/Senden und Empfangen/HMI/einfache, aber nun funktionierende Programmlogik.
Nun schaue ich mir SCL an und dann ist RS484 Modbus RTU dran... :|
 
Zurück
Oben