Step 7 Programmierhilfe FUP

EMZ

Level-2
Beiträge
232
Reaktionspunkte
4
Zuviel Werbung?
-> Hier kostenlos registrieren
Hi Leute,

unter "sonstiges" habe ich schon ein Thread bezüglich der Programmierhilfe für LOGO erstellt, aber es hat sich ergeben, dass für diese Progrmmierung eine S7 eher eignet.

Ich will folgende Funktion:

Also, wenn Sensor 1 + Sensor 2 betätigt wurden, sollen von dort an 100 Impulse (oder können auch zum testen weniger sein die Zahl spielt vorerst keine Rolle) gezählt werden und dann soll der Ausgang Q1 angehen. Nachdem dann Ausgang Q1 an ist, sollen einfach nochmals 4 Impulse gezählt werden, damit der Ausgang wieder ausgeht.
Soll in der Zwischenzeit , in der die 100 Impulse z.B. über einen Geber gezählt werden, nochmal der Fall vorkommen, dass Sensor 1 + Sensor 2 betätigt werden, dann sollen parallel die 100 Impulse gezählt werden und dann der Eingang wieder nach 100 Impulsen für 4 Impulse angehen.

Die Problematik liegt daran, dass ich nicht weiß wie ich das ganze in FUP programmieren soll, da ich leider wenig Erfahrung darin hab. Ich weiß nicht welche Bausteine ich für die Rechenoperation benötige.

Ich wäre für jegliche Hilfe dankbar.



LG

EMZ
 
.
Ich denke mal, du solltest hier einfach deinen
Entwurf mal reinstellen, dann wird dir sicher
geholfen.

Eine erste Hilfe für Zähler findest du in STEP 7
mit der F1-Taste.
Alternativ kannst du die Impulse statt in FUP
auch in AWL einfach aufaddieren.

Erster Gedankenanstoss für dich:

Sensor 1 + Sensor 2 --> Zählung 1 freigeben
Merker 1 setzen für "Zählung 1 läuft"
wenn Merker 1, dann Impulse zählen

Merker 1 "Zählung 1 läuft" ist gesetzt (parallel zählen)
Sensor 1 +2 erneut betätigt --> Zählung 2 freigeben
Merker 2 "Zählung 2 läuft" setzen
wenn Merker 2, dann ebenfalls Impulse zählen

Q 1 setzen:
wenn 100 Impulse aus Zählung 1 erreicht --> Q1 setzen
ODER
wenn 100 Impulse aus Zählung 2 erreicht --> Q1 setzen

Q 1 rücksetzen:
weitere 4 Impulse (104 Impulse) aus Zählung 1 gezählt --> Merker 1 und Q1 rücksetzen
ODER
weitere 4 Impulse (104 Impulse) aus Zählung 2 gezählt --> Merker 2 und Q1 rücksetzen
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hi,

ja soweit ist es alles ja kein Problem. Schwierig wird es erst jetzt:
Ich habe es jetzt mit einem Zähler programmiert, sodass jedesmal erst wenn einmal 104 Impulse durchgezählt wurden Q1 ein und dann wieder ausgeschaltet wurde, das Programm erst wieder zählt.
Aber es soll z.B. immer gezählt werden. Auch wenn gerade ein Zählvorgang geschieht und dort x-beliebig mal Sensor 1+2 betätigt wird, soll jede einzele Zählfreigabe abgezählt werden und nach 104 Impulsen der Ausgang wieder geschlossen werden.
Also ich muss es irgendwie so programmieren, sodass immer egal wann und wie oft Sensor 1+2 betätigt wird, immer Q1 nach 100 Impulse einschaltet und nach 4 weiteren wieder aus geht.

Zum Probieren habe ich jetzt statt 100 Impulse 20 genommen und die 4 habe ich gelassen (Damit ich nicht jedesmal 100 Impulse abwarten muss). Als Impulsausgabe habe ich den in der CPU integrierten Taktmerker " M10.4 " genommen.

