TIA Datentypen

[hucki]

Zuviel Werbung?
-> Hier kostenlos registrieren

Um #schieben TRUE zu setzen reicht doch ne einfache IF funktion mit boolschen variablen oder ?

Um #schieben auf TRUE zu setzen, reicht auch 'ne einfache Zuweisung:

#schieben:= TRUE;

Bei Deinem obigen Programmauszug hast Du aber gar nichts in der Art dabei.
Daher wird Dein Code innerhalb der äußersten IF-Schachtel (vermutlich) einfach nicht ausgeführt und kann demzufolge gar nicht funktionieren.

Welchen Grund hattest Du denn für das IF #schieben?

 

[kiar]

@RAik
Ich bin es mittlerweile gewohnt dass es bei jedem Thread einen gibt der seinen noch so sinnlosen d..... Senf dazu geben muss, aber bitte les doch erstmal alle beiträge bevor du überhaupt was schreibst.
Ich machs dir leichter dann brauchst deine gehirngrütze nicht so anzustrengen:

Um #schieben TRUE zu setzen reicht doch ne einfache IF funktion mit boolschen variablen oder ?

LG
EMZ

 

[EMZ]

Zuviel Werbung?
-> Hier kostenlos registrieren

IF #schieben THEN


FOR #index := 10 TO 1 BY -1 DO
#Zaehler [#index]:= #Zaehler [#index - 1];
END_FOR;

IF #Zaehler[#Position_1] THEN
#ausgangszaehler:= #Pausenzeit;

#Start := #ausgangszaehler > 0;

IF #Start THEN #ausgangszaehler := #ausgangszaehler -1 ;
END_IF;

END_IF;



END_IF;
Input
Takt Bool 0.2 false True
Pausenzeit# Int 2.0 4 True
Position_1# Int 4.0 10 True


Output
Freigabe_Pos2# Bool 6.0 false True
Start #Bool 6.1 false True

Static
ausgangszaehler# Int 10.0 0 True
Zaehler #Array [0..10] of Bool 12.0 True

Temp
schieben# Bool 0.0 False
index# Int 2.0 False

Habe jetzt zwei Fragen.
Warum steht schieben und index bei temp?
Warum steht ausgangszaehler bei static ?
Und sie pausenzeit und und position_1 bei input

Die nächste frage is beim der for schleife: #Zaehler [#index]:= #Zaehler [#index - 1];
Warum weist man das so zu ?
Soll es bedeuten, wenn zaehler index gesetzt wird soll, zaehler index -1 gezählt werden ?
[] nimmt man die klammern um etwas hervorzuheben?

LG
EMZ

 

[Larry Laffer]

Hallo,

Warum steht schieben und index bei temp?

Warum "schieben" da steht weiß ich auch nicht - "index" hingegen ist eine Variable, die temporär nur innerhalb der Schleife benötigt wird. Man muss sie sich nicht merken und sie muss nach Beendigung des Bausteins auch nicht erhalten bleiben ...

Warum steht ausgangszaehler bei static ?

weil er nach Beendigung des Bausteins erhalten bleiben soll. Statische Daten werden in dem Instanz-DB desd Bausteins abgelegt und bleiben so von Aufruf zu Aufruf erhalten (außer man überschreibt sie wieder)

Und sie pausenzeit und und position_1 bei input

... weil es Eingangsvariablen in den Baustein sind ...!?

Die nächste frage is beim der for schleife: #Zaehler [#index]:= #Zaehler [#index - 1];
Warum weist man das so zu ?

Wenn du den Inhalt eines Arrays nach hinten aufschieben willst dann mußt du immer von hinten nach vorne arbeiten. Also erst dem Element 10 das Element 9 zuweisen, dann dem Element 9 das Element 8 usw.
Würdest du es anders herum machen (Element 1 nach 2, dann Element 2 nach 3 usw.) dann würdest du in jedem Arrayelement den gleichen Inhalt drin stehen haben - nämlich den. den du auf Element 1 draufschreiben willst ...

