# SCL -Arrays mit einander vergleichen



## MatthiasH24 (2 September 2008)

Erstmal ein Hallo an alle bin Student der Elektrotechnik und befinde mich gerade im Praxissemester.

Soll für ein Projekt eine Funktion entwickeln die 2 Arrays mit einandder vergleicht und dann bei ungleich bzw gleich einen wert ausgibt.

Die Funktion ist als Überprüfung einer eingabe gedacht also wenn neue eingabe muss sie sich ja vom alten unterscheiden nur dann wird der rest des programmes ausgeführt.

Bei beckhoff gibts es das schon vorprogrammiert aber bei Siemens leider nicht.

Wäre für jede Hilfe dankbar

Grüßle Matthias


----------



## Larry Laffer (2 September 2008)

Hallo Matthias,
also ...
wenn es bei Beckhoff da etwas gibt, das du brauchen kannst, warum passt du es dir dann nicht für Siemens an ...?
und dann ...
wie sieht denn dein bisheriger Ansatz zu dem Thema aus ... und woran hängt es bei dem ...?

Gruß
LL


----------



## vierlagig (2 September 2008)

ein tipp von mir: machs in SCL, da kannst du arrays indiziert ansprechen und damit dann zum vergleichen schöne schleifen bauen...

[edit] oh, steht ja schon im titel ... ähh ... dann packenen wir halt noch ne sinnvolle info dazu:

http://support.automation.siemens.com/WW/view/de/5949672
[/edit]


----------



## MatthiasH24 (2 September 2008)

Hi,

ja das anzupassen ist leider nicht wirklich so einfach da ich davon kein quellcode habe. es gibt schon funktionen im Internet die nachgebaut sind aber die funktionieren leider nur mit REAL und das kann ich nicht gebrauchen.

mein bisheriger Ansatz ist eher bescheiden habe schon was ausprobiert mit na schleife aber komm damit nicht wirklich klar.

Und im internet habe ich auch schon lange rumgesucht. Es ist nur so wenn die funktion nicht steht kann ich nicht weiter programmieren bzw geht ohne die gar nichts


----------



## vierlagig (2 September 2008)

dein problem liegt also darin, dass du die programmiersprache nicht kennst und auch nicht kennenlernen willst, irgendwie nicht so richtig lust hast dich da einzulesen, lieber bißchen was zusammenkopierst und dann frustriert zum himmel schreist "sone scheiße hier - warum geht das nicht!?" ???

zeig uns, was du bisher hast, dann werden schon einige kommen und dich in die richtige richtung drücken nd wenn du dran bleibst läuft das dinge ende der woche ... allerdings mußt du dafür deine einstellung zum programmieren nochmal überdenken ...


----------



## MatthiasH24 (2 September 2008)

Was heißt hier keine lust zum programmieren das stimmt nicht wirklichn habe hier das das buch Automatisieren mit Step 7 in AWl und SCL. DAs ich SCL noch nicht wirklich behersche gebe ich zu aber ich arbeite dran.

 Ich kann es nur zeigen wie es bei Beckhoff geht das ist halt eine wirklich feine sache

IF M_Change_Var_ix = 1 THEN
    MEMCMP_INT[1] := MEMCMP  ( pBuf1 := ADR(alterwert)  ,pBuf2 := ADR(neuerwert)  ,n := SIZEOF (alterwert)   );

IF   (MEMCMP_INT[1] <> 0) THEN
     (* Wenn eine Vorwahl Änderung der WKZ erfolgt, Nockenautomatik ausschalten *)
    Vorwahl   := TRUE;
    END_IF
    neuer wert    := alter wert;

wobei die alten und neuen werte als Array [1..32] of BOOl

dann habe ich mir überlegt etwas über awl zu probieren was ich aber nicht soll

es gilt n-1 = alter wert
n = neuer wert

L n-1
Ln
<>I
spb aenderung
nop 0

anderung: L n
              T n-1

oder ich habe mir es über eine if else funktion überlegt die aber nur auf papier probiert also weiß nicht ob es so gehen kann

if n>n-1
then ergebnis +1
elseif n<n-1
then ergebnis -1

else gleich ergebnis = 0


----------



## vierlagig (2 September 2008)

verstehe den einwurf mit AWL nicht...

hast du dir denn die SCL-umgebung mal angeschaut? grundaufbau der bausteine mal angesehen? eine funktionierende funktion mal angeschaut? ... dann wirst du sehen, dass es von dem code, den du dir da irgendwo rausgesucht hast, gar nicht soweit weg ist...


----------



## MatthiasH24 (2 September 2008)

ja das steht auch in dem buch wo ich habe. Das schlimme ist ja ich weiß das ich davon gar nicht soweit weg bin wenn nur nicht das memcmp fehlern würde. 

Ich muss halt unbedingt diese funktion mit Arrays machen da es so an die SPS ankommt mit schon vorgegebenen varaiblen und alles da kann ich nichts mehr dran ändern.

Eine Idee wäre noch ich lade die arrays in ein datenbaustein und verarbeite sie dann da weiter nachdem ich sie umgewandelt habe das Prob ist nur dabei das zuviel zeit verloren geht. Es muss schnell gehen. Darf leider nicht sagen wofür ich diesen Code brauche


----------



## Ralle (2 September 2008)

MatthiasH24 schrieb:


> Ich muss halt unbedingt diese funktion mit Arrays machen da es so an die SPS ankommt mit schon vorgegebenen varaiblen und alles da kann ich nichts mehr dran ändern.



Wie genau kommen denn die Array-Daten nun an, wo liegen sie zum verarbeiten bereit? In deinem DB, in Eingangsworten? In einem bereits definiertem Array oder als lose folge von Intwerten?


----------



## MatthiasH24 (2 September 2008)

Die daten kommen in einem bereits definierten Array an mittels der Viso wenn der einrichter auf F2 drückt werden die daten an die sps übergeben


----------



## vladi (2 September 2008)

*Daten...*



MatthiasH24 schrieb:


> Die daten kommen in einem bereits definierten Array an mittels der Viso wenn der einrichter auf F2 drückt werden die daten an die sps übergeben



In einem Briefumschlag wahrscheinlich.. 

V.


----------



## vierlagig (2 September 2008)

vladi schrieb:


> In einem Briefumschlag wahrscheinlich..



nee nee: übergeben! ... also in nem eimer


----------



## Ralle (2 September 2008)

Ok, Spaß beiseite:

ich nehme mal an, die Daten liegen in einem DB, als Array definiert.

