Erste Schritte S7-300

[Andy082]

Abend.

Hab mir nach langem zögern aus meiner Firma zwei TP170B monocrom und eine ältere 315-2DP ausgeliehen und würde hier nun soetwas wie eine Gebäudesteuerung erstellen. Normal plane & baue ich Produktionsanlagen nur zusammen und lasse quasi programmieren. *gg*

Vorgreifend: mein Wissensstand betreffend S7-300 sind unterstes/mittleres Level, jedoch hab ich bereits beide Panel mit WinCC projektiert und kann von beiden über ein DBX bereits Ausgänge etc ohne Probleme steuern, Status anzeigen, oder Text in das eine Panel eingeben und am anderen ablesen, etc.
Alles keine Hexerei....

Nun würde ich gerne eine Codeeingabe programmieren.
Hierfür hab ich eine eigene Zahlen-Tastatur angelegt. (nicht die Nummerntastatur von WinCC)
Mein Problem ist nun aber, dass ich zwar beliebige Bits in ein DBW schreiben kann, aber diese summieren sich immer automatisch.
Was mir vorschweben würde ist, dass ich zB 1-3-4-2 drücke und dann auch tatsächlich 1342 im DB steht.
Es würde auch reichen, wenn ich weiß wie ich einzelne Bits oder DBW zu einem DBW zusammenfassen könnte.

Nächstes Problem wäre dann noch, wie kann ich die Eingabe mit einem zuvor festgelegten Wert eines DB vergleichen und im Falle einer richtigen Eingabe zB einen Ausgang steuern, bzw. bei einer falschen Eingabe nach 4 Tasten nochmals anfangen?


mfg, Andy.


P.S.: welche Lektüre wäre für Einsteiger bzw. leicht fortgeschrittene zu empfehlen?

[Larry Laffer]

Hallo Andy,
die letzte Frage zuerst :

welche Lektüre wäre für Einsteiger bzw. leicht fortgeschrittene zu empfehlen?

aus meiner Sicht reicht das interessierte Mitlesen im SPS-Forum und das gelegentliche Stellen von Fragen vollkommen aus.

Zu deiner (technischen) Frage :
Ich gehe hier davon aus, dass es dir in erster Linie um deine "selbst-erstellte" Code-Eingabe geht. Du hast hier vermutlich die Tasten 0 bis 9 und Abbruch und Übernahme. Bei den Tasten-Eingaben möchtest du vermutlich ein "*" oder so in der Anzeige erscheinen lassen ...
Das hat Anforderungs-Charakter ...
Da du für die ganze Geschichte ein Low-Level-TP einsetzt muß hier ALLES über die SPS laufen - ansonsten hättest du bei einem leistungsfähigerem Bediengerät vorhandene Script-Fähigkeiten nutzen können und das darüber abwickeln können.
Ich würde jeder Taste ein Bit in der SPS zuordnen und diese auf eine hohe Aktualisierungsrate setzen. Nun mußt du in der SPS ein Programm haben (hier würde sich z.B. eine Schrittkette anbieten), dass die Eingaben aufnimmt, in eine Ergebnis-Variable schreibt und diese dann auswertet. Hierfür solltest du dir zunächst den Ablauf dieser Schrittkette überlegen (weil von der hängt alles andere ab). Zu diesem Thema sollte es im Forum auch schon Threads geben - vielleicht bemühst du die Foren-Suche mal mit dem Stichwort "Codeschloss" oder ähnlich.

Ich hoffe, dass bringt sich erstmal ein bißchen weiter ...

Gruß
LL

[Ralle]

Da hast du dir ja schon was ganz nettes vorgenommen. Ich skizziere mal einen Weg, den ich mir vorstellen könnte. Wie immer gibt es natürlich mehrere Wege.

Ich geh mal davon aus, daß du ein Word nutzt in einem DB. Bei einem Tastendruck setzt du jeweils ein Bit in diesem Wort. Du nutzt die Funktionen:

