TIA Temperaturanzeige und Schrittanzeige über BCD-Anzeige

Rainör

Level-1
Beiträge
20
Reaktionspunkte
5
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo zusammen,

ich möchte an meiner Anlage (Simatic S7 1200 CPU 1214C /Programmiersprache: FUP) die Temperatur anzeigen lassen, die über einen Analogeingang von einem PT100-Sensor gemessen wird. Das Signalboard ist extra für einen PT100-Sensor ausgelegt, sodass die Temperatur über einen Wert von z.B. 320 für 32°C dargestellt wird. Ich

Nun habe ich an meiner Anlage eine BCD-Anzeige eingebaut, die über die SPS mit den Ausgängen A, B, C und D gesteuert wird. A mit der Wertigkeit 2^0, B mit 2^1, C mit 2^2 und D^4. Beispiele: A=0, B=1, C=1, D=0: Anzeige = 6; A=1, B=0, C=0, D=1: Anzeige = 9.

Da die Anzeige nur eine Ziffer darstellen kann, möchte ich, dass bei z.B. 32°C die Anzeige erst eine 3 anzeigt, danach eine 2. Dann soll 1s Nichts dargestellt werden, ehe die Visualisierung wiederholt wird. Um Nichts anzuzeigen müssen alle Ausgänge (A, B, C & D) gleichzeitig angesteuert werden. Die Temperarturanzeige soll ein- und ausgeschaltet werden können.

Nun könnte ich ja theoretisch mit Vergleicher-Bausteinen die Temperatur auslesen und dann die einzelnen Ausgänge nacheinander zielgerichtet ansteuern und mit Zeitbausteinen einen Anzeigezyklus programmieren. Soll ich das jedoch für jedes einzelne Grad selber machen, wird das wohl ein riesen Programm. Genau deswegen suche ich hier nach einer effizienteren Lösung.

Weiterhin hat meine Anlage ein Automatikmodus mit 9 Schritten. Nun möchte ich im Automatikmodus ebenfalls die Temperaturanzeige einschalten können, sodass erst die Temperatur angezeigt wird, dann 1s Nichts und dann für z.B. 2s der aktuelle Schritt, dann wieder 1s Nichts und dann wieder die Temperatur.
Zudem möchte ich noch eine Funktion einbauen, dass ich auswählen kann, dass die Temperatur entweder nur bis zur gewünschten Temperatur oder die ganze Zeit angezeigt wird.

Ich denke, dass wenn ich einmal die Temperaturanzeige einmal sinnvoll programmiert und verstanden habe, sich die anderen Funktion recht einfach hinzufügen lassen. Für eure Hilfe und Tipps wäre ich sehr dankbar.

Liebe Grüße
Rainer
 
Mache Dir für die Anzeige eine Schrittkette, die im 1s-Takt weiterschaltet/weiterzählt (2 Ziffern-Temperatur evtl. besser 2x je 0.5s lang anzeigen?). In den Schritten weise einer Word- oder Byte-Variable den auszugebenden Wert (Ziffer oder dunkel) zu (Stichwort: CASE). Und den Ausgängen, wo die BCD-Anzeige angeschlossen ist, weise die Bits aus der Anzeigevariable zu:
Code:
Q_A := bAnzeigewert.%X0;
Q_B := bAnzeigewert.%X1;
Q_C := bAnzeigewert.%X2;
Q_D := bAnzeigewert.%X3;

Zum programmieren lernen ist das eine schöne Übungsaufgabe, in der Praxis ist es aber günstiger und viel verständlicher, einfach ein kleines HMI-Display anzubauen und alles im Klartext anzuzeigen.

Harald
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Moin zusammen,

etwas verspätet, aber danke für die Antwort. Im letzten Kurs wollte ich mir diese Herausforderung die Temperaturanzeige zu programmieren einmal stellen. Doch wie es so ist dann kam dann die Berufsschule, dann der Außendienst in der Abteilung und die Prioritäten haben sich erstmal verlagert. Nun habe ich Urlaub und möchte mich dieser Aufgabe zur Vorbereitung auf den nächsten Kurs nochmal annehmen.