Array_1 Array[1..100] of Int
Array_2 Array[1..100[ of Int

Dann könnte so in etwa die Verleichsfunktion aussehen:


```
FUNCTION FC100 : INT

VAR_INPUT

aArray_1: ARRAY[1..100] OF INT;
aArray_2: ARRAY[1..100] OF INT;

END_VAR

VAR_IN_OUT

Ergebnis: BOOL;
    
END_VAR
    
VAR_TEMP
    i: Int;
END_VAR

    // Anweisungsteil
    Ergebnis := False;
    FOR i := 1 TO 100 DO
        IF aArray_1[i] = aArray_2[i] THEN Ergebnis := True;
        ELSE
          Ergebnis := False;
          EXIT; 
        END_IF;
    END_FOR;       
   
    ;
    FC100 := 100;
END_FUNCTION
```

Die Schleife bricht nach dem ersten ungleichen Wert ab, du wolltest ja nur wissen ob gleich oder ungleich. Man könnte auch noch den Index mit ausgeben, ab welchem die Array ungleich sind, so als Goodi .


----------



## Ralle (2 September 2008)

Anhang, der Funktionsaufruf:


```
CALL  FC   100
       aArray_1:="Array".Array_1
       aArray_2:="Array".Array_2
       RET_VAL :=MW10
       Ergebnis:=M12.0
```

Wobei der DB 100 ("Array" in der Symboltabelle) die beiden definierten Array (Array_1 und Array_2) enthält.


----------



## vladi (2 September 2008)

*Code*

Hi,
Ralle hat wieder nichts zu tun..wie verdienst du Geld eigentlich? 
Und jetzt bitte das o.g. auch in AWL; manche Leute können nicht SCL..

Vladi


----------



## Ralle (2 September 2008)

vladi schrieb:


> Hi,
> Ralle hat wieder nichts zu tun..wie verdienst du Geld eigentlich?
> Und jetzt bitte das o.g. auch in AWL; manche Leute können nicht SCL..
> 
> Vladi



Du bist unangemessen frech . Eigentlich sollte ich die gelbe Karte zücken, aber da wartet ihr Burschen ja nur drauf *ROFL*.


----------



## MatthiasH24 (2 September 2008)

Vielen Dank schon mal das wird mir aufjedenfall mal weiter helfen!

Ja das prob ist das der jenige wo mich dabei die ganze zeit jetzt unterstützt hat oder zumindest meine frage beantwortet ncht da ist.

ich gebe zu ich habe vorher noch nichts mit Arrays gemacht. Die Arrays wo ich habe sind:

Vorwahl_1   : ARRAY [1..32] OF BOOL;
EndEin_1  : ARRAY [1..32] OF DINT;  
EndAus_1  : ARRAY [1..32] OF DINT; 
EndEin_1  : ARRAY [1..32] OF REAL;  
EndAus_1  : ARRAY [1..32] OF REAL; 
T_Impuls_1   : ARRAY [1..32] OF DINT; 

wobei _1 für neuen wert steht

die alten werte die zum vergleich dienen habe ich natürlich auch

geht das dann mit jedem daten typ?


----------



## vladi (2 September 2008)

*Nicht beleidigt sein...*

Gibt es "angemessen frech sein"..weiss nicht. 
Was ist "Gelbe Karte", bzw. die Folgen davon.. Punkte in Flensburg? 
V.


----------



## vladi (2 September 2008)

*Funktion*



MatthiasH24 schrieb:


> Vorwahl_1   : ARRAY [1..32] OF BOOL;
> EndEin_1  : ARRAY [1..32] OF DINT;
> EndAus_1  : ARRAY [1..32] OF DINT;
> EndEin_1  : ARRAY [1..32] OF REAL;
> ...



Vergleichen geht nur wenn die Typen gleich sind; so brauchst du je eine Funktion dafür; die eine vom Ralle  noch 2x umbauen.

Ne Frage mal: Kannst du überhaupt SCL verwenden?

V.


----------



## MatthiasH24 (2 September 2008)

vladi schrieb:


> Ne Frage mal: Kannst du überhaupt SCL verwenden?
> 
> V.


 
Wie meinst du ob ich überhaupt SCl verwenden? Wenn du meine persönliche Programmierfähigkeit damit meinst dann kann ich das im mom nicht 100% bejahen

Wenn es um das Projekt geht dann ja. Das lustigste ist ja das ich gar nichts anderes machen soll. und an der fh lernt man nur awl und fup habe bis gestern noch nie was von SCL gehört gehabt...


----------



## Ralle (2 September 2008)

vladi schrieb:


> Gibt es "angemessen frech sein"..weiss nicht.
> Was ist "Gelbe Karte", bzw. die Folgen davon.. Punkte in Flensburg?
> V.



Ich und beleidigt, nö, deshalb stand doch das ROFLMAO dahinter!

@Matthias

Du mußt mein Funktionsbeispiel entsprechend umändern. Also Länge auf 32.
Da das Array ja als In Definiert ist mußt du in diesem Falle für jeden Datentyp einen eigene Funktion schreiben, das ist das Einfache.
Die zweite Möglichkeit wäre, nicht die Arrays zu übergeben, sondern nur Any oder Pointer und sich damit dann in dem FC unabhängig vom Typ eine Vergleichsroutine zu bauen. Wohl kompliziert und ich weiß nicht, ob das so gelingen würde.

Ich würde es dann so versuchen:

Input als Any
Aus dem Any die Daten über DB , Start und Länge herausholen.
Die Daten in ein internes Array (z.Bsp. Byte) umkopieren, evtl. geht das sogar ganz einfach mit dem SFC20 und dem Any!!!
Der Inhalt der Array of Byte ist dann zwar im Prinzip wirr, aber es geht ja nur darum zu sehen, ob gleich oder ungleich, also gleich wirr, reicht dazu.


----------



## vladi (2 September 2008)

*Projekte und Sprachen*

Hi,


MatthiasH24 schrieb:


> Wie meinst du ob ich überhaupt SCl verwenden? Wenn du meine persönliche Programmierfähigkeit damit meinst dann kann ich das im mom nicht 100% bejahen
> 
> Wenn es um das Projekt geht dann ja. Das lustigste ist ja das ich gar nichts anderes machen soll. und an der fh lernt man nur awl und fup habe bis gestern noch nie was von SCL gehört gehabt...



Nein, deine persönliche Programmierfähigkeit wollte ich nicht checken, sondern ob du Step 7 mit SCL hast! 
SCL und GRAPH sind Programmiereditoren, die normalerweise nicht im Step7 für "normalsterbliche"(Standard) vorhanden sind; das muss man extra kaufen, bzw. man kauft die "Step 7 Professional" Software.

Vladi


----------



## MatthiasH24 (2 September 2008)

Da wird mir ja schon vom lesen schlecht .

Ne ich habe deins schonmal umgeschrieben um es an meine arrays anzupassen.

Das was ich benötige ist der vergleich auf ungleich aber das ist ja kein prob das zu ändern und das exit habe ich auch rausgemacht weil da ja noch mehere abfragen von anderen arrays kommen soll.

Was ich nur als frage habe wenn ich als ergebnis haben will -1,1,0 kann ich dann einfach sagen Ergebnis : INT;

bei der variablen deklaration?


----------



## MatthiasH24 (2 September 2008)

Und wegen der Software wie am Anfang gesagt ich bin im Praxissemester bei einer Firma die nur Maschinen programmiert also die ham die "Professional" aber bis jetzt immer mit Beckhoff SPS und nicht mit Siemens nur der jetztzige Kunde will nun mal unbedingt Siemens SPS und wenn er das will bekommt er es auch.

Nur das Problem ist das wenige S7 können und die, die es können nehmen nur SCL


----------



## vladi (2 September 2008)

*Scl*

Klar, Ergebnis : INT;  deklarieren.
Dann musst du in der Schleife auch enspr. Werte zuweisen, nicht TRUE oder FALSE!
.....
Ergebnis := 1;
usw.
V.


----------



## Larry Laffer (2 September 2008)

MatthiasH24 schrieb:


> Nur das Problem ist das wenige S7 können und die, die es können nehmen nur SCL


 
Das hat sicher seinen Grund ...
Wie hättest du es denn sonst gemacht ? In Standard-AWL ? Das ist doch viel zuviel Arbeit ...


----------



## MatthiasH24 (3 September 2008)

Hi ja ich hätte es wahrscheinlich in standard awl programmiert weil wir im studium da so drauf trainiert wordén sind. Aber ich muss agen umso mehr ich mit SCL mache umsoweniger verstehe ich wieso man uns das nicht im studium zeigt.

An vladi noch eine frage

das mit dem ergebnis als int deklarieren ist klar, aber das problem ist nur das ich egal welchen datentyp als array ich habe immer die ergebnise für kleiner -1 größer 1 und gleich 0 benötige

Ps: Einen wunderschönen Guten Morgen wünsche ich


----------



## Ralle (3 September 2008)

MatthiasH24 schrieb:


> An vladi noch eine frage
> 
> das mit dem ergebnis als int deklarieren ist klar, aber das problem ist nur das ich egal welchen datentyp als array ich habe immer die ergebnise für kleiner -1 größer 1 und gleich 0 benötige
> 
> Ps: Einen wunderschönen Guten Morgen wünsche ich



Ich frag mal was nach dazu. Heißt das, du willst die Ergebnisse des Vergleichs in einem weiteren Array speichern? Denn, wenn du 32 Werte vergleichst, wo ist dann die Grenze für größer oder kleiner? Ansonsten, wo ist das Problem? Du baust deine IF ... Then ... Else - Vergleiche und jeweils als Ergebnis (INT) weist du dann -1, 0 oder +1 zu.

Ergebnis := -1;


----------



## MatthiasH24 (3 September 2008)

Ne das ganze zeug dient nur zum vergleichen. da wir die andere programmteile aber eins zu eins von beckhoff zu siemens übersetzten können brauchen wir eben diesen vergleichs wert.

das problem ist aber wenn ich bei der variablen deklaration die arrays nicht als INT deklariere sagt er mir als fehlermeldung das ergebnis muss vom typ bool sein

Hier das prob


```
FUNCTION FC100 : INT
VAR_INPUT
wert1:   ARRAY[1..32] OF Bool;
wert2: ARRAY[1..32] OF Bool;
END_VAR
VAR_IN_OUT
Ergebnis: Int;
 
END_VAR
 
VAR_TEMP
    i: Int;
END_VAR
    // Anweisungsteil
 
    FOR i := 1 TO 32 DO
1.        IF wert1[i] < wert2[i] THEN Ergebnis := -1;
        ELSIf
          wert1[i] > wert2[i] THEN Ergebnis := 1;
          ELSE
            Ergebnis :=0;         
        END_IF;
 
        //wert1 := wert2;
 
    END_FOR;      
 
 
    FC100 := 32;
END_FUNCTION
```
 
Fehlermeldung

Bei 1. der Ausdruck muss vom datentyp Bool sein


----------



## kiestumpe (3 September 2008)

Naja '<' oder '>' macht bei Bool kein Sinn-zumindest in der S7-Welt.
Du musst das mit NOT, Vergleich auf FALSE, oder Konvertierungsfunktion machen.


----------



## Ralle (3 September 2008)

Bei Bool mußt du auch Operatoren nehmen, die für Bool zugelassen sind, also

=
<>

größer und kleiner geht für True und False nicht!


----------



## MatthiasH24 (3 September 2008)

So also ich habe mal en bißchen weiter rum probiert. Ihr wißt ja langsam ernährt sich das Eichhörnchen !

hier mal mein code mit natürlich der schleife von euch


```
FUNCTION_BLOCK FB250
VAR
Wert1: ARRAY [1..2] OF INT;
Wert2: ARRAY [1..32] OF INT;
     // temporäre Variablen
iy: INT;
ix: INT;
iz: ARRAY [1..5] OF INT;
iu : INT;
END_VAR
VAR_INPUT
    start: BOOL;
END_VAR
    
VAR_OUTPUT
    
    ergebnis: BOOL;
END_VAR
 

BEGIN
IF start then    
  FOR ix := 0 TO 5 DO
  iz[ix]:= Wert1[1];
  iu := 2;
    Wert2[iu]:= iu;
     FOR iy := 0 TO 32 DO
       IF Wert1[iy] > Wert2[iy] THEN ergebnis := true;
       ELSE ergebnis := false;
      END_IF;
    END_FOR;
   END_FOR;    
 END_IF; 
END_FUNCTION_BLOCK
```
 
mein ziel ist das ich mit der ersten for schleife die funktion also der vergleich testen kann (mit unterschiedlichen werten die es laden soll) ob er auch sicher funktioniert. Wäre ja schlimm wir würden was abgeben und dann erst merken das es einen fehler gibt. Die vergleichsfunktion soll aber erst gehen wenn start = true ist. Start ist im Ob als eingang definiert den ich auf einschlaten kann.

WWenn ich das tue geht mein SPS in Stop.


----------



## kiestumpe (3 September 2008)

Was sagt denn dein Diagnospuffer? (Zielsystem->Diagnose->Baugruppenzustand)


----------



## MatthiasH24 (3 September 2008)

STOP durch Programmierfehler (OB nicht geladen oder nicht möglich, bzw. kein FRB vorhanden ) 
Unterbrechungstelle im Anwenderprogramm: Zyklisches Programm (OB 1) 
Prioritätsklasse:    1
FB-Nummer:   250
Bausteinadresse:     74 
Bisheriger Betriebszustand: RUN
Angeforderter Betriebszustand: STOP (intern)
interner Fehler, kommendes Ereignis

das sagt er

im ob steht nur 

 CALL  FB   250 , DB250
       start   :=E1.0
       ergebnis:=M1.0
 BE


----------



## kiestumpe (3 September 2008)

Schau dir dies nochmal genau an:


```
FOR iy := 0 TO 32 DO
       IF Wert1[iy] > Wert2[iy]
```
Wert1 geht nur bis Index5, also hier ist schonmal ein Zugriffsfehler!


----------



## MatthiasH24 (3 September 2008)

Ja ich habe gedacht das dass eine nur angibt was er vergleichen soll! Aber so gebe ich dir natürlich recht. ich mag keine Arrays :-(!


----------



## kiestumpe (3 September 2008)

Mal nebenbei bemerkt würde ich den Test des FB's nicht in den FB integrieren, sondern von aussen beschalten.
Sinn könnte unter anderem, statt den statischen Array's im FB anzugeben, zwei Datenbausteinnummern und deren Länge als Eingangsvariablen zu nehmen.
Und wenn es nur um ein "<>" geht reicht sogar ein FC der die Inhalte Word-weise vergleicht.


----------



## MatthiasH24 (3 September 2008)

ja es geht ja auch darum das es ich es net nur wort weiße auf ungleich untersuchen will. Bekomme echt noch die Krise solange halt das zeug nicht angeschlossen ist von denen ich die Arrays bekomme kann ich es nur über umwege testen und das kostet voll viel zeit...


----------



## kiestumpe (3 September 2008)

Schau dir mal noch den Baustein "BLKMOV-SFC20" an, bei Festellung von Eingabeänderungen muss ja auch der Vorgängerzustand gerettet werden (DBxy - DatenAlt) oder sowas.
Allerdings ist mir auch nicht ganz klar, wieso eine Eingabe auf diese umständliche Weise erkannt werden muss?!? Was steckt da für ein Sinn dahinter?


----------



## MatthiasH24 (3 September 2008)

Meinst du jetzt den Sinn weil es mit Arrays gemacht wird oder den vergleich auf Eingabeänderung?


Ja das mit den alten daten habe ich schon geht aber auch ohne BLKMOV.


----------



## kiestumpe (3 September 2008)

Letzteres- den Vergleich auf Eingabeänderung.


----------



## Larry Laffer (3 September 2008)

MatthiasH24 schrieb:


> ja es geht ja auch darum das es ich es net nur wort weiße auf ungleich untersuchen will. Bekomme echt noch die Krise solange halt das zeug nicht angeschlossen ist von denen ich die Arrays bekomme kann ich es nur über umwege testen und das kostet voll viel zeit...


 
Es wird aber nicht einfacher, wenn du mit den "echten" Daten herummachst ...

Ich finde den schon gemachten Vorschlag mit dem "flexiblen" Auswerten gar nicht schlecht. Versuch doch mal eine Funktion (FC) zu bauen, der du per ANY-Pointer die beiden Quell-Datenblöcke übergibst. Der ANY-Pointer beinhaltet dann auch (zumindestens bei richtiger Handhabung) den Datentyp der Quelle und du kannst das flexibel auswerten.
Dieser Vorschlag ist allerdings eine ganze Ecke aufwendiger als alles bisherige.

Zu deinem Script in Beitrag #32 noch einmal:
Die beiden Array's wert1 und wert2 werden auch nicht korrekt indexiert werden. Das eine (wert1) hast du nur 2 Elemente groß dimensioniert und das Zweite hat zwar die richtige Größe, die Schleife (iy) beginnt aber mit "0" und diesen Index hast du auch in keinem Array ...

Gruß
LL


----------



## MatthiasH24 (4 September 2008)

So nach dem das mit den vergleichen jetzt eigentlich fast passt... soll ich es doch anderster machen man die haben vllt nerven.

Die einfachste Änderung ist die, das der vergleich nur solange stattfinden soll bis er einen Änderung findet und dann abbrechen bzw mittels EXIT die Schleife verlassen.

Was den schwierigen teil an geht ist das ich mit einem pointer die Startadresse und endadresse des Arrays rauslesen soll und dann mittels der sozusagen gezählten Bites die forschleife starten soll.

Das problem ist nur das ich mit den pointer in SCl nicht klar komme.

Mit AWl ist es ja um die startadress rauszubekommen so:

L P#Name;
LAR1 P#Name;
LAr2 p#name;

zumindest steht es so in meinem buch aber leider halt nur in awl im internet habe ich bis jetzt auch nichts gefunden was es mir einfacher macht! hat da von euch jemand ne idee

Also wie gesagt AWl kann ich mir was außem internet zusammen suchen aber leider nicht in SCL!

Grüßle


----------



## vladi (4 September 2008)

*Scl*

Hi,
ich wollte mal was über die o.g. Schleife sagen:

```
......
iz: [B]ARRAY [1..5][/B] OF INT;
iu : INT;
END_VAR
VAR_INPUT
    start: BOOL;
END_VAR
    
VAR_OUTPUT
    
    ergebnis: BOOL;
END_VAR
 

BEGIN
IF start then    
  FOR ix := [B]0[/B] TO 5 DO
  iz[B][ix][/B]:= Wert1[1];           // hier wird iz[[B]0[/B]] angesprochen..gibt es aber nicht!
```

Vladi


----------



## MatthiasH24 (4 September 2008)

ja die art kann ich ja jetzt eh nimma nehmen ahhte es aber gestern abend noch zum laufen mittels debug modus gebracht. ich musste aber zuerst in der hilfe suchen bei siemens das ich überhaupt wusste wie ich den debugger starte...

Habe noch ein beispiel mit zeiger in der hilfe gefunden nur steht da leider net dabei was das für variablen sind


```
BEGIN
IF neuwert <> altwert THEN
    zeiger := zeiger MOD Anzahl;
    messwert[zeiger] := messwert_ein;
    zeiger .= zeiger + 1;
END_IF;
altwert := neuwert;
```


----------



## vladi (4 September 2008)

*Scl..*

Hi,
Larry hat oben ein Vorschlag für eine FC mit Pointerübergabe..das solltest du dir anschauen, suche im Forum z.B. nach ANY Pointer..
Ablauf:
-die FC bekommt als Input die Pointer der Arrays: (P#DB100.dbx60.0 DWORD 32 und P#DB100.dbx100.0 DWORD 32 z.B.)
- diese Pointer werden mittels *AT* Schablone zerlegt, dann weisst du die Anfangsadresse, die Länge und was für Datentyp es ist.
- dann mittels Temp Variablen diese Arrays vergleichen(es sind mehrere Schleifen zu vorbereiten, je für ein Datentyp, und eben die richtige ausführen..) und Ergebnis ausgeben.

Vladi


----------



## MatthiasH24 (4 September 2008)

Hi also das was du meinst habe ich nicht gefunden. oder gefunden und nicht gesehen das es das war.


----------



## Larry Laffer (4 September 2008)

@Vladi:
Schön, dass du den Ball noch einmal wieder ins Spiel gebracht hast ...

@Matthias:
Wenn du dir das zutraust - ist allerdings ein bißchen Arbeit damit verbunden - dann kannst du auf diesem Wege eine Funktion (FC) mit SCL erstellen, die im Prinzip so arbeitet, wie das ursprünglich von dir genannte Beispiel.


----------



## MatthiasH24 (4 September 2008)

Also war das nur ein Vorschlag von einer funktion oder hast du die gemacht? falls nicht muss ich mir da sowieso irgednwas einfallen lasse.

ich bin jetzt immerhin soweit das ich jetzt einen pointer habe denke ich zumindest...


```
FUNCTION_BLOCK FB25
VAR_TEMP
   zeiger: STRUCT
   ANY_Wert: BYTE;
   quelle_Typ: BYTE;
   quelle_Laenge: WORD;
   quelle_DB_Nr: WORD;
   quelle_byte_Zeiger: DWORD;
END_STRUCT;
pAny_quelle AT zeiger: ANY;
erg: INT;
END_VAR
zeiger.ANY_Wert := 16#10;
zeiger.quelle_Typ := 16#02;
zeiger.quelle_Laenge :=16#04;
zeiger.quelle_DB_NR := 16#06;
zeiger.quelle_byte_zeiger :=16#84;
 
END_FUNCTION_BLOCK
```
 
nur das problem ist das ich jetzt nicht weiß wie ich den weiter verwenden kann also in einem konkreten programm.


----------



## Larry Laffer (4 September 2008)

Ich habe etwas ähnliches schon einmal gemacht. Für die Zerlegung des Any-Pointers habe ich auch ein schönes Beispiel. Ein fertiges Programm wirst du von mir nicht erhalten - ich helfe aber gerne dabei, eins zu entwickeln. Wenn du von mir eine fertige Arbeit erhalten würdest, dann wäre dir im Endeffekt damit nicht geholfen - nur was man selber gemacht hat, das versteht man auch ...


----------



## Larry Laffer (4 September 2008)

Hier übrigens das Beispiel :
	
	



```
FUNCTION FC399 : VOID
Title   = 'UP Any-Pointer zerlegen'  // UP Any-Pointer zerlegen
 
//     Bausteinparameter
 
VAR_INPUT
   // Eingangsparameter
   DatenQuelle : ANY ;
END_VAR
 
VAR_OUTPUT
   // Ausgangsparameter
   Daten_Mem : STRING [4] ;
   Daten_Typ : STRING [4] ;
   Daten_DB  : WORD ;
   Daten_Ptr : DWORD ;
   Daten_1W  : INT ;
   Daten_Len : INT ; 
//   Inhalt : INT ;
END_VAR
 
VAR_TEMP
   // temporäre Variablen
   hDatenQuelle : ANY ;
   xDatenQuelle AT hDatenQuelle : STRUCT
              ID_Code   : BYTE ;  // 10h für S7
              DataTyp   : BYTE ;
              Anzahl    : WORD ;
              DB_Nr     : WORD ;
              SpeicherPtr : DWORD ;
              END_STRUCT ;
   yDatenQuelle AT hDatenQuelle : STRUCT
              ID_Code   : BYTE ;  // 10h für S7
              DataTyp   : BYTE ;
              Anzahl    : WORD ;
              DB_Nr     : WORD ;
              Speicherbereich : ARRAY [0..3] OF BYTE ;
              END_STRUCT ;
END_VAR
 
 
//     Anweisungsteil 
 
BEGIN
   hDatenQuelle := DatenQuelle ;
 
   IF    xDatenQuelle.DataTyp = w#16#00 THEN Daten_Typ := 'Nil' ;   // Nil
   ELSIF xDatenQuelle.DataTyp = w#16#01 THEN Daten_Typ := 'X' ;     // Bool
   ELSIF xDatenQuelle.DataTyp = w#16#02 THEN Daten_Typ := 'B' ;     // Byte
   ELSIF xDatenQuelle.DataTyp = w#16#03 THEN Daten_Typ := 'Char' ;  // Char
   ELSIF xDatenQuelle.DataTyp = w#16#04 THEN Daten_Typ := 'W' ;     // Word
   ELSIF xDatenQuelle.DataTyp = w#16#05 THEN Daten_Typ := 'Int' ;   // Integer
   ELSIF xDatenQuelle.DataTyp = w#16#06 THEN Daten_Typ := 'DW' ;    // Double-Word
   ELSIF xDatenQuelle.DataTyp = w#16#07 THEN Daten_Typ := 'DInt' ;  // Double-Integer
   ELSIF xDatenQuelle.DataTyp = w#16#08 THEN Daten_Typ := 'Real' ;  // Real
   ELSIF xDatenQuelle.DataTyp = w#16#09 THEN Daten_Typ := 'Date' ;  // Date
   ELSIF xDatenQuelle.DataTyp = w#16#0A THEN Daten_Typ := 'TOD' ;   // Time-of-Day
   ELSIF xDatenQuelle.DataTyp = w#16#0B THEN Daten_Typ := 'Time' ;  // Time
   ELSIF xDatenQuelle.DataTyp = w#16#0C THEN Daten_Typ := 'S5T' ;   // S5Time
   ELSIF xDatenQuelle.DataTyp = w#16#0E THEN Daten_Typ := 'DT' ;    // Date-and-Time
   ELSIF xDatenQuelle.DataTyp = w#16#13 THEN Daten_Typ := 'Str' ;   // String
   END_IF ;
   IF    yDatenQuelle.Speicherbereich[0] = w#16#81 THEN Daten_Mem := 'E' ;   //Eingänge
   ELSIF yDatenQuelle.Speicherbereich[0] = w#16#82 THEN Daten_Mem := 'A' ;   // Ausgänge
   ELSIF yDatenQuelle.Speicherbereich[0] = w#16#83 THEN Daten_Mem := 'M' ;   // Merker
   ELSIF yDatenQuelle.Speicherbereich[0] = w#16#84 THEN Daten_Mem := 'DB' ;  // DB
   ELSIF yDatenQuelle.Speicherbereich[0] = w#16#85 THEN Daten_Mem := 'DI' ;  // Instanz-DB
   ELSIF yDatenQuelle.Speicherbereich[0] = w#16#86 THEN Daten_Mem := 'L' ;   // Lokaldaten
   ELSIF yDatenQuelle.Speicherbereich[0] = w#16#87 THEN Daten_Mem := 'LV' ;  // vorherige Lokaldaten
   END_IF ;
   Daten_DB  := xDatenQuelle.DB_Nr ;  
   Daten_Len := WORD_TO_INT (xDatenQuelle.Anzahl) ;
   Daten_Ptr := xDatenQuelle.SpeicherPtr AND dw#16#00FF_FFFF ;
   Daten_1W  := DWORD_TO_INT(SHR (IN:=Daten_Ptr , n:=3)) ;
 
END_FUNCTION
```
Das Ding ist nur als Beispiel gedacht ... ich nehme es aber gern hin und wieder für Erklärungen heran.
Weiteres zum ANY-Pointer gibt es in der Rubrik FAQ. 

Gruß
LL


----------



## MatthiasH24 (4 September 2008)

Ja das sehe ich ein. dann bist du herzlich eingeldane mir dabei zu helfen 
!

Wie sieht es mit meinem Programm oben aus habe ich damit nur ein parameter oder einen pointer? das würde mir zuerst schon mal helfen


----------



## Larry Laffer (4 September 2008)

Du hättest 2 Eingangsparameter vom Typ ANY (Quell-Array 1 und 2). Des weiteren dann deine Ausgangsparameter, die den Status des Vergleichs ausgeben und ggf. was dir sonst noch so dazu einfällt ...

Die IN's könnten dann so aussehen :
	
	



```
Quelle_1 : p#DB1.DBX0.0 REAL 32
Quelle_2 : p#DB2.DBX0.0 REAL 32
```


----------



## MatthiasH24 (4 September 2008)

Redest du jetzt von deinem beispiel oder von meinem?

Die Abfrage auf welchen datentyp finde ich gut das könnte ich nämlich sehr gut bei mir einbinden.

Aber wie du schon richtig gesagt hast würde ich das schon gerne selber schreiben mit dem pointer dann kann aihc es auch brauche nur noch den richtigen Anstoss.


----------



## Larry Laffer (4 September 2008)

Das Beispiel mit den Quellen (1 und 2) war für dich gedacht ...
Ich bin mal gespannt, was du so baust ...


----------



## MatthiasH24 (4 September 2008)

Ja jetzt abue ich nichts mehr mache jetzt feierabend aber morgen früh geht es weiter.

danke schon mal und grüßle


----------



## vierlagig (4 September 2008)

MatthiasH24 schrieb:


> Ja jetzt abue ich nichts mehr mache jetzt feierabend aber morgen früh geht es weiter.



ja Larry, ich schüttle auch den Kopf ... aber laß die Jugend mal machen ...


----------



## MatthiasH24 (5 September 2008)

Was heißt denn hier kopfschütteln? habe in meiner Wohnung kein Internet und auch nicht die software!

Jetzt bin ich aber wieder dran und stehe immer noch mit den Pointer auf Kriegsfuss...

Kann mir vllt irgendjemand nur ein kleines beispiel schicken das ich mal sehe wie das genau aufgebaut ist die Funktion? Wäre nett.

Und @larry das mit den Quellen so als VAR_Input def geht nicht auch net mit Strichpunkt.


----------



## kiestumpe (5 September 2008)

*Hinweis "String"*

Moin,

ich hab den FC jetzt nicht getestet, aber es könnte sein, dass Byte 0 und 1 der Strings noch die maximal-Länge und die tatsächliche Länge zugewiesen werden muss. Strings sind in S7 etwas umständlich zu händeln 

hth


----------



## MatthiasH24 (5 September 2008)

ich verstehe zwar grad net was mir damit sagen willst aber ok 

So ich habe jetzt mal etwas rumprobiert und aus nem anderem beispiel was eingefügt aber es geht nicht so wirklich.
hier mal der Code


```
FUNCTION FC10:INT
VAR_INPUT
    
    pVariablename: ANY;
END_VAR
VAR_TEMP
   pZeiger: ANY;
   MyZeiger AT pzeiger:STRUCT
   ID: BYTE;
   TYP: BYTE;
   NUM: WORD;
   DBN: WORD;
   PTR: DWORD;
END_STRUCT;
dwOffset:DWORD;
END_VAR
BEGIN
pZeiger:= pVariablename;
dwOffset := MyZeiger.PTR;

(*zeiger.ANY_Wert := 16#10;
zeiger.quelle_Typ := 16#02;
zeiger.quelle_Laenge :=16#04;
zeiger.quelle_DB_NR := 16#06;
zeiger.quelle_byte_zeiger :=16#84;*)
FC10 := WORD_TO_INT(DWORD_TO_WORD(dwOffset));   
    
END_FUNCTION
FUNCTION_BLOCK Fb50
VAR
    Wert : ARRAY [1..32] OF INT;
    isizeofWert: INT;
    ibyteOffset: INT;
END_VAR
VAR_TEMP
    ibyteoffsetFromStratOfDB:INT;
END_VAR
BEGIN
isizeofWert:= FC10(pArrayName:=Wert);
ibyteOffset:= FC11(pArrayName:= Wert ,pArrayElement:= Wert[13]);
ibyteoffsetFromStratOfDB:= FC12(pVariablename:= DB10.idata13);
END_FUNCTION_block
```
 
So mein problem ist jetzt das er beim FB rum motzt wegen den pArray Variablen und ich nicht weiß ob ich vorher schon was in den DB schreiben muss das er es erkennt.

mein Ob sieht bis jetzt so aus


```
CALL  FC    10
       pVariablename:=DB10.DBW2
       RET_VAL      :=MW100
      CALL  FC    11
      CALL  FC    12

      BE
```


----------



## MatthiasH24 (5 September 2008)

Weiß zu dem beispiel niemand was?


----------



## Ralle (5 September 2008)

An den FC10 mußt du dann auch einen Any als pVariablenname ranschreiben, der sieht anders aus, lies doch mal in der Foren-FAQ oder in der Siemenshilfe zum Typ Any nach!

"P#DB10.DBX2.0 Byte 20" z.Bsp. Du kannst auch mal versuchen, dein im DB definiertes Array Symbolisch an pVariablenname zu schreiben, also mit dem Symbolnamen des DB und dem Namen des Array in dem DB!


----------



## Larry Laffer (6 September 2008)

... siehe dazu doch auch bitte noch mal Beitrag #51 und #53 von mir ...


----------



## MatthiasH24 (8 September 2008)

So aslo habe mich jetzt übers Wochenende mit zeiger in AWl eingearbeitet. da verstehte ich das Grundgerüst besser.

Jetzt versuche ich das langsam in SCl übersetzen nur ich komme schon nicht bei der eingabe der dbnr weiter...

Hier mal der code dazu

```
VAR_INPUT
    x : INT;
END_VAR
VAR_OUTPUT
    DBNR: INT;
END_VAR
VAR_TEMP
    // temporäre Variablen
MYPOINTER : ANY;
AnyPointer AT MYPOINTER: STRUCT
                        ID :  BYTE;
                        TYP   :  BYTE;
                        ANZ   :  WORD;
                        DBNR  :  WORD;
                        BZ    : DWORD;
                        END_STRUCT;            
END_VAR
BEGIN
MYPOINTER := x;
DBNR := WORD_TO_INT(AnyPointer.DBNR);
END_FUNCTION_block
```
 
das Problem ist nur wenn ich das im Debug modus durchlaufen lasse. Nimmt er Kommt bei DBNR nicht der Wert den ich bei x eingebe.

kann mir jemand sagen was ich da falsch mache.


----------



## MatthiasH24 (8 September 2008)

was mir selber schon aufgefallen ist das, ich beim OB1 den Aufruf mache Call fb650,db65

und bei dem DBNR immer 65 raus kommt. Das heißt ja somit das er immer die Nummer des Instanzdaten Db nimmt was ich aber nicht will.

wenn ich jetzt mehere daten habe und einmal sollen sie im db10 und das andere mal in db11 gespeichert werden somit müsste ich das doch über die Variable 'x' machen können.


----------



## Larry Laffer (8 September 2008)

Hallo Matthias,
ich hatte dir das ANY-Pointer -Beispiel genannt, weil ich gedacht hatte, dass du etwas damit anfangen kannst. 
Ein ANY-Pointer ist von der Systematik her die Angabe eines Speicher-Bereichs und deren Länge (falls gewünscht).

Wenn du in deinem Fall die DB-Nr. aus "x" einlesen willst, dann muss x der ANY-Pointer sein, den du dann zerlegst. Also so :
	
	



```
VAR_INPUT
    x : [COLOR=red]ANY[/COLOR];
 [COLOR=red]  AnyPointer AT x : STRUCT
                        ID :  BYTE;
                        TYP   :  BYTE;
                        ANZ   :  WORD;
                        DBNR  :  WORD;
                        BZ    : DWORD;
                        END_STRUCT;[/COLOR]            
END_VAR
VAR_OUTPUT
    DBNR: INT;
END_VAR
VAR_TEMP
    // temporäre Variablen
END_VAR
BEGIN
   DBNR := WORD_TO_INT(AnyPointer.DBNR);
END_FUNCTION_block
```
 
Beim Aufruf des Bausteinstein schreibst du dann als Datensatz an x :
	
	



```
call FB10
       x := p#DB10.DBX0.0 
       DBNR := MW10
```
In MW10 sollte nun "10" stehen ...

Gruß
LL


----------



## MatthiasH24 (8 September 2008)

Danke schonmal das funktioniert aber ich muss echt sagen das ich noch ziemlich probleme mit SCL habe.

wie kann ich z.b ein Eingangswort einlesenß bei AWl geht es ja einfach 

L EW XX

aber wie geht das bei SCl?


----------



## Larry Laffer (8 September 2008)

im Prinzip genauso ...

```
myVar := EW10 ;
```
Es empfiehlt sich aber nicht, mit absoluter Adressierung zu arbeiten ...

Und ... wenn dir noch etwas unklar ist ... IMMER fragen ...

Gruß
LL


----------



## MatthiasH24 (8 September 2008)

Naja eigentlich darf ich da dazu gar nichts sagen... ist ja eigentlich logisch. Aber da ich bei SCL noch net so logisch denken kann wie bei AWl ist das, dass problem..

Ich probiere mal ob ich so weiter komme.

Danke


----------



## MatthiasH24 (8 September 2008)

```
L #ZAE1;             //Lade Speicherstelle
SLW 3;                         //Schalterstellung in BYTE Adressieren
T #ADRZ;                      //Transferie in Adressregister
U #Z_1;
FP #FO1;
SPBNB M001;                
L #XW_E;                    //lade Einzulesender Wert
T DBW [#ADRZ];           
L #ZAE1;                     //alte Speicherstelle
+ 2;                            //erhöhe die Speicherstelle um 2
T #ZAE1;                     //neue Speicherstelle
L #ZAE3;                     //lade Anzahl einzulesende/auszulesende Stellen
+ 1;                            //erhöhe um 1
T #ZAE3;                    //Transferiere
L #LAE;                     //Lade maximale Anzahl der Speicherstellen
L -1;                        //Lade -1
+I;                            //Addiere -1 von alten Wert
L 2;                           //L 2
*I ;                          //Multipliziere LAE um den Faktor 2
L #ZAE1;                   //Lade Speicherstelle ZAE1
TAK;                         
>I;                             
Spbn M001;  // Springe Bedingt zu M001 ( wenn Akku 1 nicht größer als Akku2)
L 0;   // L 0
T #ZAE1;  // Transferie '0' in den zeiger der einzulesenden Daten
M001: nop 0; // falls Sprung NOP 0 (no operation)
```
 
Das ist mal der AWl Code (Ein Teil davon) von meiner zeiger geschichte. Aber ich weiß nicht wie ich es mit SCL machen soll mit der adressvergabe und erhöhen der Adresse das er die richtige speicherstelle nimmt


----------



## Larry Laffer (8 September 2008)

naja ...

SCL hat eine andere Syntax, die einer Progarmmiersprache eben (in diesem Fall stark an Pascal angelehnt).

SCL ist auch nicht das Allerheilmittel - man muß schon wissen, wo es Sinn macht es einzusetzen. Ganz generell würde ich sagen immer dann, wenn man mit Schleifen oder komplizierten Berechnung arbeitet. Hier wird die Lesbarkeit des Codes (nicht der übersetzte AWL-Code sondern der SCL-Code) doch ganz erheblich verbessert. Manche komplizierten AWL-Scripts werden in SCL ggf. zu einem übersichtlichen Dreizeiler ...

Gruß
LL


----------



## MatthiasH24 (8 September 2008)

ja wie halt schon anfangs erwähnt darf ich es später nicht in AWl schreiben. Es ist nur Fup/KOp und SCl erlaubt. und wie ich en pointer mit Fup konstruieren soll habe ich keine ahnung


----------



## Larry Laffer (8 September 2008)

... das habe ich jetzt nun nicht verstanden ...


----------



## MatthiasH24 (8 September 2008)

ich wollte damit nur sagen das ich nur SCL programmieren darf. Weil du meintest das es eventuell nicht dafür geeignet ist.


----------



## Larry Laffer (8 September 2008)

Du kannst alles, was du in AWL hinbekommst auch irgendwie mit SCL machen ... manche Sachen sehen nur in SCL nicht so schön aus ... dafür dann aber andere umso schöner ...

Etwas anderes wollte ich nicht sagen ...


----------



## BoxHead (8 September 2008)

MatthiasH24 schrieb:


> ich wollte damit nur sagen das ich nur SCL programmieren darf. Weil du meintest das es eventuell nicht dafür geeignet ist.



Für diese Aufgabe ist SCL doch bestens geeignet.


----------



## MatthiasH24 (8 September 2008)

ja ich habe nie behauptet das es das dafür nicht geeignet ist. ich bekomme es nur im Mom nicht hin. leider! Aber ich gebe die hoffnung nicht auf.


----------



## Larry Laffer (8 September 2008)

MatthiasH24 schrieb:


> ja ich habe nie behauptet das es das dafür nicht geeignet ist. ich bekomme es nur im Mom nicht hin...


 
Wo hängst du denn gerade ...
Oder anders ... was ist das Problem ...?
Du must schon gezielt fragen ... nicht nach dem Motto "ich kriege es nicht hin - kann es vielleicht einer von euch gerade bauen ..."

Gruß
LL


----------



## MatthiasH24 (9 September 2008)

Es gibt da wäre man am liebsten gar nicht aufgestanden!

Ich muss nochmal zu meinem ursprünglichen problem zurück kommen.

Da es sich jetzt herausgestellt hat das man es nicht über eine for schleife machen kann wegen Zykluszeit.

jetzt soll ich es über eine if abfrage mache die auch die arrays einzel abfrägt. mal schauen was dabei raus komtm

hier mal der 1.te Versuch:


```
FUNCTION_BLOCK FB1
VAR_INPUT   
   Wert1 : ARRAY [1..32] OF BOOL;
   Wert2 : ARRAY [1..32] OF BOOL;
    F2 : BOOL;
END_VAR
VAR_OUTPUT
    erg: BOOL;
    Berechnung: BOOL;
END_VAR
VAR
 edge : BOOL := 0;
 ix : INT;
 FP: BOOL;
END_VAR
BEGIN

  FP := NOT(F2) AND Edge;       //F_Trig Funktion   
  edge := F2;                   //F_Tric Funktion

IF FP THEN
    IF wert1[ix] <> wert2[ix] then 
       ix := ix +1;
       erg := TRUE;
    ELSE
        erg := FALSE;
    END_IF;
END_IF;
END_FUNCTION_BLOCK
```


----------



## Larry Laffer (9 September 2008)

und ... sollte doch funktionieren ... oder nicht ?

Wo bekommst du ein Problem mit der Zykluszeit ? Wenn du eine FOR..TO-Schleife über 32 Elemente laufen läßt ganz sicher nicht ...

Willst du nur Bit-Array's mit 32 Elementen überprüfen ?
Wenn ja, dann könntest du dir die Sache auch noch einfacher machen ...

```
FUNCTION_BLOCK FB1
VAR_INPUT   
   Wert1 : ARRAY [1..32] OF BOOL;
      dw_Wert1 at Wert1 : dword ;
   Wert2 : ARRAY [1..32] OF BOOL;
      dw_Wert2 at Wert2 : dword ;
    F2 : BOOL;
END_VAR
VAR_OUTPUT
    erg: BOOL;
    Berechnung: BOOL;
END_VAR
VAR
 edge : BOOL := 0;
 ix : INT;
 FP: BOOL;
END_VAR
BEGIN
 
IF F2 and not Edge THEN
    dw_wert1 <> dw_wert2 then 
       erg := TRUE;
    ELSE
        erg := FALSE;
    END_IF;
END_IF;
edge := F2;                   //F_Tric Funktion
 
END_FUNCTION_BLOCK
```


----------



## vierlagig (9 September 2008)

bei der if-variante ist aber zu beachten, dass der ganze vorgang im schlimmsten fall 32*zykluszeit dauert.
ich stimme larry zu, bei 32*for-schleifen-durchlauf sollte es kein problem geben.

@larry: die guten tricks holst du immer erst zum schluß raus


----------



## Larry Laffer (9 September 2008)

vierlagig schrieb:


> @larry: die guten tricks holst du immer erst zum schluß raus


 
@4L:
Danke für die Blumen ... aber die guten Tricks fallen mir meisstens dann ein, wenn ich schon mal ein bißchen was zu sehen bekomme ...


----------



## vierlagig (9 September 2008)

Larry Laffer schrieb:


> @4L:
> Danke für die Blumen ... aber die guten Tricks fallen mir meisstens dann ein, wenn ich schon mal ein bißchen was zu sehen bekomme ...



das kenn ich, auch vom selber proggen ... da bauste sone schleife und dann hier // und da // und dann da ein POP und wieder was gespart ... da kann man nächtelang da sitzen ...


----------



## MatthiasH24 (9 September 2008)

Ja ich will núr Arrays vergleichen die max 32 groß sind aber von unterschiedlichem datentypen ( also klar es wird immer der selben typ miteinander verglichen).

Problem wegen der zykluszeit ist die große Anzahl der Variablen die noch hinzu kommt.


----------



## vierlagig (9 September 2008)

was für eine cpu kommt zum einsatz?


----------



## Larry Laffer (9 September 2008)

... da gäbe es dann die Möglichkeit :
- die Auswertung auf mehrere Zyklen zu verteilen
- den Code der Auswertung zu optimieren
- die Zyklus-Überwachungszeit hochzusetzen.

Was für dich das Beste ist, wäre sicher noch zu untersuchen.


----------



## MatthiasH24 (9 September 2008)

Eine 400er was genau für en typ weiß ich noch nicht

Aber ob ich ne For schleife nehmen soll oder nicht ist eigentlich gar keine Debatte mein Chef sgat nein also...


----------



## vierlagig (9 September 2008)

MatthiasH24 schrieb:


> Eine 400er was genau für en typ weiß ich noch nicht



die lacht sich kaputt!


----------



## Larry Laffer (9 September 2008)

vierlagig schrieb:


> die lacht sich kaputt!


 
was *4L* damit sagen wollte :
die "irgendeine 400er" ist so leistungsstark, dass sie sich auch an 10 FOR..TO-Schleifen 1..32 nicht groß stören würde. Ich vermute mal, dass die Zykluszeit nicht mal um 1 ms ansteuigen würde ...

Ich persönlich hätte ein Problem damit eine Auswertung über ettliche Zyklen zu verteilen ... Aber das ist ja nun Gott-sei-Dank nicht meine Baustelle ...


----------



## Ralle (9 September 2008)

Larry Laffer schrieb:


> was *4L* damit sagen wollte :
> die "irgendeine 400er" ist so leistungsstark, dass sie sich auch an 10 FOR..TO-Schleifen 1..32 nicht groß stören würde. Ich vermute mal, dass die Zykluszeit nicht mal um 1 ms ansteuigen würde ...
> 
> Ich persönlich hätte ein Problem damit eine Auswertung über ettliche Zyklen zu verteilen ... Aber das ist ja nun Gott-sei-Dank nicht meine Baustelle ...



Wer weiß, was die noch mit der SPS machen, außerdem hat der Chef immer recht, oder? 

If...then ist doch ok. Dauert dann halt 32 Zyklen bis man einen Unterschied mitbekommt.


----------