Gruß
Larry

 

[hucki]

Warum "schieben" da steht weiß ich auch nicht

Eigentlich versucht er einen Baustein, den ich ihm vor langer Zeit auch mal haarklein erklärt habe, zu reproduzieren.

Das Original sah seinerzeit so aus:

[FONT=Courier New]FUNCTION_BLOCK "Boolsches_Schieberegister"

VAR_INPUT
    Start1: BOOL;                               // Startbedingung 1
    Start2: BOOL;                               // Startbedingung 2
    Takt: BOOL;                                 // Impuls-Eingang
    Schritte: INT;                              // Impulszahl bis zur Ausgabe
    Laenge: INT;                                // 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]

Und plötzlich wird auch wieder klar, woher #schieben kommt - es ist das Ergebnis einer Flankenauswertung, die EMZ hier wohl fehlt.

 

[hucki]

Zuviel Werbung?
-> Hier kostenlos registrieren

Die nächste frage is beim der for schleife: #Zaehler [#index]:= #Zaehler [#index - 1];
Warum weist man das so zu ?
Soll es bedeuten, wenn zaehler index gesetzt wird soll, zaehler index -1 gezählt werden ?
[] nimmt man die klammern um etwas hervorzuheben?

Zähler ist ein Array. Das kannst Du Dir in diesem Fall vorstellen, wie eine Schubladenkommode. Die Zahl in den eckigen Klammern gibt die gewünschte Schublade von unten nach oben an.
Zähler[10]:=Zähler[10-1] bedeutet demzufolge, der Inhalt von Schublade 10 soll dem von Schublade 9 entsprechen. Dann wird der Index um eins reduziert. Damit kommt in Schublade 9 jetzt das, was in Schublade 8 ist. ....

So entsteht Dein Schieberegister, das Du gewünscht hast und bei dem die Werte von 1 (unten) nach x (oben) durchgeschoben werden.
Ein Array dafür zu verwenden, bietet dabei gegenüber einzelnen Variablen den Vorteil, das aktuelle Feld über den Index berechnen zu können.

 

[hucki]

Eigentlich versucht er einen Baustein, den ich ihm vor langer Zeit auch mal haarklein erklärt habe, zu reproduzieren.

@EMZ,

es wäre also sinnvoll, Dir nochmal Deine eigenen alten Threads, insbesondere den im Zitat verlinkten, anzusehen und durchzuarbeiten.
Dort wurde Dir u.a. auch schon erklärt, was es mit den Zahlen in den eckigen Klammern auf sich hat.

 

[EMZ]

Danke euch beiden sehr sehr hilfreich

Also muss ich den Array vom endwert zum startwert zuweisen, weil wenn ich das andersrum machen würde, die Arrayfelder immer die gleichr Zahl hätte oder ?

For index:= 10 to 1 by -1 do zaehler [index] = zaehler [index-1]
Wenn ich von 1 anfangen würde also :

For index:= 1 to 10 by +1 do zaehler [index] = zaehler [index-1]

Würde ja dir zahl von schublade 1 in schublade 2 übernehmen und das wäre 1
Und das von schublade 2 also auch 1 in schhublade 3

"+1" nach by wird ja sowieso als deklarationsfehler erkannt oder ?

Warum weist man aber von oben nach unten zu aber die sps rechnet von unten nach oben ?

LG
EMZ

 

[EMZ]

Zuviel Werbung?
-> Hier kostenlos registrieren

@hucki
Ja ich schaue mir auch meine alten threads an
Danke

Hast du vllt. noch iwelche Übungsaufgaben für mich ?

Lg
EMZ

 

[hucki]

Hast du vllt. noch iwelche Übungsaufgaben für mich ?

Nein, da kann ich leider nicht mit dienen.

 

[EMZ]

ok trotzdem danke erstmal,
hat mir schon ein ganzes stück weitergerbracht.
kann mir eine noch meine vorherig unbeantwortete frage beantworten
wäre sehr dankbar.