Beim Drücken der Taste: SetzeBitinVaribale
Beim Loslassen der Taste: RücksetzeBitinVariable

Du hast die Tasten 0-9 und noch eine Clear-Taste.
Die Cleartaste würde ich in ein gesondertes Word ablegen, macht sich später einfacher.

Step7 Programm:

Du brauchst:

1. Deine Tasteninputs (2xWord, 1x0-9, 1xClear)
2. Einen Timer, der erkennt, daß X Sekunden lang nichts eingegeben wurde, dann wird der Code gelöscht und der Codezähler auf Null gesetzt.
3. Einen Codezähler, der von 1-4 auf die Stelle weist, die gerade eingegeben und somit vom Programm in der SPS erwartet wird. (Int)
4. Für jede Codezahl eine Variable. (Code1-Code4, Int)
5. Eine Anzeigevariable für den Code. (Int)
6. Eine Vergleichsvariable, in der der Sollcode steht. (Int)
7. Eine Ausgabe, die anzeigt daß der Code IO ist. (Bool)

Nun zum Programm.

Teil 1 - Löschen

Zuerst würde ich den Fall programmieren, daß jemand lange nichts eingibt oder Clear drückt. Wenn das so ist wird eine Löschroutine angesprungen, die alles in den Anfangszustand versetzt. Dazu vergleiche das Tastenword (0-9) auf Null, wenn es Null ist lasse eine Zeit ablaufen (z.Bsp. 30 Sekunden). Ist die Zeit abgelaufen oder die Taste Clear wird gedrückt --> Sprung in eine Löschroutine, die alle Variablen auf 0 setzt, den Codezähler (4.) auf 1 und den Ausgang auf False.

Teil 2 - Codeeingabe

Das Programm ist im Ausgangszustand.
Es erwartet die Eingabe vom Nutzer. Dazu wird ständig das Inputword eingelesen und wenn es <> 0 ist, eine Flanke gebildet. Mit dieser Flanke wird nacheinander jedes einzelne Bit geprüft. Ist ein Bit True, wird die diesem Bit entsprechende Zahl, in diejenige Codavariable (Code1-Code4) eingetragen, auf die der Codezähler gerade zeigt.

Bsp.: Bei der ersten Eingabe und Bit 7 steht der Codezähler auf 1, eine 7 wird in Code 1 eingetragen. Nach dem Eintrag wird der Codezähler um eins erhöht und auf die nächste Flanke gewartet.
Bei der 2. Eingabe und Bit 3 steht der Codezähler auf 2 und eine 3 wird in Code 2 eingetragen, der Codezähler um 1 erhöht.

Achtung, Wichtig ist hier die Flanke!
Achtung, wenn eine 5. Eingabe erfolgt, darf man den Codezähler nicht auf 5 erhöhen, sondern muß ihn auf 1 setzen und die anderen Codestellen löschen. So wird dann wieder bei Code 1 begonnen!

Teil 3 - Codeanzeige

Zur Codeanzeige würde ich einfach eine Int nutzen.
Je nachdem, wo der Codezeiger steht (1-4) mit unterschiedlicher Berechnung.

Codezähler ist 1: Code 1 (gibt es noch keinen Code ist so automatisch eine 0 in der Anzeige, wenn man das nicht will muß man sich dazu auch noch etwas überlegen)
Codezähler ist 2: Code 1*10 + Code2
Codezähler ist 3: Code 1*100 + Code2*10 + Code3
Codezähler ist 4: Code 1*1000 + Code2*100 + Code3*10 + Code 4

Ich weiß jetzt nicht, ob man in WinCCFlex führende Nullen mit anzeigen lassen kann, wenn nicht, muß man das in Strings wandeln die Nullen ergänzen und nicht eine Int, sondern einen String anzeigen.

Teil 4 Codeauswertung