Ich muss gestehen, dass ich mit der Antwort noch nicht so viel anfangen kann. Das Stichwort Case habe ich in Hinblick auf FUP-Programmierung auch nicht gefunden.

Ich verstehe, dass ich mit einer zyklisch rotierenden Schrittkette, die alle 0,5s weiterschaltet und eine 1 ausgibt die Temperatur an der BCD-Anzeige theoretisch irgendwie anzeigen lassen könnte. Jedoch verstehe ich noch nicht wie ich z.B. die Ziffer 13 in zwei Ziffern auftrennen lassen kann, sodass erst die 1 und dann die 3 angezeigt wird, weil meine BCD-Anzeige ja nur eine Ziffer zurzeit anzeigen kann.
Mein Gedanke war, dass ich über die Schrittkette im ersten Schritt die erste Zahl und im zweiten Schritt die zweite Zahl anzeigen lassen kann.

Weiterhin wird mir die Temperatur ja mit dem Datentyp Integer ausgegeben. Das sind ja letztendlich 16 Bits. Ich weiß hier nicht wie ich diesen Datentyp auf meine 4 Eingänge der BCD-Anzeige zuweisen kann. Welche Bausteine benötigt werden dort benötigt?

Ich würde mich sehr über weitere Hinweise und Tipps freuen!

PS.: In einen der nächsten Aufgaben sollen wir auch noch mit einem HMI-Panel arbeiten.
 
Case ist auch ein Befehl in SCL der einem bei unterschiedlichen Werten verschachtelte Abarbeitungen ausführt.

Zudem kannst du in SCL in der Tat gleich den Befehl

Code:
INT_TO_BCD(IN:=integer_wert);

verwenden.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Das Stichwort Case habe ich in Hinblick auf FUP-Programmierung auch nicht gefunden.
Das habe ich irgendwie überlesen daß Du FUP haben willst. Mein Beispielcode und der Hinweis auf CASE ist in SCL. In FUP kann man für CASE Mehrfachverzweigung die Anweisung JMP_LIST verwenden, man kann den Vergleich mit der Schrittnummer (Zählerstand) aber auch für jeden Schritt mit einem Vergleicher CMP== machen.

Jedoch verstehe ich noch nicht wie ich z.B. die Ziffer 13 in zwei Ziffern auftrennen lassen kann, sodass erst die 1 und dann die 3 angezeigt wird, weil meine BCD-Anzeige ja nur eine Ziffer zurzeit anzeigen kann.
Mein Gedanke war, dass ich über die Schrittkette im ersten Schritt die erste Zahl und im zweiten Schritt die zweite Zahl anzeigen lassen kann.
Einen Zähler, der alle 0.5s weiterschaltet und nach dem höchsten Schritt wieder auf den Startwert geht, kriegst Du vermutlich hin. Empfehlung: realisiere den mit ADD oder INC, da läßt sich am einfachsten der Startwert festlegen.

Nimm Dir ein Blatt Papier und schreibe die Schrittnummern untereinander, dahinter schreibe was in dem Schritt angezeigt werden soll, z.B. Anzeige Temperatur 32°C:
Schritt 0: dunkel
Schritt 1 Temperatur Zehnerstelle (3)
Schritt 2 Temperatur Einerstelle (2)
Schritt 3 zu Schritt 0 gehen/Schrittnummer auf 0 setzen