Einen guten Rutsch ins neue Jahr
:s11:

Danke euch beiden sehr sehr hilfreich :smile:

Also muss ich den Array vom endwert zum startwert zuweisen, weil wenn ich das andersrum machen würde, die Arrayfelder immer die gleichr Zahl hätte oder ?

For index:= 10 to 1 by -1 do zaehler [index] = zaehler [index-1]
Wenn ich von 1 anfangen würde also :

For index:= 1 to 10 by +1 do zaehler [index] = zaehler [index-1]

Würde ja dir zahl von schublade 1 in schublade 2 übernehmen und das wäre 1
Und das von schublade 2 also auch 1 in schhublade 3

"+1" nach by wird ja sowieso als deklarationsfehler erkannt oder ?

Warum weist man aber von oben nach unten zu aber die sps rechnet von unten nach oben ?

 

[hucki]

Zuviel Werbung?
-> Hier kostenlos registrieren

Warum weist man aber von oben nach unten zu aber die sps rechnet von unten nach oben ?

Welche Richtung Du wählst, liegt allein bei Dir und Deiner Aufgabe und was Du dafür am Geeignetsten hältst.


Hier habe ich halt mal festgelegt, dass neue Werte an Stelle 1 eingefügt werden sollen und alle anderen dann immer um 1 weiter rücken.
Und dieses Weiterrücken muss eben von der letzten Stelle aus begonnen werden. Von 1 begonnen, hast Du ja selbst festgestellt, würde der neue Wert sofort durch das ganze Register kopiert werden, was jedoch nicht gewünscht ist.


Man könnte auch den neuen Wert an letzter Stelle einfügen und müsste demzufolge dann von 2 beginnen, den Wert nach 1 zu kopieren, und sich dann aufwärts durch das Register arbeiten.


PS: Ich hab' die Schieberichtung 1 aufwärts gewählt, weil man dann anhand der Registernummer/Index einfach feststellen kann, um wieviel Plätze ein Wert bereits geschoben wurde.

 

[EMZ]

Danke dir Hucki


Bin schon gut voran gekommen

Ne frage: Der index ist bei nem Array als höchster/niedrigester Wert des Arrays definiert oder sagt man eher als Zählwert des Arrays??
Welches is richtig formuliert ?
Der kann ja im gegensatz zu kop,fup,awl frei variieren oder?

LG

EMZ

 

[hucki]

Index ist einfach ein anderes Wort für Zeiger.

Der Zeiger zeigt auf ein Element des Arrays, um zu bestimmen, in/aus welchen Element gelesen/geschrieben werden soll.
Er kann logischerweise nur auf ein Element zeigen, das bei der Deklaration auch angelegt wurde (die Zahlen in der Klammer), also alle vom Element mit der niedrigsten bis zum Element mit der höchsten angelegten Nummer.

Du kannst Dir das wie die Hausnummern in Deiner Straße vorstellen. Gibst Du eine Hausnummer an, die es in der Straße nicht gibt, hat Dein Navi ein Problem.

 

[EMZ]

Zuviel Werbung?
-> Hier kostenlos registrieren

Also "" zeigt"" der Index sozusagen den aktuellen Wert des Arrays an.
Das mit dem zeigen ist so indirekt gemeint
Right?

 

[hucki]

Also "" zeigt"" der Index sozusagen den aktuellen Wert des Arrays an.

Nein, der Index zeigt nicht den Wert an, sondern das aktuelle Element des Arrays. Dessen Wert kann dann gelesen oder verändert (geschrieben) werden.

Wie ein Schrank mit z.B. 10 Schubladen (Schublade : Array [1..10] OF ...). Wenn ich Dich dann frage "Was ist in Schublade[3]", dann gibt die 3 ja nicht den Inhalt (Wert) der Schublade oder gar aller Schubladen an, sondern sie gibt Dir nur vor, in welche Schublade der 10 vorhandenen Du zu schauen hast, um mir eine Antwort geben zu können.
Deshalb "Zeiger" - er zeigt die Schublade an, um die es geht, aber nicht deren Wert.

 