Kann mir jetzt einer weiterhelfen ??

Im Anhang das von mir erstellte Programm ohne vollständige Funktion.
 

Anhänge

  • Zählen_V01.jpg
    Zählen_V01.jpg
    51,1 KB · Aufrufe: 145
Zuletzt bearbeitet:
Ich verstehe deine Frage nicht ganz.
Du willst wenn deine Zählfreigabe eine positive Flanke vorhanden ist (bzw war) bis 100 Zählen. Danach soll 4 Impulse lang der Ausgang gesetzt sein.
Soweit OK.

So und jetzt willst du nach jeder positiven Flanke deiner Zählerfreigabe 100 Impulse Zählen und dann immer 4 Impulse lang den Ausgang setzen?
Also wenn jetzt zb alle 0-4 Impulse eine Flanke kommt dann soll dein Ausgang nie zurückgesetzt werden?
Für was braucht man so etwas? ;)

Auf jeden Fall brauchst du dann mal so viele Speicherstellen für Zählstände soweit du Zählen willst.
Bei 100 Impulsen kann es dann 100 verschiedene Zählerstände geben.

Wenn du das wirklich so brauchst, dann ist es besser du legst dir ein Array von 100 Bits an.
Dann lässt du eine Indexvariable bei jedem Impuls hochzählen. Bei 100 setzt du diese wieder zurück.
Bei jedem Impuls (positive Flanke) kannst du mit dieser Indexvariable das Bit aus dem Array adressieren und Abfragen. Wenn dieses true ist dann startest du einen Zähler der bis 4 zählt und den Ausgang setzt / rücksetzt, bei noch nicht abgelaufenen Zähler setzt du den Zählerstand einfach wieder auf 0.
Wenn irgendwann eine positive Flanke der Zählerfreigabe auftritt dann kannst du einfach das Bit in deinem Array setzen welches gerade durch deine Indexvariable angesprochen wird.

Klar? ;)
 
Ich hab' ihm ja das Programm schon für die Logo gemacht.

Von der Sache her benötigt er ein Schieberegister bzw. FIFO über 100 boolsche Stellen. Und am Ende einen Zähler für die 4 Ausgangsimpulse, der mit jedem positiven Ausgangsimpuls des Schieberegisters resettet wird.

Ich hab' ihm auch bereits eine mögliche (ungetestete) Lösung für die S7-1200 gezeigt (Die 100 Impulse zw. Erfüllen der Startbedingung und Setzen des Ausgangs sind sogar variabel bis momentan 500 Impulse). Allerdings in SCL, weil das m.M.n. geradezu prädestiniert für solche Aufgaben ist, obwohl da auch meine Kenntnisse beschränkt sind:
Diese kannst Du in FUP/KOP oder in SCL programmieren, wobei Letzteres für Deine Aufgabenstellung m.M.n. prädestiniert ist.
Ich bin darin allerdings mangels bisheriger Einsatzmöglichkeiten nicht gerade die größte Leuchte. Deshalb freu' ich mich über diese Trainingseinheit und würde Deine obige Aufgabenstellung folgendermaßen in einem eigenem FB umsetzen (ungetestet):
Code:
[FONT=Courier New]FUNCTION_BLOCK "Boolsches_Schieberegister"

VAR_INPUT
    Start1: BOOL;                               // Startbedingung 1
    Start2: BOOL;                               // Startbedingung 2
    Takt: BOOL;                                 // Impuls-Eingang
    Schritte: INT := 100;                       // Impulszahl bis zur Ausgabe
    Laenge: INT := 4;                           // Ausgabelänge des Impulses in Takten
END_VAR

VAR_OUTPUT
    Ausgabe: BOOL;                              // Impulsausgabe
END_VAR