An die einzelnen Ziffern der Temperatur kannst Du herankommen mit Konvertierung zu BCD und dann ausmaskieren der jeweils 4 Bits einer BCD-Stelle. Oder einfacher: wenn die Temperatur im Bereich 0..99 vorliegt, dann durch 10 Ganzzahl dividieren ergibt die Ziffer der Zehnerstelle und MOD 10 ergibt die Ziffer der Einerstelle.
Wie schaltet man Deine BCD-Anzeige dunkel? Den Wert 15 (16#F) ausgeben?

Dann programmierst Du aus, was in jedem Schritt passieren soll, z.B. die Zuweisung des gewünschten Wertes an die Ausgabevariable. Wenn ein Schritt länger dauern soll (z.B. 1s dunkel), dann mache den Schritt einfach 2 Schritte lang. Und zum Schluß kopierst Du die 4 Bits der Ausgabevariable an die 4 Digitalausgänge, wo Deine BCD-Anzeige angeschlossen ist. Etwa so:
Code:
               +-------+
               |  ==   |
               |  INT  |               +--------+
Schrittnummer--|IN1    |               |  MOVE  |
            3--|IN2    |---------------|EN      |
               +-------+            0--|IN   OUT|--Schrittnummer
                                       +--------+

               +-------+
               |  ==   |
               |  INT  |               +--------+
Schrittnummer--|IN1    |               |  MOVE  |
            0--|IN2    |---------------|EN      |
               +-------+           15--|IN   OUT|--Ausgabeziffer
                                       +--------+

               +-------+
               |  ==   |                +-------+
               |  INT  |                |  DIV  |
Schrittnummer--|IN1    |                |  INT  |
            1--|IN2    |----------------|EN     |
               +-------+    Temperatur--|IN1 OUT|--Ausgabeziffer
                                    10--|IN2    |
                                        +-------+

               +-------+
               |  ==   |                +-------+
               |  INT  |                |  MOD  |
Schrittnummer--|IN1    |                |  INT  |
            2--|IN2    |----------------|EN     |
               +-------+    Temperatur--|IN1 OUT|--Ausgabeziffer
                                    10--|IN2    |
                                        +-------+


Netzwerk: Ziffernausgabe an BCD-Anzeige:
                             "BCD_1"
                   +-----+   +-----+
Ausgabeziffer.%X0--|  &  |---|  =  |
                   +-----+   +-----+

                             "BCD_2"
                   +-----+   +-----+
Ausgabeziffer.%X1--|  &  |---|  =  |
                   +-----+   +-----+

                             "BCD_4"
                   +-----+   +-----+
Ausgabeziffer.%X2--|  &  |---|  =  |
                   +-----+   +-----+

                             "BCD_8"
                   +-----+   +-----+
Ausgabeziffer.%X3--|  &  |---|  =  |
                   +-----+   +-----+

Wenn Du verschiedenes an der BCD-Anzeige ausgeben willst, dann kannst Du mit verschiedenen Schrittnummern arbeiten, z.B. 1..3 Temperaturanzeige, 11.. Temperaturanzeige und Auto-Schrittnummer, 21.. ?
und je nach Ausgabemodus lege den Startwert des Schrittzählers auf die entsprechende Anfangs-Schrittnummer.

Harald
 
Moin Zusammen,

ich habe mir die Antwort von @PN/DP mal angeschaut und angefangen das in meinem Programm zu übernehmen und nachzuvollziehen.

Einen entsprechenden Zähler habe ich leider noch nicht zusammenbasteln können. Ich versuche das, wie entfohlen, mit einem ADD-Baustein zu realisieren. Da die Additionseingänge den Datentyp Int haben, frage ich mich wie ich dort an IN1 überhaupt eine 1 anstehen lassen und dann innerhalb von 0,5s an IN2 auch eine 1 anstehen lassen kann. Bisher hatte ich immer nur mit BOOL gearbeitet. Meine Idee war erst dort mit Zeitbausteinen zu arbeiten, aber die haben ja den Datentyp BOOL, sodass ich die Ausgänge nicht den Additionseingängen zuweisen kann.
Kann ich die Signale hier vielleicht konvertieren? Bei dem CONVERT-Baustein kann ich jedoch nicht von BOOL auf Int konviertieren, wenn ich das richtig gesehen habe. Oder wie funktioniert das hier?

Das Sytem die Schrittnummern zu vergleichen und dann dementsprechend den jeweiligen Schritt ausführen zu lassen habe ich verstanden. Nur bei den DIV-Baustein stellt sich mir die Frage, wenn ich durch 10 Ganzzahl dividiere, wie der Rest der Division behandelt bzw. ob dann auf- oder abgerundet wird? Meine Bedenken sind hier, wenn ich z.B. 37°C habe, dass er als Zehnerstelle dann eine 4 anzeigt statt einer 3. Weiterhin muss ich noch erwähnen, dass mir der Temperaturwert in 100er angegeben wird. Also wenn ich 370 als Wert erhalte, habe ich eine Temperatur von 37°C. Aber hier müsste ich dann ja nur durch Ganzahl 100 dividieren, das Prinzip bleibt ja das Selbe.

Wie schaltet man Deine BCD-Anzeige dunkel?
Meine BCD-Anzeige schaltet dunkel, wenn alle Eingänge spannungsfrei sind. Eine 0 wird angezeigt, wenn alle Eingänge unter Spannung stehen.

Soweit ich weiß muss ich die Ausgabeziffern (Für jeden Schritt habe ich für die Ausgangsziffer im Datenbaustein einen einzelnen Output erstellt.) noch mit einen CONVERT-Baustein in Bcd16 konvertieren. Ich habe mir dort für jede Ausgangsziffer einen CONVERT-Baustein geschnappt.
Bis jetzt hatte ich immer nur Automatikschritte an meiner BCD-Anzeige anzeigen lassen. Hierfür habe ich 4 boolische Ausgänge an der SPS für die Siebensegmentanzeige. Hier habe ich also wieder ein ähnliches Problem. Wie kann ich nun meine Bcd16 Zahl so ausmaskieren, dass ich damit meine boolischen Ausgänge ansteurere? Mir sind in deinem Programm @PN/DP die .%X0, .%X1, .%X2, und .%X3 aufgefallen. Hat das was damit zu tun?

Falls mir dort andere Forenbeiträge oder Tutorials im Grundverständnis helfen, würde ich mich auch dort durchfuchsen. Nur muss ich wissen, was ich mir anschauen muss, sonst suche ich Ewigkeiten im dunkeln :D

Ich bedanke für die gute Hilfe, die ich hier schon erhalten habe. Ich bin mir sicher, dass sich die Mühe am Ende lohnen und ich sehr viel draus mitnehmen kann.

Gruß Rainer
 
Servus,

das wären zwar alles Basics, aber here we go.

1)
In der Hardwarekonfiguration deiner SPS, kannst du die Taktmerker der SPS aktivieren.
1678720228840.png
Das Taktmerkerbyte sollte hier so gewählt werden, dass bereits vorhandene Merker nicht beeinflusst werden.
Die jeweiligen Taktmerker des Bytes wechseln ihren Zustand in der angegebenen Frequenz zwei mal. (einmal von low auf high und umgekehrt)
In deinem Fall wählst du Takt 2 Hz, bei dem man alle 0.5s eine positive Flanke abfragen kann.
Mit diesem kannst du dann deine Schrittnummer weiterschalten.
1678720563228.png
Und falls deine Schrittnummer größer als gewollt ist, setzt du sie wieder zurück.
1678720663546.png

