TIA Datentypen

hucki · 11 Januar 2015

Fangen wir erst mal mit dem Einfachen an.

Dein Programm gehört nicht in die Zitat-Tags [QUOTE]...[/QUOTE], sondern in die Code-Tags [CODE]...[/CODE]. Dafür gibt es auch einen Button mit dem Zeichen # ganz rechts in der 2. Icon-Reihe.

Wenn Du endlich mal diese einfache Aufgabe gebacken bekommst, nachdem ich das (wie alles andere m.M.n. eigentlich auch) ja nun ausreichend oft erklärt habe, widme ich mich auch dem nächst schwierigeren Problem.

PS: Solch' einfache Syntaxaufgaben sind übrigens die Grundlage jeglicher Programmierung. :razz:

EMZ · 11 Januar 2015

So sorry, hab den Button vergessen

und warum krieg ich das nicht zum laufen ?

Code:

Input    
Start1    Bool
Start2    Bool
Position_1    Int   10
Laenge_1    Int    4
stopp    Int
takt    Bool
Output    
Ausgang_1    Bool
InOut    
    
Static    
Ausgabe_1    Array [0..10] of Bool
takt_1    Bool
ausgangszaehler    Int
start    Bool
Temp    
Index    Int
schieben    Bool



    #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;

hucki · 11 Januar 2015

Das nächste sind die optischen Probleme, die Du Dir selber bereitest.
Z.B.:

EMZ schrieb:
Code:

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

Wie willst Du da Deinen Code vernünftig analysieren?

Code:

...
FOR #Index := 10 TO 1 BY -1 DO 
     [COLOR="#FF8C00"]#Ausgabe_1 [#Index] := #Ausgabe_1 [#Index][/COLOR];
END_FOR;
...

Sind so die einzelnen Code-Aufgaben nicht besser lesbar?