VAR
    Takt_Old: BOOL;                             // Flankenmerker für Eingang Takt
    Start: BOOL;                                // Startbedingung erfüllt
    Schieberegister: ARRAY [0..500] OF BOOL;    // statische Variablen
    Ausgangszaehler: INT;                       // Zähler für Ausgabelänge
END_VAR

VAR_TEMP
    Schieben: BOOL;                             // positive Flanke Eingang Takt
    Index: INT;                                 // Array-Zeiger
END_VAR


    // Schrittbegrenzung
    IF Schritte > 500 THEN
        Schritte := 500;
    END_IF;
    
    // Startbedingung erfüllt?
    IF Start1 AND Start2 THEN
        Start := true;
    END_IF;
    
    // Flankenerkennung Eingang Takt
    Schieben := Takt AND NOT Takt_Old;
    Takt_Old := Takt;
    
    
    // Schieberegister
    IF Schieben THEN
        
        // Register weiterschieben
        FOR Index := Schritte TO 1 BY -1 DO
            Schieberegister [Index] := Schieberegister [Index - 1];  
        END_FOR;
        
        // Startbedingung ins Schieberegister übernehmen
        Schieberegister [0] := Start;
        Start := false;
        
        // Ausgang Schieberegister
        IF Schieberegister [Schritte] THEN
            Ausgangszaehler := Laenge;
        END_IF;
        
        // Ausgabe
        Ausgabe := Ausgangszaehler > 0;
        
        // Zähler Ausgabelänge
        IF Ausgabe THEN
            Ausgangszaehler := Ausgangszaehler - 1;
        END_IF;
        
    END_IF;
    
    
END_FUNCTION_BLOCK[/FONT]
...
Wenn man das Format des Arrays ändert, kann man auch andere Informationen als nur EIN/AUS durch das Register schicken.
Da er aber bis dato noch nichts mit SCL gemacht hat, möchte er lieber eine Lösung in FUP. Obwohl m.M.n. seine Kenntnisse da auch nicht viel mehr als in SCL sind. Es würde also nicht viel Unterschied machen, obe er sich mit SCL oder FUP beschäftigt. (Deswegen mach' ich das ja hier auch - um zu lernen!)

Da ich einfach keine Lust hatte, auch noch Energie in eine FUP-Lösung zu stecken, wenn's mit SCL so relativ einfach zu lösen geht, fragt er jetzt Euch.
:razz:
 
Zuviel Werbung?
-> Hier kostenlos registrieren
@godi:

Wenn du das wirklich so brauchst, dann ist es besser du legst dir ein Array von 100 Bits an.
Dann lässt du eine Indexvariable bei jedem Impuls hochzählen. Bei 100 setzt du diese wieder zurück.
Bei jedem Impuls (positive Flanke) kannst du mit dieser Indexvariable das Bit aus dem Array adressieren und Abfragen. Wenn dieses true ist dann startest du einen Zähler der bis 4 zählt und den Ausgang setzt / rücksetzt, bei noch nicht abgelaufenen Zähler setzt du den Zählerstand einfach wieder auf 0.
Wenn irgendwann eine positive Flanke der Zählerfreigabe auftritt dann kannst du einfach das Bit in deinem Array setzen welches gerade durch deine Indexvariable angesprochen wird.

Also kannst du mir vielleicht beschreiben was ein "Array" ist und wie ich den anlegen kann ?
Gibt es denn Beispiele zur Programmierung ?

Ich habe noch nie was von "ARRAY" gehört.


@hucki:

ich will selber SCL programmieren, aber wie gesagt wenn ich keine Basics habe und nicht mal weiß welche Befehle etc. es überhaupt gibt, dann lohnt es sich ja kaum ein Programmin SCL zu schreiben, welches ich nicht verstehe.
Außer irgendjemand stellt sich bereit und erklärt mir kurz die Basics von SCL, damit ich ich einlesen bzw. einlernen kann.


LG
EMZ
 
Also kannst du mir vielleicht beschreiben was ein "Array" ist und wie ich den anlegen kann ?
Das hier:
Code:
VAR
    Takt_Old: BOOL;                             // Flankenmerker für Eingang Takt
    Start: BOOL;                                // Startbedingung erfüllt
    [COLOR=#FF0000]Schieberegister: ARRAY [0..500] OF BOOL;[/COLOR]    //boolsches Schieberegister
    Ausgangszaehler: INT;                       // Zähler für Ausgabelänge
END_VAR
Das ist ein Feld von Variablen. In diesem Fall sind das die Variablen Schieberegister[0], Schieberegister[1], Schieberegister[2] bis Schieberegister[500]. Durch die Zahl in Klammern lassen sich die Variablen relativ einfach z.B. der Reihe nach ansprechen.
Dies benutze ich im obigen Code in einer Schleife zum Verschieben des Inhalts:
Code:
[FONT=Courier New]        // Register weiterschieben
        FOR Index := Schritte TO 1 BY -1 DO
            Schieberegister [Index] := Schieberegister [Index - 1];  
        END_FOR;
[/FONT]
Die FOR-Schleife fängt mit dem höchsten Wert Deiner Schritte an, also momentan mit 100. Die Variable Schieberegister[100] erhält den Wert von Schieberegister[100-1], also Schieberegister[99]. Mit END_FOR wird wieder zum FOR-Beginn zurück gesprungen, solange Index nicht 1 (der Wert hinter TO) ist und Index um -1 (BY) erhöht. Der Index ist jetzt also 99. Schieberegister[99] erhält jetzt den Wert von Schieberegister[99-1]. Und so weiter und so fort bis Index 1 ist.
Und das ist ein Schieberegister. :)
Und ein F(irst) I(n) F(irst) O(ut)-Speicher. :).