[EMZ]

Ah okey verstehe jetzt...
Also bedeutet es, dass dann die For Schleife immer mit dem "neuen" Index beginnt, dessen wert dann geschrieben wird. Und den Wert des Arrays lesen wir dann mit :
#Zaehler [#index]:=

Oder ?

 

[hucki]

Zuviel Werbung?
-> Hier kostenlos registrieren

Und den Wert des Arrays lesen wir dann mit :
#Zaehler [#index]:=

Nein, weder noch.

Der Wert des ARRAYs wäre bei meinem vorigen Beispiel der Inhalt aller Schubladen.
#Zaehler [#index] wäre der Wert einer bestimmten Schublade. Die stellt aber nicht das ARRAY sondern nur ein Element des selbigen dar. Wichtiger Unterschied! Man kann nämlich z.B. auch das gesamte ARRAY in einem Rutsch (ohne Angabe eines Zeigers) auf ein anderes übertragen.


Und mit:

#Zaehler [#index]:=

wird das Element des ARRAYs nicht gelesen, sondern beschrieben (Zuweisung).

 

[EMZ]

also ich komm langsam durcheinander deshalb möchte ich jetzt mal alles zusammenfassen wie weit ich es verstanden habe.

Also der Index ruft nur das Element des Arrarys auf, z.B. Schublade [3]
Der Wert des Arrays wäre ja dann z.B. in unserem Fall 10
#Zaehler [#index] stellt wie du sagst ein selbiges Element dar, also wenn wir dann den Wert von Schublade [3] haben
z.B. Wert 3 stellt er es mit #Zaehler [#index -1] nochmals dar und rechnet dann den Wert -1.
Mit End_For springen wir ja wieder zum Anfang der Schleife, das bedeutet dann, dass wir jetzt nicht mehr in Schublade
[3], sondern in Schublade [2] reinschauen, da der Index um eins reduziert wurde.
Dann wird wieder in die Schublade 2 reingeschaut der wert von schublade 2 ausgelesen bzw. bis Index = 0 bzw. Endwert
von der forschleife.

LG
EMZ

Wie viele Fehler sind in meiner Denkweise drinne,
vllt wäre es einfacher zu verstehen wenn es iwie zu veranschaulichen wäre.
zumindest das array

 

[EMZ]

Ich habe es jetzt so aufgebaut aber es funktioniert nicht ??

Kann mir jemand helfen??


LG
EMZ

Start1 #Bool 0.0 false True
Start2 #Bool 0.1 false True
Position_1 #Int 2.0 10 True
Laenge_1 #Int 4.0 2 True
stopp #Int 6.0 0 True
takt #Bool 8.0 false True
Output
Ausgang_1 #Bool 10.0 false True
InOut

Static
Ausgabe_1 #Array [0..10] of Bool 12.0 True
takt_1 #Bool 14.0 false True
ausgangszaehler #Int 16.0 0 False
start #Bool 18.0 false True
Temp
Index # Int 0.0 False
schieben #Bool 2.0 False

#schieben := #takt AND NOT #takt_1;
#takt_1 := #takt;
IF #Start1 AND #Start2 THEN
#start := true;
END_IF;


#schieben := true;

IF #schieben THEN

FOR #Index := 10 TO 1 BY -1 DO #Ausgabe_1 [#Index]
:= #Ausgabe_1 [#Index];
END_FOR;

#Ausgabe_1[0] := #start;
#start := false;


IF #Ausgabe_1[#Position_1]
THEN #ausgangszaehler := #Laenge_1;
END_IF;

#Ausgang_1 := #ausgangszaehler > 0;


IF #Ausgang_1 THEN #ausgangszaehler := #ausgangszaehler -1;
END_IF ;
END_IF;