Was willst Du mit der farblich gekennzeichneten Zeile denn erreichen? Wieviel Sinn macht sie so, wie sie ist?
(Schau' Dir die Variable vor und hinter der Zuweisung an. Was stellst Du da fest?)

EMZ · 11 Januar 2015

hi hucki,

habe den Fehler gefunden

Habe beim Schieberegister irgendwie bei der Zuweisung "-1" in den [#Index ] vergessen. Vermutlich vertippt oder vergessen.
und Habe auch die 10 durch meine Deklaration " Position_1" ersetzt.

Jetzt ne Frage zu dem Index noch:

Passt das was ich so bisher verstanden habe?
Ich habe leider nicht viel Zeit mich damit zu befassen, da ich beruflich auch leider nicht tagtäglich mit S7 sondern eher mit LOGO zutun habe,
kann ich mich mit der Materie auch ´dementsprechend begrenzt beschäftigen.
Aber ich denke wenn du mir meine Antwort mit ja oder richtig bestätigst dann denke ich dass ich ein Schritt vorangekommen bin.

Code:
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.

Code:

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

Diese Zeile bedeutet doch, dass wenn Ausgabe_1 = 0 dann Start ...Warum schreibt man dann Start := false ??

Code:

#schieben := #takt AND NOT #takt_1; #takt_1 := #takt;

Warum weißt man takt_1 zu takt zu?

LG EMZ

und nen fetten Dankeschön für deine bisher geleistete HILFE @hucki :s1:

hucki · 11 Januar 2015

EMZ schrieb:
Diese Zeile bedeutet doch, dass wenn Ausgabe_1 = 0 dann Start ...Warum schreibt man dann Start := false ??

Start wird hier ganz am Anfang von einer bedingten Zuweisung auf TRUE gesetzt. Um sicher zu gehen, das der Ausgangszustand immer FALSE ist, wird Start am Ende wieder auf FALSE zurück gesetzt. Ideal ist dieses Vorgehen aber auch nicht gerade. Mit meinem heutigen Wissen würde ich eine eindeutige statt einer bedingten Zuweisung bevorzugen.
Also statt:

Code:

IF #Start1 AND #Start2 THEN
        #start := true;
END_IF;

...

#start := false;

besser nur (ohne das ganze IF-THEN-Gedöns:

Code:

#start := #Start1 AND #Start2

EMZ schrieb:
Code:

#schieben := #takt AND NOT #takt_1; #takt_1 := #takt;

Warum weißt man takt_1 zu takt zu?

takt wird als INPUT des Bausteins in jedem Zyklus neu beschrieben. Indem man diesen Zustand auf takt1 überträgt, speichert man sich diesen Zustand für den nächsten Zyklus. (Deswegen muss takt1 auch unbedingt ein statischer und kein temporärer Speicher sein). Wenn man den Zustand des aktuellen mit dem des letzten Zyklus vergleicht, kann man feststellen, ob:
- dieser gleich geblieben ist (#takt = #takt_1),
- er sich von 0 auf 1 (#takt AND NOT #takt_1) oder
- er sich von 1 auf 0 (NOT #takt AND #takt_1) geändert hat.
Die letzten beiden nennt man auch Flankenerkennung.

Was für mich aber hier die viel interessantere Frage ist - Warum machst Du eine Flankenerkennung, dessen Ergebnis in #schieben landet, wenn Du dann anschließend diese Variable #schieben generell auf TRUE setzt, ohne sie zwischendurch zu benutzen:

EMZ schrieb:

Code:

[COLOR="#FFA500"]#schieben := #takt AND NOT #takt_1[/COLOR];
#takt_1 := #takt;

IF #Start1 AND #Start2 THEN
        #start := true;
END_IF;

[COLOR="#FFA500"]#schieben := true[/COLOR];

EMZ · 11 Januar 2015

Also wäre diese Zeile eine bessere Lösung

Code:

#start := #Start1 AND #Start2

?

dieser gleich geblieben ist (#takt = #takt_1)

also ob sich der Zustand von der Startbedienung geändert hat oder nicht ??

und wie richtig oder falsch ist meine derzeitige Erklärung der Forschleife ??

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.

sorry, ich habe "schieben := true entfernt und durch

Code:

schieben := takt and not takt_1

ersetzt.

Was für mich aber hier die viel interessantere Frage ist - Warum machst
Du eine Flankenerkennung, dessen Ergebnis in #schieben landet, wenn Du
dann anschließend diese Variable #schieben generell auf TRUE setzt, ohne
sie zwischendurch zu benutzen:

hucki · 11 Januar 2015

Ich scheue mich, von "Wert des Arrays" zu sprechen, weil das in meinen Augen etwas anderes impliziert.

Das Array hat eine Anzahl von Elementen, die sogenannte Feldgröße. Der Wert des Arrays wäre für mich der gemeinsame Inhalt aller dieser Elemente.

Zu der FOR-Schleife schreibe ich noch mal was, wenn ich wieder am Laptop bin.

hucki · 11 Januar 2015

hucki schrieb:
Zu der FOR-Schleife schreibe ich noch mal was, wenn ich wieder am Laptop bin.

Eigentlich soll ja die Zeile innerhalb der FOR-Schleife nichts weiter bewirken, als den Inhalt der einzelnen Elemente jeweils um ein Element zu verschieben. Dazu könnte man jeden Befehl einzeln schreiben:

Code:

#Ausgabe_1 [10] := #Ausgabe_1 [9];
#Ausgabe_1 [9]  := #Ausgabe_1 [8];
#Ausgabe_1 [8]  := #Ausgabe_1 [7];
#Ausgabe_1 [7]  := #Ausgabe_1 [6];
#Ausgabe_1 [6]  := #Ausgabe_1 [5];
#Ausgabe_1 [5]  := #Ausgabe_1 [4];
#Ausgabe_1 [4]  := #Ausgabe_1 [3];
#Ausgabe_1 [3]  := #Ausgabe_1 [2];
#Ausgabe_1 [2]  := #Ausgabe_1 [1];
#Ausgabe_1 [1]  := #Ausgabe_1 [0];

#Ausgabe_1 [0]  := #start;

Wie Du siehst, ist das bei nur 11 Elementen schon eine ganz schöne Schreibarbeit (mal davon abgesehen, dass es auch noch unflexibel ist). Ursprünglich hattest Du 100 Schritte!
Also erstellt man sich einfach eine zusätzliche Variable, die man von der FOR-Schleife einen gewünschten Wertebereich durchlaufen läßt, um so die eigentliche Aufgabezeile nur einmal schreiben zu müssen. Und genau da liegt der Vorteil des Arrays. Die Variablen unterscheiden sich nur durch den Index, der eine separate Variable darstellt. Hättest Du 11 einzelne Variablen statt des Arrays, müsstest Du jede Zeile einzeln schreiben, das sie alle unterschiedliche Namen haben.

EMZ · 11 Januar 2015

Ich scheue mich, von "Wert des Arrays" zu sprechen, weil das in meinen Augen etwas anderes impliziert

Was dann?

Also mit dem Array erstelle ich einen Wertebereich z.B. 0-10
Und mit den Index kann ich dann die einzelnen Arrayfelder abfragen bzw.
anzeigen.
Also brauche ich zu jedem Array einen Index, sonst muesste ich das alles in eine
Einzelne Zeile Schreiben.
Also is index nichts anderes als ein Zeiger mit dem ich die Werte bzw Zahlen Anzeigen lassen kann?
Danke dieser Code ist sehr hilfreich gewesen, damit kann ich es mir jetzt besser Vorstellen.

Lg
EMZ

EMZ · 12 Januar 2015

Ich glaube jetzt habe ich es besser verstanden.

Also mal nur bisschen mehr verständlicher hingestellt.

So wären ja die einzelnen Schritte des Schieberegisters:
Der erste Code soll den Ausgangscode darstellen

Code:

For Index := 10 TO 1 BY -1 DO 
Schieberegister [Index] := Schieberegister [Index -1]
END_FOR

For Index [10]:= Endwert to startwert by Laufvar. do 
Array [10] := Array [10 -1]
END_FOR

For Index [9] := Endwert to startwert by Laufvar. do 
Array [9] := Array [9 -1]
END_FOR

For Index [8] := Endwert to startwert by Laufvar. do 
Array [8] := Array [8 -1]
END_FOR

For Index [7] := Endwert to startwert by Laufvar. do 
Array [7] := Array [7 -1]
END_FOR

usw...

Also den Index brauche ich ja sogesehen nur, um der Forschleife sagen zu können, dass wenn wir z.B. von 10 -1 runter zu rechnen, dass er dann beim nächsten Schleifendurchlauf nicht
mit 10 sondern mit [10-1] also mit 9 die Schleife durchlaufen soll.... usw.
??
Mir fehlen die Fachbegriffe um es ordentlich zu erklären,
aber wenn es so wie ich es mit dem Code und dem Text unter dem Code richtig ist, dann habe ich es glaub von a-z gecheckt.

Dann würde ich gerne diesen Thread vorerstmal stilllegen und mich zum nächsten Schritt bewegen, aber diesmal mit Buch und Stift
Nachdem ich die Schleifen ohne Forumhilfe geschafft habe, möchte ich mal Analogwerte bearbeiten, z.B. eine Spannungs oder Stromüberwachung mit Hyterese...
Denke aber, dass dies einbisschen einfacher sein wird, sobald ich weiß wo ich die Variablen zuordne temp.static .... und welche Datentypen ich nehme,
denke aber dass es bisdahin noch bisschen dauert.

LG
EMZ

Ich bedanke mich rechtherzlich für deine Hilfe,
hast es echt drauf, für dass dass du im alltag nicht programmierst.

hucki · 12 Januar 2015

EMZ schrieb:
Was dann?

Also mit dem Array erstelle ich einen Wertebereich z.B. 0-10

Wenn Du Dir eine Brieftasche mit 10 Fächern zulegst, ist dann der Wert Deiner Brieftasche 10?

Mit Wert verbinde ich persönlich den gesamten Inhalt dieser 10 Fächer und nicht die Anzahl der Fächer.

EMZ · 12 Januar 2015

Ok, also is Array der gesamte Wert der Felder,
Index dann der Inhalt der Felder.

Bekomme ich auch eine Antwort zu meinen anderen Post ?

hucki · 12 Januar 2015

EMZ schrieb:
Ok, also is Array der gesamte Wert der Felder,
Index dann der Inhalt der Felder.

Nein, immer noch nicht.

Ein Array ist ein Feld mit einer bestimmten Anzahl gleichartiger Elemente.
Der Index ist die Nummer (der Name) mit dem die einzelnen Elemente benannt und unterschieden werden.
Der Wert eines Elements ist dessen Inhalt. Der Wert des Arrays ist der Inhalt aller Elemente zusammen.

Eine Schulklasse ist ein eindimensionales Feld mit einer bestimmten Anzahl an Schülern.
Mit dem Namen (Schüler[x]) kann man die einzelnen Schüler benennen und auseinanderhalten.
Der Wert eines Schülers ist sein Wissen. Der Wert der Klasse ist das Wissen aller Schüler zusammen.

Wenn die Schüler einzeln auf dem Schulhof stehen, musst Du sie alle mit ihrem jeweils unterschiedlichen Namen ansprechen.
Als Liste kannst Du aber die Klasse mit Schüler[1], Schüler[2], Schüler[3] ... besser automatisiert durch recherchieren als mit Einzelnamen.

Eine Schule ist ein eindimensionales Feld an Klassen. Die Nummer (Index) gibt die jeweilige Klasse an. Der Wert einer Klasse ist die Anzahl ihrer Schüler.
Außerdem ist die Schule ein zweidimensionales Feld an Schülern. Die erste Dimension (1. Index) gibt die Klasse an, die 2. (2. Index) den jeweiligen Schüler dieser Klasse.

Wenn sie wieder einzeln auf dem Schulhof stehen, musst Du sie wieder alle mit ihrem jeweils unterschiedlichen Namen ansprechen.
Als Liste kannst Du aber die Klassen mit ihren Schülern Schüler[Klasse 1, Schüler 1], Schüler[1, 2], Schüler[1, 3] ... Schüler[2, 1], Schüler[2, 2], Schüler[2, 3] besser automatisiert durch recherchieren als mit Einzelnamen.

Und wieder ist das Wissen der Schule nicht die Anzahl der Schüler sondern die Summe des Wissens jedes einzelnen Schülers.

Das Verschieben der Klassen findet einmal im Jahr statt, in dem die Schüler von Klasse 10 entlassen, in die Klasse[10] die von Klasse[9] kommen, in die Klasse[9] die von Klasse[8] kommen, ....

PS: Die FOR-Schleife macht jetzt nichts weiter , als zu sagen:

Code:

Die Klassen von 10 bis 1 und zwar jede einzelne
     gehen in ihren Klassenraum;
nächste Klasse;

anstatt

Code:

"Klasse[10] geht in ihren Klassenraum;
 Klasse[9] geht ..."

(PS-Ende)

EMZ schrieb:
Bekomme ich auch eine Antwort zu meinen anderen Post ?

Muss ich erst noch lesen. Hast Du ja schließlich nachgereicht.

Wirklich richtig ist das auch nicht, aber für heute bin ich erst mal platt mit Vereinfachungen, abgesehen von meinem PS hier drüber.

EMZ · 12 Januar 2015

Danke Hucki TOP Erklärung
Danke dir dass du dir dafür soviel Zeit nimmst und so eine Geduld hast ...Nice

Genau das habe ich damit gemein, also mit dem nachgereichten Post
Array sind dann eine bestimmte Anzahl von der selben Elementen (z.B. 10 Container)
Index gibt dann z.B. an Container [1]..... Container [10]
Der Wert des Arrays was ja in dem Fall nicht relevant ist, wäre dann was in den Container von 1-10 drinne ist.
Z.b. haben wir in jedem Container 2 Autos drinne, also wäre dann der Wert des Arrays 20 Autos.

Noch ne Frage fällt mir grade ein:

In welcher Form bzw. als welchen Datentyp wird denn der Wert des Arrays deklariert?
Als INT??

Code:
"Klasse[10] geht in ihren Klassenraum;
Klasse[9] geht ..."

mit meinen vorherigen Post habe ich genau das gemeint,
Durch die FOR-Schleife muss man dann die einzelnen Befehlszeilen bzw. Forschleifen nicht einzelnd
eingeben, sondern kann dann Anhand des variablen Indexes eine das ganze in eine Zeile schreiben.
In meinen vorherigen Post habe ich das einbisschen aufgeschachtelt, damit meine denkweise besser zu vermitteln ist,
da ich es dir wahrscheinlich nicht mit fachbegriffen erklären kann wie iche s verstehen, da meine fachbegriffe wahrscheinlich nicht ausreichend sind

Aber ich habe das prinzip verstanden.

hucki · 13 Januar 2015

EMZ schrieb:
Danke Hucki TOP Erklärung

Einfach unten auf den Danke-Button drücken reicht vollkommen.

EMZ schrieb:
Array sind dann eine bestimmte Anzahl von der selben Elementen (z.B. 10 Container)
Index gibt dann z.B. an Container [1]..... Container [10]
Der Wert des Arrays was ja in dem Fall nicht relevant ist, wäre dann was in den Container von 1-10 drinne ist.
Z.b. haben wir in jedem Container 2 Autos drinne, also wäre dann der Wert des Arrays 20 Autos.

Jetzt hast Du's.

EMZ schrieb:
In welcher Form bzw. als welchen Datentyp wird denn der Wert des Arrays deklariert?
Als INT??

Nein, das hängt davon ab, was Du im Array speichern möchtest.
In Deinem Beispiel war es ein Signal, also demzufolge Bool.
Möchtest Du kleinere Zahlen speichern -> INT, größere -> DINT, Zeichenketten -> String, usw., usw. ... .

Du hast ja zu Hause auch je ein Array an Messern, Gabeln und Löffeln. Welches Du zum Decken des Tisches auswählst, hängt vom Essen ab, oder?

EMZ schrieb:
Aber ich habe das prinzip verstanden.

Na denn hat sich die Mühe ja gelohnt.

EMZ · 15 Januar 2015

Hi ich habe noch einige kleine Fragen.

muss ich beim programmieren die reihenfolge der befehlszeilen einhalten?
Ich vermute mal ja oder ?

und wozu ist der ausgangszaehler da ?

Zählt er, wie viel takte der Ausgang auf true bleibt?

Ich verstehe die zeile so:

wenn schieberegister(array) die Position 1 erreicht hat, dann soll ausgangszaehler gleich der ausgabelänge sein.

Der Ausgang wird gesetzt, wenn der ausgangszaehler größer als 0 ist.

wenn der ausgang true ist, dann ist ausgangszaehler gleich ausgangszaehler -1

also bedeutet das, dass wenn der ausgang gesetzt wird, dass der ausgangszaehler die takte der Ausgabelänge zurückzählt und dann den Ausgang wieder
auf false setzt. Der Ausgang wird auf false gesetzt, wenn ausgangszaehler = 0 ist.

ist meine denkweise right ?

Code:

IF #schieben THEN
  FOR #index := #pos_1 TO 1 BY -1 DO
    #array [#index] := #array [#index -1];
  END_FOR;
  
  #array[0] :=  #start1;
  #start1:= false;
  
  IF #array[#pos_1]
  THEN #ausgangszaehler := #Laenge_1;
  END_IF;
  
  #ausgang := #ausgangszaehler > 0;
  
  
  IF #ausgang THEN #ausgangszaehler := #ausgangszaehler-1;
      
  END_IF;
  
 
  
END_IF;

LG
EMZ

hucki · 16 Januar 2015

Deine Denkweise ist richtig.
Also erst mal Respekt, Du machst Dich.

Und warum das so ist? Weil Du das damals in Deiner ursprünglichen Aufgabenstellung so wolltest:

EMZ schrieb:
Wenn Sensor 1 und Sensor 2 schalten, ... , danach sollen 100 weitere Impulse gezählt werden und anschließend für 4 Impulse Ausgang Q1 geöffnet werden.

Einige Sachen hattest Du Dir dann zwar noch anders überlegt, aber das war immer drin geblieben.

TIA Datentypen

hucki

User des Jahres 2014

EMZ

Level-2

hucki

User des Jahres 2014

EMZ

Level-2

hucki

User des Jahres 2014

EMZ

Level-2

hucki

User des Jahres 2014

hucki

User des Jahres 2014

EMZ

Level-2

EMZ

Level-2

hucki

User des Jahres 2014

EMZ

Level-2

hucki

User des Jahres 2014

EMZ

Level-2

hucki

User des Jahres 2014

EMZ

Level-2

hucki

User des Jahres 2014

Similar threads

Wir schützen deine Privatsphäre