Die Variablendeklaration ist übrigens die gleiche, wie im FUP/KOP. Var_Input sind die Eingangsparameter, Var_Output die Ausgänge, Var die statischen und Var_Temp ... na?
Letztendlich wird der SCL-Code (zumindest bei der S7-300/400) genau wie FUP/KOP im Hintergrund in AWL umgewandelt.


@hucki:

ich will selber SCL programmieren, aber wie gesagt wenn ich keine Basics habe und nicht mal weiß welche Befehle etc. es überhaupt gibt, dann lohnt es sich ja kaum ein Programmin SCL zu schreiben, welches ich nicht verstehe.
Außer irgendjemand stellt sich bereit und erklärt mir kurz die Basics von SCL, damit ich ich einlesen bzw. einlernen kann.
Es ist auch ein bißchen Selbstinitiative gefragt. Sorry, aber da hab' ich noch nicht viel von mitbekommen.
Und den Guide und die Erste-Schritte-Anleitung hab' ich Dir ja verlinkt.
;)
 
Zuletzt bearbeitet:
Okey und wie kann ich das dann in FUP schreiben?

Also ich würde mal auf die Funktion "16Bit nach rechts schieben" tippen.

Ich probiere schon die ganze Zeit rum wie das am besten machbar ist, aber komme leider auf keine Lösung.

Ich will das ganze mal in FUP machen.

Anschließend in SCL.

IF Ausgabe THEN
Ausgangszaehler := Ausgangszaehler - 1

So etwas blick ich nicht ganz durch. Das sind immer diese Sachen die mich durcheinander bringen.
das IF und Then ist verständlich, aber warum steht da nicht z.B. statt If E124.0 then A124.0= 1 oder ähnliches.
Wozu gehört der Befehl "Ausgabe" ?? Wie kommst du drauf. Genauso wie Ausgangszaehler


Genauso wie das hier

IF Schritte > 500 THEN

warum schreibst du hier z.B. einfach Schritte. Kann man das irgendwo im Programm definieren oder sind das einfach #Befehle die man in SCL so schreibt, genauso wie If, then und welche es noch gibt.