Es kann immer der in Teil 3 berechnete Code mit dem Sollcode verglichen werden. Das Ergebnis des Vergleiches auf den Ausgang legen. Wenn 30 Sekunden keine Neueingabe erfolgt, würde durch Teil 1 der Code und der Ausgang gelöscht werden.


Das war mal ein Weg, wie du ihn beschreiten könntest. Stell den jeweils fertigen Code hier ein und beschreibe, wo du Probleme hast, dann bekommst du garantiert Hilfe, bei der Lösung.

[Larry Laffer]

Nachtrag:
Ich habe noch einmal nach dem Code-Schloss-Thread gesucht. Das lohnt (glaube ich) nicht so. Da macht der beitrg von Ralle schon mehr her ...

Gruß
LL

[Andy082]

Hallo.


Mal recht herzlichen Dank für die detailierte Anleitung.
Leider muss ich zugeben, dass mir selbst der Unterschied zw. INT, WORD, ARRAY etc nicht klar sind, geschweigeden ich erst mal versuchen muss einzelne Sprünge zu programmieren.

Die Deklarierung der Tasten wiederrum war kein Problem.

Wo genau ich denn nun ansetze wird sich in den nächsten Tagen zeigen, aber ich bleib am Ball.


mfg,
Andy

[Larry Laffer]

Versuch doch vielleicht erstmal einen Ablauf für die Code-Eingabe in der SPS zu erstellen. Du könntest hier ja auch testweise zunächst mit "Standard"-Eingängen arbeiten und diese dann später durch die Visu-Tasten zu ersetzen ...

Gruß
LL

[Andy082]

So, ich bin langsam so weit, dass ich's aufgeb´....

Die Bit der entsprechenden Tasten in die DB zu schreiben ist das geringste Problem. Egal ob ich das DBW in Dez oder Bin beschreibe, oder die Taste als DBX zur SPS bringe.

Ich muss meine erste Aussage bezüglich meinem Wissenstand wohl revidieren und mit "unter aller s..." neu beschreiben.

Meiner bisherigen Meinung nach reicht es in AWL ein paar Zeilen alá

U E0.0
U E0.1
UN E 0.2
= A0.0

rein zu klopfen und man kann zumindest etwas steuern.

Aber ich hab ja schon mal keine Ahnung was genau denn das Fenster "Umgebung/Schnittstelle" für eine Verwendung findet, bzw. wenn ich die dortige Schnittstelle verwende, welchen DB etc ich hier gleichzeitig miteinbeziehe.
Auch das programmieren von Schritten ist für mich ein Rätsel, da kann ich noch so viele Beispiele von Sprungleisten (SPL), springe bedingt (SPB) oder springe absolut (SPA) durcharbeiten um deren Sinn zu verstehen.

Das berechnen von Daten und rückschreiben in ein DBW ist wiederum keinerlei Hexerei.

Gibt's online keine Lektüren die man sich einverleiben kann?


mfg,
Andy

[Ralle]

Vielleicht fängst du mal hier an: https://www.automation.siemens.com/f...tm?HTTPS=REDIR

PS. Und nicht so schnell aufgeben, alles keine Hexerei mit den SPS.

[Andy082]

Danke mal für die Links zu den Handbüchern.
Die Sachen bringen einen wirklich etwas tiefer in die Materie.

Nun denn.....

// Schrittkette
SET
L Z 10
SPL STR
SPA S000
SPA S001
SPA S002
SPA S003
SPA S004
SPA S005
SPA S006
SPA S007
SPA S008
SPA CLR
STR: SPA KEND

// Schritt 0 - warte auf Eingabe;
S000: L "CodeHSK".CodeTasten
T "CodeHSK".Code1st
U "CodeHSK".Taste_CLR
SPB CLR
U "CodeHSK".Taste_gedrueckt
ZV Z 10
SPA KEND