2)
Der DIV Baustein gibt dir das Ergebnis einer Division ohne Rest zurück. (Bei positiven Zahlen wird abgerundet)
Der MOD Baustein gibt dir den Rest zurück der bei einer Division der beiden angehängten Variablen entsteht.
Wenn du jetzt Hunderter auch noch angeben musst wäre wahrscheinlich die weniger umständliche Variante mit dem Convert To BCD16.

3) Du kannst deinen gemessene Temperatur (falls es eine Real ist und noch nicht in °C/10 angegeben ist) mal 100 nehmen und in ein Int umwandeln.
Dann convertierst du es mit dem To BCD16 in ein Word.
Bei dem sind dann die höchstwertigen 4 Bits (.%X15, .%X14, .%X13, .%X12) die Tausenderstelle, die nächsten 4 Bits die Hunderterstelle, die nächsten 4 Bits die Zehnerstelle und die letzten 4 Bits die Einerstelle.
Diese musst du dann nur noch je nach Schrittnummer auf deine Ausgänge schreiben.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
bei den DIV-Baustein stellt sich mir die Frage, wenn ich durch 10 Ganzzahl dividiere, wie der Rest der Division behandelt bzw. ob dann auf- oder abgerundet wird?
Ganzzahl-Division! siehe die Erklärung von R4m80. (Die TIA-Hilfe zum DIV-Baustein taugt leider gar nichts, weil sie nicht auf Details und die Problematik "Ganzzahl" eingeht)