LG EMZ
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ausgabe, Ausgangszaehler und Schritte sind Variablen, die ich in den entsprechenden Bereichen deklariert habe.
Die findest Du u.a. hier:
Code:
VAR_INPUT
    Start1: BOOL;                               // Startbedingung 1
    Start2: BOOL;                               // Startbedingung 2
    Takt: BOOL;                                 // Impuls-Eingang
    [COLOR="#FF0000"]Schritte[/COLOR]: INT := 100;                       // Impulszahl bis zur Ausgabe
    Laenge: INT := 4;                           // Ausgabelänge des Impulses in Takten
END_VAR

VAR_OUTPUT
    [COLOR="#FF0000"]Ausgabe[/COLOR]: BOOL;                              // Impulsausgabe
END_VAR

VAR
    Takt_Old: BOOL;                             // Flankenmerker für Eingang Takt
    Start: BOOL;                                // Startbedingung erfüllt
    Schieberegister: ARRAY [0..500] OF BOOL;    // statische Variablen
    [COLOR="#FF0000"]Ausgangszaehler[/COLOR]: INT;                       // Zähler für Ausgabelänge
END_VAR

VAR_TEMP
    Schieben: BOOL;                             // positive Flanke Eingang Takt
    Index: INT;                                 // Array-Zeiger
END_VAR
Die Variablen musst Du (wie in jeder anderen Programmiersprache auch) auch in FUP deklarieren.


IF prüft die dahinter angegebene Bedingung. Ist sie wahr, werden die Befehle hinter THEN abgearbeitet. Ist sie falsch, die hinter ELSE (sofern angegeben).
Code:
IF Schritte > 500 THEN
heißt also:
Code:
Wenn der Vergleich "Variable Schritte größer 500" wahr ist, dann ...

Code:
IF Ausgabe THEN
ist 'ne Abkürzung, weil Ausgabe nur den Zustand WAHR oder FALSCH haben kann und somit schon dem Ergebnis der Auswertung der Bedingung entspricht.
Man könnte auch länger schreiben:
Code:
IF Ausgabe = TRUE THEN
Wenn "Ausgabe = WAHR", dann ...

Code:
Ausgangszaehler := Ausgangszaehler - 1
Der neue Wert von Ausgangszaehler soll = der alte Wert - 1 sein.
 
Ok danke. Aber meine eigentliche Frage war, wie du dort Schritte einfügst. Wenn ich z.B. jetzt IF Schritte THEN eingeben, dann wird Schritte bei mir Rot als Fehler erkannt. Ich kann aber nicht nachvollziehen warum. Ich vermute du meinst das deklarieren.
Kannst du mir vielleicht sagen, wie ich meine Variablen deklarieren kann?


Wie kann ich denn jetzt so ein Array in FUP programmieren ?
Kann mir jemand weiterhelfen?


LG
EMZ
 
In dem Du den Wert, den Du Schritte beim Aufruf des FBs zuweist, änderst.
Standardmäßig steht dort 100. Bis zu 500 sind jetzt ohne Programmänderung möglich. Ansonsten müsste das Array vergrößert werden.
Deswegen wird am Anfang geprüft, das Schritte nicht größer ist.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Code:
VAR_INPUT
    Start1: BOOL;                               // Startbedingung 1
    Start2: BOOL;                               // Startbedingung 2
    Takt: BOOL;                                 // Impuls-Eingang
    [COLOR="#FF0000"]Schritte[/COLOR]: INT := 100;                       // Impulszahl bis zur Ausgabe
    Laenge: INT := 4;                           // Ausgabelänge des Impulses in Takten
END_VAR

VAR_OUTPUT
    [COLOR="#FF0000"]Ausgabe[/COLOR]: BOOL;                              // Impulsausgabe
END_VAR