// Schritt 1 - Eingabe auf 1.Codestelle schreiben;
S001: L "CodeHSK".Code1st
T "CodeHSK".Code12
T "CodeHSK".CodeAnzeige
UN "CodeHSK".Taste_gedrueckt
ZV Z 10
SPA KEND

// Schritt 2 - warte auf Eingabe;
S002: L "CodeHSK".CodeTasten
T "CodeHSK".Code2st
U "CodeHSK".Taste_CLR
SPB CLR
U "CodeHSK".Taste_gedrueckt
ZV Z 10
SPA KEND

// Schritt 3 - Eingabe auf 2.Codestelle schreiben;
S003: L "CodeHSK".Code1st
L 10
*I
L "CodeHSK".Code2st
+I
T "CodeHSK".CodeAnzeige
T "CodeHSK".Code12
UN "CodeHSK".Taste_gedrueckt
ZV Z 10
SPA KEND

// Schritt 4 - warte auf Eingabe;
S004: L "CodeHSK".CodeTasten
T "CodeHSK".Code3st
U "CodeHSK".Taste_CLR
SPB CLR
U "CodeHSK".Taste_gedrueckt
ZV Z 10
SPA KEND

// Schritt 5 - Eingabe auf 3.Codestelle schreiben;
S005: L "CodeHSK".Code12
L 10
*I
L "CodeHSK".Code3st
+I
T "CodeHSK".CodeAnzeige
T "CodeHSK".Code123
UN "CodeHSK".Taste_gedrueckt
ZV Z 10
SPA KEND

// Schritt 6 - warte auf Eingabe;
S006: L "CodeHSK".CodeTasten
T "CodeHSK".Code4st
U "CodeHSK".Taste_CLR
SPB CLR
U "CodeHSK".Taste_gedrueckt
ZV Z 10
SPA KEND

// Schritt 7 - Eingabe auf 4.Codestelle schreiben;
S007: L "CodeHSK".Code123
L 10
*I
L "CodeHSK".Code4st
+I
T "CodeHSK".CodeAnzeige
UN "CodeHSK".Taste_gedrueckt
ZV Z 10
SPA KEND

// Schritt 8 - IstCode mit SollCode vergleichen
S008: L "CodeHSK".CodeAnzeige //entspricht IST-Code
L "CodeHSK".CodeSoll //entspricht SOLL-Code
==I
S "CodeHSK".CodeOK
R Z 10
L "CodeHSK".CodeAnzeige //entspricht IST-Code
L "CodeHSK".CodeSoll //entspricht SOLL-Code
<>I
ZV Z 10
SPA KEND
// Schritt CLR zum Löschen aller Eingaben
CLR: L 0 //alle DBW ruecksetzen
T "CodeHSK".Code1st
T "CodeHSK".Code2st
T "CodeHSK".Code3st
T "CodeHSK".Code4st
T "CodeHSK".CodeAnzeige
T "CodeHSK".Code12
T "CodeHSK".Code123
U "CodeHSK".Taste_CLR
R Z 10
R "CodeHSK".CodeOK //Code-ok rücksetzen
SPA KEND
KEND: NOP 0

....so sieht der erste Entwurf denn dann mal aus.
Dass ich dafür den ganzen SO und halben MO gesessen bin, darf man eh nicht verraten.

Der SOLL & IST-Vergleich inkl. anschliessender Freigabe funktioniert noch nicht so ganz.

Ich hoffe das Schmuntzeln hält sich in Grenzen.


mfg,
Andy

[Ralle]

Immerhin, man kann doch schon erkennen, was es sein soll. Gar nicht so schlecht.

Den Soll-Ist-Vergleich mußt du doch nicht innerhalb eines Schrittes machen. Den kannst du ganz hinten in ein neues Netzwerk Schreiben. Solange Soll=Ist, Ausgang mit = ansteuern.

Wann soll eigentlich der Code gelöscht werden? Nur mit der Clear-Taste?