Weiterhin muss ich noch erwähnen, dass mir der Temperaturwert in 100er angegeben wird. Also wenn ich 370 als Wert erhalte, habe ich eine Temperatur von 37°C. Aber hier müsste ich dann ja nur durch Ganzahl 100 dividieren, das Prinzip bleibt ja das Selbe.
Am einfachsten durch 10 dividieren (ergibt die Temperatur in ganzen Grad) und dann aus dem Ergebnis die Zehner- und Einerziffer wie bereits beschrieben ermitteln.

Meine BCD-Anzeige schaltet dunkel, wenn alle Eingänge spannungsfrei sind. Eine 0 wird angezeigt, wenn alle Eingänge unter Spannung stehen.
Da muß die Ziffer 0 für die Ausgabe noch umcodiert werden. Und ein Wert ungleich 0..9 als Codierung für "dunkelschalten" verwendet werden, z.B. 15 (16#F)

Soweit ich weiß muss ich die Ausgabeziffern (Für jeden Schritt habe ich für die Ausgangsziffer im Datenbaustein einen einzelnen Output erstellt.) noch mit einen CONVERT-Baustein in Bcd16 konvertieren. Ich habe mir dort für jede Ausgangsziffer einen CONVERT-Baustein geschnappt.
Wie bereits im Beitrag #6 geschrieben, den in FUP aufwändigeren Umweg über BCD braucht man nicht.
Allgemeine Zerlegung von Werten in Dezimalziffern: Die höheren Ziffern (Zehner, Hunderter, Tausender, ...) erhält man, indem man diese zuerst zur Einer-Stelle verschiebt, indem man durch 10 oder 100 oder ... dividiert. Danach mit MOD die erhaltene Einer-Stelle isolieren.

Wenn von einem mehrstelligen Wert die einzelnen Ziffernstellen nacheinander ausgegeben werden, dann darf sich der Wert während der Ausgabe nicht ändern. Er muß für die Dauer der Ausgabe "eingefroren" werden, z.B. durch Umkopieren vor oder zu Beginn der Ausgabe. Wenn z.B. die Temperatur während der Ausgabe zwischen 39 und 40 schwankt und der Wert wird nicht eingefroren, dann kann es passieren daß 30 oder 49 ausgegeben wird.

Wie kann ich nun meine Bcd16 Zahl so ausmaskieren, dass ich damit meine boolischen Ausgänge ansteurere? Mir sind in deinem Programm @PN/DP die .%X0, .%X1, .%X2, und .%X3 aufgefallen. Hat das was damit zu tun?
Die ".%X0" ... sind sogenannte Slice-Zugriffe und damit greift man auf die einzelnen Bits von Mehrbit-Datentypen zu. Im Programm kopiere ich damit die einzelnen Bits aus der Ausgabevariable in die Ausgänge, wo die BCD-Anzeige angeschlossen ist.

Die Slice-Zugriffe sollte man eigentlich nur mit Bitstring-Datentypen (BYTE, WORD, DWORD) machen, TIA erlaubt das aber auch mit Ganzzahlen INT, DINT usw.. Wenn man das IEC-konform machen will, dann muß man vor den Slice-Zugriffen den Wert aus der INT-Variable in eine WORD-Variable umkopieren (FUP: mit CONV Int to Int) und dann auf die Bits der WORD-Variable zugreifen.

Das Programm von #6 entsprechend angepasst:
Code:
Netzwerk: Ende dieser Schrittkette, auf ersten Schritt zurückstellen zum wiederholen
               +-------+
               |  ==   |
               |  INT  |               +--------+
Schrittnummer--|IN1    |               |  MOVE  |
            3--|IN2    |---------------|EN      |
               +-------+            0--|IN   OUT|--Schrittnummer
                                       +--------+
Netzwerke: Ausgaben je Schritt
//Anzeige dunkel = Code 15
//und Temperaturwert für Ausgabe einfrieren und auf ganze Grad skalieren, 370 --> 37
               +-------+
               |  ==   |
               |  INT  |               +--------+
Schrittnummer--|IN1    |               |  MOVE  |
            0--|IN2    |--+------------|EN      |
               +-------+  |        15--|IN   OUT|--Ausgabeziffer
                          |            +--------+
                          |             +-------+
                          |             |  DIV  |
                          |             |  INT  |
                          +-------------|EN     |
                            Temperatur--|IN1 OUT|--Anzeigewert
                                    10--|IN2    |
                                        +-------+
//Temperatur-Zehner, z.B. 37 / 10 = 3
               +-------+
               |  ==   |                +-------+
               |  INT  |                |  DIV  |
Schrittnummer--|IN1    |                |  INT  |
            1--|IN2    |----------------|EN     |
               +-------+   Anzeigewert--|IN1 OUT|--Ausgabeziffer
                                    10--|IN2    |
                                        +-------+
//Temperatur-Einer, z.B. 37 MOD 10 = 7
               +-------+
               |  ==   |                +-------+
               |  INT  |                |  MOD  |
Schrittnummer--|IN1    |                |  INT  |
            2--|IN2    |----------------|EN     |
               +-------+   Anzeigewert--|IN1 OUT|--Ausgabeziffer
                                    10--|IN2    |
                                        +-------+

Netzwerk: Ziffernausgabe an BCD-Anzeige, dunkel und 0 umcodieren
//Code 15 = dunkel --> 0 ausgeben, Ziffer 0 --> 15 ausgeben, Ziffern 1..9 = 1..9
               +-------+
               |  ==   |
               |  INT  |               +--------+
Ausgabeziffer--|IN1    |               |  MOVE  |
           15--|IN2    |--+------------|EN      |
               +-------+  |         0--|IN   OUT|--Ausgabeziffer
                          |            +--------+
                          |            +---+        +---+
                          +------------| & |o-------| & |
                                       +---+        |   |
                                       +-------+    |   |
                                       |  ==   |    |   |
                                       |  INT  |    |   |      +--------+
                        Ausgabeziffer--|IN1    |    |   |      |  MOVE  |
                                    0--|IN2    |----|   |------|EN      |
                                       +-------+    +---+  15--|IN   OUT|--Ausgabeziffer
                                                               +--------+

Netzwerk: Ziffernausgabe an BCD-Anzeige:

                   "BCD_1"
                   +-----+
Ausgabeziffer.%X0--|  =  |
                   +-----+

                   "BCD_2"
                   +-----+
Ausgabeziffer.%X1--|  =  |
                   +-----+

                   "BCD_4"
                   +-----+
Ausgabeziffer.%X2--|  =  |
                   +-----+

                   "BCD_8"
                   +-----+
Ausgabeziffer.%X3--|  =  |
                   +-----+

Harald
 
Zuletzt bearbeitet:
Moin zusammen,

ich wollte mich nochmal melden. Ich hatte nun die Möglichkeit an der Anlage mit meiner BCD-Anzeige zu arbeiten.

Zufrieden und erfreut kann ich mitteilen, dass das Programm funktioniert und die Anzeige so arbeitet wie sie soll. Den Part mit der Umcodierung konnte ich sogar ein bisschen einfacher ohne UND-Bausteine realisieren. Mit einem weiteren Zählerschritt zwischen Zehner- und Einerausgabe habe ich auch eine Pause programmiert, in der einfach alle Eingänge angesteuert werden und die Anzeige somit aus ist. Damit kann dann auch z.B. eine 33 gut erkannt werden.

Weiterhin habe ich es mit einem zweiten ADD-Zähler geschafft die Temperaturanzeige auch während meines Automatikbetriebs mit Schhrittanzeige zwischenzeitlich anzuzeigen. So wird die Schrittzahl lange angezeigt, dann wird kurz nichts angezeigt und danach die Zehner und die Einer der Temperatur zweimal nacheinander eingeblendet, ehe nach einer kurzen Anzeigepause wieder der akutelle Schritt gezeigt wird. Das wiederholt sich dann selbstverständlich.

Ich möchte einfach zum Schluss nochmal danke sagen an alle, die mir hier so fleißig, ausführlich und unermüdlich geholfen haben. Dank euch und der Aufgabe habe ich sehr viel Neues gelernt!

@PN/DP

Beste Grüße
Rainer
 
Zurück
Oben