VAR
    Takt_Old: BOOL;                             // Flankenmerker für Eingang Takt
    Start: BOOL;                                // Startbedingung erfüllt
    Schieberegister: ARRAY [0..500] OF BOOL;    // statische Variablen
    [COLOR="#FF0000"]Ausgangszaehler[/COLOR]: INT;                       // Zähler für Ausgabelänge
END_VAR

VAR_TEMP
    Schieben: BOOL;                             // positive Flanke Eingang Takt
    Index: INT;                                 // Array-Zeiger
END_VAR
Die Variablen musst Du (wie in jeder anderen Programmiersprache auch) auch in FUP deklarieren.
Scheinbar mußt Du diesen Teil im TIA per Hand erledigen.
Das sieht dann so aus, egal ob SCL oder FUP:
 
Der Vollständigkeit halber - der SCL-Code im TIA:


und ein möglicher Aufruf im OB1 mit Deinen beiden Einstellungen:


PS: Sorry, Du wolltest ja FUP. Ist zwar beim FB-Aufruf fast gleich zu KOP (das verwende ich im Normalfall, deswegen der vorige Screenshot), aber sicherheitshalber:
 
Zuletzt bearbeitet:
hi hucki,

so langsam bin ich echt am verweifeln.
Ich blick einfach garnicht mehr durch.
Ich finde deinen Datenbaustein "Schieneregister" nirgens. :confused::confused:
Und ich weiß auch garnicht wie ich einen Datenbaustein erstellen kann und auch abspielen.
Ich habe schon alle Funktionen durchgeschaut aber keinen gleichen Datenbaustein gefunden.
Ich bin noch glaub zu unerfahren für sowas.

Und das oben mit der Schnittstelle bekomme ich auch nicht hin. Ich schreibe die gleichen Begriffe rein die du auch reingeschrieben hast, aber da kann ich dann den Defaultwert nicht ändern und auch keine häckchen setzen bei Sichtbar... :(

Ich weiß nicht wie ich das hinkriege, ich hab bisher auch noch nie mit Datenbausteine gearbeitet.
Also ich will jetzt die Realisierung mit Siemens LOGO machen, aber trotzdem möchte ich gerne wissen, wie ich sowas in S7 programmieren kann.


Kannst du mir helfen bei dieser Aufgabe?
Am besten mit einzelnen Schritten wie ich das öffne etc.


LG EMZ
 
Zuviel Werbung?
-> Hier kostenlos registrieren
so langsam bin ich echt am verweifeln.
Ich blick einfach garnicht mehr durch.
Ich finde deinen Datenbaustein "Schieneregister" nirgens. :confused::confused:
Und ich weiß auch garnicht wie ich einen Datenbaustein erstellen kann und auch abspielen.
Ich habe schon alle Funktionen durchgeschaut aber keinen gleichen Datenbaustein gefunden.
Ich bin noch glaub zu unerfahren für sowas.

Und das oben mit der Schnittstelle bekomme ich auch nicht hin. Ich schreibe die gleichen Begriffe rein die du auch reingeschrieben hast, aber da kann ich dann den Defaultwert nicht ändern und auch keine häckchen setzen bei Sichtbar... :(

Ich weiß nicht wie ich das hinkriege, ich hab bisher auch noch nie mit Datenbausteine gearbeitet.
Das ist genau das, was ich hier:
Da er aber bis dato noch nichts mit SCL gemacht hat, möchte er lieber eine Lösung in FUP. Obwohl m.M.n. seine Kenntnisse da auch nicht viel mehr als in SCL sind. Es würde also nicht viel Unterschied machen, obe er sich mit SCL oder FUP beschäftigt.
gemeint habe. Auch Dein Wissen in FUP tendiert gegen Null. Es macht überhaupt keinen Unterschied, in welcher Sprache Dir das Programm serviert wird.
Das kann man aber alles lernen.
;)


Also ich will jetzt die Realisierung mit Siemens LOGO machen,
Immer diese Meinungsumschwünge.
:rolleyes: :ROFLMAO:




aber trotzdem möchte ich gerne wissen, wie ich sowas in S7 programmieren kann.

Kannst du mir helfen bei dieser Aufgabe?
Am besten mit einzelnen Schritten wie ich das öffne etc.
Neues Projekt anlegen und die zu verwendende CPU auswählen, hast Du doch schon hinbekommen, oder? Ich nehm' mal irgend eine S7-1500, weil die sich im Gegensatz zu einer 1200er simulieren läßt (in Natura mußt Du natürlich genau die auswählen, die Du auch hast), und gebe ihr den Namen "Test-CPU".

In der Projektansicht erst noch per Drag & Drop Ein- und Ausgänge aus dem Hardwarekatalog zur Gerätekonfiguration hinzufügen (bei der 1200er wahrscheinlich nicht notwendig):




Jetzt klickst Du erst mal die CPU mit Rechts im linken Projektbaum an und wählst die Eigenschaften aus. Dort aktivierst Du sowohl das System- als auch das Taktmerkerbyte. Speziell Letzteres brauchen wir (zumindest testweise) für den Takteingang des SCL-Bausteins. Schaden tun beide nicht, deswegen aktiviere ich sie eigentlich immer.




Danach gehts Du links auf Programmbausteine und "Neuen Baustein hinzufügen". FB auswählen, Sprache auf SCL stellen und dem FB einen Namen geben:




Im FB als erstes die Schnittstelle öffnen und die gewünschten Variablen-Namen und deren Datentyp! eintragen. Und Kommentar ist immer sinnvoll. Den Rest macht TIA erst mal allein. Nur bei den beiden Variablen Schritte und Laenge gibst Du den Defaultwert vor. (Wenn Du Dir die Variablen in das Editor-Feld unterhalb kopierst, brauchst Du beim Eintragen nicht ständig zwischen den TIA- und 'nem anderen Fenster hin- und herwechseln.)
Code:
//[FONT=Courier New]INPUT:
//    Start1           BOOL                    Startbedingung 1
//    Start2           BOOL                    Startbedingung 2
//    Takt             BOOL                    Impuls-Eingang
//    Schritte         INT := 100              Impulszahl bis zur Ausgabe
//    Laenge           INT := 4                Ausgabelänge des Impulses in Takten

//OUTPUT:
//    Ausgabe          BOOL                    Impulsausgabe

//STATIC:
//    Takt_Old         BOOL                    Flankenmerker für Eingang Takt
//    Start            BOOL                    Startbedingung erfüllt
//    Schieberegister  ARRAY [0..500] OF BOOL  statische Variablen
//    Ausgangszaehler  INT                     Zähler für Ausgabelänge

//TEMP:
//    Schieben         BOOL                    positive Flanke Eingang Takt
//    Index            INT                     Array-Zeiger
[/FONT]




Variablen wieder aus dem SCL-Feld löschen und dafür das eigentliche Programm hinein kopieren.
Code:
[FONT=Courier New]    // Schrittbegrenzung
    IF #Schritte > 500 THEN
        #Schritte := 500;
    END_IF;
    
    // Startbedingung erfüllt?
    IF #Start1 AND #Start2 THEN
        #Start := true;
    END_IF;
    
    // Flankenerkennung Eingang Takt
    #Schieben := #Takt AND NOT #Takt_Old;
    #Takt_Old := #Takt;
    
    
    // Schieberegister
    IF #Schieben THEN
        
        // Register weiterschieben
        FOR #Index := #Schritte TO 1 BY -1 DO
            #Schieberegister [#Index] := #Schieberegister [#Index - 1];  
        END_FOR;
        
        // Startbedingung ins Schieberegister übernehmen
        #Schieberegister [0] := #Start;
        #Start := false;
        
        // Ausgang Schieberegister
        IF #Schieberegister [#Schritte] THEN
            #Ausgangszaehler := #Laenge;
        END_IF;
        
        // Ausgabe
        #Ausgabe := #Ausgangszaehler > 0;
        
        // Zähler Ausgabelänge
        IF #Ausgabe THEN
            #Ausgangszaehler := #Ausgangszaehler - 1;
        END_IF;
        
    END_IF;[/FONT]




Jetzt den OB1 "Main" im Projektbaum doppelt anklicken, damit er im Editor-Feld angezeigt wird. Eventuell die Programmiersprache durch Rechtsklick auf den OB1 im Projektbaum auf FUP wechseln. Danach den FB1 "Schieberegister" aus dem Projektbaum per Drag & Drop ins Netzwerk 1 des OB1 im Editor ziehen. TIA fragt mit einem Pop-Up nach dem Instanz-DB. Einfach bestätigen und TIA legt den DB automatisch für Dich an.




Jetzt noch die Ein- und Ausgänge des FBs beschalten und die von TIA automatisch vergebenen Symbole "Tag_x" unter PLC-Variablen in aussagekräftigere Namen ändern.




Dann alles übersetzen:

 
Danke dir :)
Habe es soweit geschafft. Mein einziges Problem ist der Merker M0.5
Ich nehme an es ist ein Taktmerker. Ich will den in der Hardwarekonfi einschalten aber das Häckchen beim Taktmerker lässt sich nicht setzen. Aber ich weiß nicht warum?
weißt du voran es liegen kann?
TIA Portal ist gewöhnungsbedürftig.
So langsam check ich das mit SCL.


LG
EMZ
 
Mein einziges Problem ist der Merker M0.5
Ich nehme an es ist ein Taktmerker. Ich will den in der Hardwarekonfi einschalten aber das Häckchen beim Taktmerker lässt sich nicht setzen. Aber ich weiß nicht warum?
Das hier geht nicht?
Jetzt klickst Du erst mal die CPU mit Rechts im linken Projektbaum an und wählst die Eigenschaften aus. Dort aktivierst Du sowohl das System- als auch das Taktmerkerbyte. Speziell Letzteres brauchen wir (zumindest testweise) für den Takteingang des SCL-Bausteins. Schaden tun beide nicht, deswegen aktiviere ich sie eigentlich immer.

Kannst Du mal einen Screenshot machen? Was für 'ne CPU hast Du ausgewählt?
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ok ich schicke dir ein screenshot heute nachmittag. Also wenn ich auf meine cpu doppelt draufklick und dann unter eigenschaften auf taktmerker gehe dann kommt da ein anderes Feld wie bei dir.
Da steht auch.nicht System und taktmerker oder.so, sondern nur taktmerker. Ich hab eine 314 ner cpu. Schicke dir gegen 16 uhr ein screenshot.
 
Also wenn ich auf meine cpu doppelt draufklick und dann unter eigenschaften auf taktmerker gehe dann kommt da ein anderes Feld wie bei dir.
Da steht auch.nicht System und taktmerker oder.so, sondern nur taktmerker. Ich hab eine 314 ner cpu.
Die 300er CPUen haben noch kein Systemmerkerbyte. Deshalb wird davon auch nichts angezeigt.

Und auch die Symbolnamen für die einzelnen Takte muss man per Hand in der Variablentabelle erstellen. Das wird nicht wie bei der 1200/1500 von TIA übernommen.
 
Ok habe jetzt eine 1200 CPU genommen.

Also gestern gab es da keine Probleme.
Heute nachdem ich die neue CPU genommen habe, ist bei mir Start 1 und Start 2 und Ausgangszähler rot.
TIA meint ich soll diese Operanten definieren. Habe z.B. EIngang I124.0 eingegebn aber der nimmt den nicht.
Was mache ich schon wieder falsch. Mit der Step 7 V5.5 Version bin ich viel besser klargekommen:)

Anhang anzeigen 21713
Anhang anzeigen 21715
Anhang anzeigen 21714



Danke für jegliche Hilfe

LG
EMZ
 
Zurück
Oben