# Positionen speichern



## Nordischerjung (9 Oktober 2008)

Moin zusammen,

ich hab hier ein Gebäckformer mit einer Walze. Auf dieser Walze 
sind Schaltnocken angebracht, die mit einem Ini erkannt werden 
und anschließend ein Verrigelungszylinder in eine Nut fährt um den Stempel mit zunehmen. 
Jetzt ist das Problem, wenn die Walze zu langsam dreht, 
fährt der Verriegelungszylinder manchmal schon vor der Nut aus.(Ist mechanisch nicht anders lösbar) 
Das ganze möchte der Kunde nun mit einem SSI Absolutwertgeber (Kübler Typ 8.5883) automatisieren. 
Ich will beim Maschinen Neustart die Walze einmal 360 Grad abfahren und bei
jeder Flanke des Inis die Position speichern.
Aber wie mache ich das speichern, wenn die Walze sich verändert (mehr oder weniger Positionen)? 
Ich weiß nicht wieviele Positionen ich speichern soll? Kann man das variabel machen? 
Wie löses ich am besten das speichern?
Für jede Position ein Merker setzen? Was ist wenn die eine Walze 10 Positionen hat und die andere 40?
Es sollte schon variabel sein, ohne dieses über das TP eingeben zu müssen. 
Das einzige was man am TP eingibt ist, ob die Walze sich verändert hat (nach Not-Aus oder Neustart)

Vielen Dank schon mal

Schöne Grüße von der Ostsee

Nordischerjung


----------



## vierlagig (9 Oktober 2008)

leg einen datenbaustein mit maximaler länge an, das sollte zum speichern der positionen reichen, außer da werden krümel gebacken 

zusätzlich zum speichern der positionen, diese zählen und an den anfang des DBs setzen


----------



## mitchih (9 Oktober 2008)

Also ich würde dann einen Positions DB anlegen mit z.B. 360 Positionen
Ich denke ein Array wäre hier ideal.

Dann würde ich über einen Schleifenzähler die Positionen jeweils in einem DB ablegen.

Nach dem Durchlauf des Messzyklus setzt du die verbliebenen Positionen auf null. Hat die Walze 40 Positionen löscht du dann ab 41-360
Dann hast du die Positionen in deinem DB und kannst damit arbeiten.

Wäre jetzt das was mir so auf anhieb einfällt
Oder habe ich das falsch verstanden


----------



## Nordischerjung (9 Oktober 2008)

vierlagig schrieb:


> leg einen datenbaustein mit maximaler länge an, das sollte zum speichern der positionen reichen, außer da werden krümel gebacken
> 
> zusätzlich zum speichern der positionen, diese zählen und an den anfang des DBs setzen



   verstehe ich dich nicht, oder ist dein Satz nicht vollständig?

Was soll ich an den Anfang setzen?



mitchih schrieb:


> Also ich würde dann einen Positions DB anlegen mit z.B. 360 Positionen
> Ich denke ein Array wäre hier ideal.
> 
> Dann würde ich über einen Schleifenzähler die Positionen jeweils in einem DB ablegen.
> ...


Und wie mache ich das mit dem ANY? Muss das mit einem Pointer gemacht werden? (Das schreiben und lesen) Wie lösche ich den rest?
Habe dieses noch nie gemacht


----------



## vierlagig (9 Oktober 2008)

Nordischerjung schrieb:


> verstehe ich dich nicht, oder ist dein Satz nicht vollständig?
> 
> Was soll ich an den Anfang setzen?



die anzahl der positionen


----------



## Gerri (9 Oktober 2008)

wenn du das erste mal die 360 grad exakt fährst dann nimm das mit einem Zähler auf und speichere den Wert Dezimal in einem DB.
Im Betrieb zählst du die Impulse (Aktualwert) und weißt so wo die Walze sich befindet. Wenn Impulse (Aktualwert) >= DB Wert sind dann setze Impulse wieder zurück.
Falls ichs nicht falsch verstanden habe


----------



## Larry Laffer (9 Oktober 2008)

... da hast du dir ja etwas vorgenommen ...

Wichtig bei dieser Aufgabe ist. strukturiert vorzugehen. Erstmal mußt du wissen, wann du einmal rum bist. Dann mußt du einen Start-Punkt (Referenzpunkt) für die Initialisierungsfahrt haben.

Dein Programm muß (nach meiner Meinung) also so aussehen :
Deinen Datenbaustein komplett löschen.
Fahre Walze bis zur steigenden Flanke des Referenzpunktes.
Dort Istposition einlesen und weiterfahren.
Bei jedem nun kommenden Nocken den Nockenzähler um 1 erhöhen und diesen zur Adressierung der DBD's (für die Positionen im DB) verwenden und dort die aktuelle Position abspeichern.
Das Ganze so lange wiederholen, bis du wieder den Referenzpunkt erkennst. Nun die Endposition einlesen und die Initialfahrt beenden.

Nun hast du einen DB mit den Angaben, die du benötigst.
Der DB muß natürlich (wie schon vorher geschrieben) so groß sein, dass die maximale Anzahl von vorkommenden Werten gespeichert werden kann.

Ich würde das Ganze übrigens nicht mit einem Absolutwertgeber sondern mit einem Inkrementalgeber aufziehen. Absolutwertgeber macht nur dann Sinn, wenn eine Umdrehung des Gebers immer genau einer Umdrehung der Walze entspricht. Ist das anders (Geber nicht direkt auf der Welle) dann hast du nur unnötig Probleme.

Als nächstes brauchst dann nun eine Routine, die die ständig nachsieht, ob du im Bereich eines der gespeicherten Nocken bist um die entsprechende Reaktion auszulösen.

Ich würde dir empfehlen, diese Aufgabe mittels SCL zu lösen ... das macht vieles einfacher ...

Gruß
LL


----------



## Nordischerjung (9 Oktober 2008)

Larry Laffer schrieb:
			
		

> Ich würde das Ganze übrigens nicht mit einem Absolutwertgeber sondern mit einem Inkrementalgeber aufziehen. Absolutwertgeber macht nur dann Sinn, wenn eine Umdrehung des Gebers immer genau einer Umdrehung der Walze entspricht. Ist das anders (Geber nicht direkt auf der Welle) dann hast du nur unnötig Probleme.


1. Absolutwertgeber kommt vom Kunden.
2. Der Geber sitz genau auf der Welle der Walze, somit 1:1 



			
				Larry Laffer schrieb:
			
		

> Ich würde dir empfehlen, diese Aufgabe mittels SCL zu lösen ... das macht vieles einfacher ...


Hab ich leider noch nicht so die Erfahrung und Ahnung. (Ausser Boschsteuerung ins SCL) Und das war nicht so aufwendig.

Habe aber heute noch erfahren, dass 16 Positionen das absolute Maximum sind. Was die Sache etwas einfacher macht.

Wie kann man es denn einfach lösen?

Kann es so in etwa funktionieren oder geht es einfacher?



```
U #Ini       //Initiator in Position
FP #HM    //Hilfsmerker Flanke
= #Flankenmerker

U  #Flankenmerker
UN #POS1    //Merker Position 1 gespeichert
SPBN POS1

L #IST_POS    //Aktuelle Position
T DB1.POS1   //DB1.DBW0

SET
S #POS1

POS1: NOP 1

U  #Flankenmerker
U #POS1
UN #POS2    //Merker Position 2 gespeichert
SPBN POS2

L #IST_POS    //Aktuelle Position
T DB1.POS2   //DB1.DBW2

SET
S #POS2

POS2: NOP 1
```

usw, usf


----------



## Larry Laffer (10 Oktober 2008)

... so wie du es dargestellt hast, läßt es sich auf jeden Fall machen ...
Ich würde aber mit einer Schleife arbeiten.
Begründung :
Für das Ablegen der Werte würdest du dir mit einer Schleife "nur" Code einsparen.
Es kommt aber dann später noch eine Routine, in der du nachschauen mußt, ob du dich im Bereich einer der gespeicherten Positionen befindest. Das geht am einfachsten in dem du die Liste der Positionen "scannst" und nachsiehst, ob eine davon zu deiner Ist-Position paßt ...

Grundsätzliches Wissen zur Schleifen-Programmierung findest du in der Rubrik FAQ vom Forum ...

Gruß
LL


----------



## Nordischerjung (10 Oktober 2008)

Danke erstmal,
zu schleifen habe ich irgendwie nichts gefunden,
was mich weiter bringen könnte. 

Noch zusätzlich eine Frage, wie kann ich einfach alle
Werte eines DB auf den gleichen Wert setzen? 
Oder muss ich 

```
L 0
T DB1.DBD0 
T DB1.DBD4
T DB1.DBD8
... usw
```


----------



## MSB (10 Oktober 2008)

Nordischerjung schrieb:


> Danke erstmal,
> zu schleifen habe ich irgendwie nichts gefunden,
> was mich weiter bringen könnte.
> 
> ...



Das geht mit einem SFC, glaube 21, der nennt sich "Fill"

Mfg
Manuel


----------



## Larry Laffer (10 Oktober 2008)

Nordischerjung schrieb:


> zu schleifen habe ich irgendwie nichts gefunden, was mich weiter bringen könnte.


 
Dann schau doch mal hier
Der Beitrag ist m.E. Klasse und sollte dir schon weiterhelfen können ...

Du mußt das ja auch nicht zwingend so machen - ich bin nur der Meinung, dass es dir letztlich ein paar Probleme erspart ...

Gruß
LL


----------



## funkdoc (10 Oktober 2008)

hallo

soweit ich dein problem verstanden habe, suchst du nach einer lösung, wo der mitnehmer während drehender walze in die nut der walze geschoben wird, wobei der ausgangspunkt der form relativ ist. 
beim ausklinken der form muss die aktuelle position in einen DB satz geschrieben werden.
beim wieder einklinken wird die form erst mitgenommen, wenn sich die nut (absoluter Istwert) auf gleiche position des mitnehmers befindet (DB-Sollwert).

ist dies wegen verzögerungszeiten von aktoren wie zylinder etc... nicht möglich, ist das eine lineare berechnung von Geschwindigkeit der Walze und der zeit, die der mitnehmer früher ausfahren soll, um die nut rechtzeitig zu erwischen. dafür benötigst du auch nur zwei werte und zwar bei maximaler geschwindikeit und minimaler.

selbstverständlich sollte auch eine ausgangsstellung der form initiert werden, um nach zb technischem gebrechen alles wieder in grundstellung fahren zu können.

grüsse


----------



## Nordischerjung (10 Oktober 2008)

Larry Laffer schrieb:


> Dann schau doch mal hier
> Der Beitrag ist m.E. Klasse und sollte dir schon weiterhelfen können ...



Dann schau ich mal ob ich das so hin bekomme. Ich möchte ja auch gerne etwas lernen 

Habe es mit meiner Version schon so weit, dass die Werte gespeichert und übergeben werden.

Grüße von der Ostsee


----------



## Nordischerjung (10 Oktober 2008)

funkdoc schrieb:


> hallo
> ist dies wegen verzögerungszeiten von aktoren wie zylinder etc... nicht möglich, ist das eine lineare berechnung von Geschwindigkeit der Walze und der zeit, die der mitnehmer früher ausfahren soll, um die nut rechtzeitig zu erwischen. dafür benötigst du auch nur zwei werte und zwar bei maximaler geschwindikeit und minimaler.


 

Nicht ganz so, der Verriegelungszylinder fuhr immer auf den Punkt zwischen
den Nuten und rutschte dann etwas später erst in die Nut,
wenn die Walze zu langsam drehte.
Um den ganzen Kram mit Verzögerungszeiten /was auch schon bedingt eingesetzt wurde) usw. zu umgehen, soll
halt ein Drehgeber eingesetzt werden.


----------



## Larry Laffer (10 Oktober 2008)

Nordischerjung schrieb:


> Nicht ganz so, der Verriegelungszylinder fuhr immer auf den Punkt zwischen
> den Nuten und rutschte dann etwas später erst in die Nut,
> wenn die Walze zu langsam drehte.
> Um den ganzen Kram mit Verzögerungszeiten /was auch schon bedingt eingesetzt wurde) usw. zu umgehen, soll
> halt ein Drehgeber eingesetzt werden.


 
Damit bist da ja auch auf dem rictigen Weg ...
Wenn du weißt, wie schnell die Trommel dreht und wie lange der Zylinder braucht dann kannst du auf diesem Weg den Start-Zeitpunkt für den Zylinder ganz gut vorherbestimmen und an einer Position festmachen ...

Gruß
LL


----------



## funkdoc (10 Oktober 2008)

> Um den ganzen Kram mit Verzögerungszeiten /was auch schon bedingt eingesetzt wurde) usw. zu umgehen, soll
> halt ein Drehgeber eingesetzt werden.


naja, ein drehgeber bringt hier nicht viel, der initiiert ja nur schritte.
soweit ich weiss gibt ein absolutwertgeber die tatsächlichen grade/schritte an, in die sich ein punkt am umfang gerade befindet. anders ausgedrückt mit einem drehgeber bekommst du signale, mit einem absolutwertgeber bekommst du werte, die auch nach anlage ein wieder sofort zur verfügung stehen ohne dass diese vorher zwischengespeichert wurden.

du formierst dir die werte (istwert,sollwert) in ein zb Doppelinteger (glaub müsste ausreichen) und prüfst dann auf gleichheit, wenn bedingung erfüllt, dann mitnehmer-zylinder ausfahren.

ich weiss, so optimierungen an alten anlagen können oft auf die nerven gehen.

grüsse


----------



## Nordischerjung (10 Oktober 2008)

funkdoc schrieb:


> naja, ein drehgeber bringt hier nicht viel, der initiiert ja nur schritte.
> soweit ich weiss gibt ein absolutwertgeber die tatsächlichen grade/schritte an, in die sich ein punkt am umfang gerade befindet. anders ausgedrückt mit einem drehgeber bekommst du signale, mit einem absolutwertgeber bekommst du werte, die auch nach anlage ein wieder sofort zur verfügung stehen ohne dass diese vorher zwischengespeichert wurden.



Ist ein Absolutwertgeber, hatte ich oben schon beschrieben 

Danke für eure Hilfe, werde mich melden falls ich nicht weiter komme

Grüße von der sonnigen Ostsee

Nordischerjung


----------



## Nordischerjung (23 Oktober 2008)

Moin moin,

ich stecke wieder bei meiner Anlage fest. Programm lief, Kunde kommt mit neuen Ideen und Änderungen usw.  Und Sachen die man vorher so nicht gesehen hatte.

Wie kann ich am einfachsten den Absolutwertgeber auswerten in dem ich in einem DINT immer 0 -4096 zähle? Der Geber macht 4096 Impulse pro Umdrehung, und die möchte ich immer bei jeder Runde von neuem starten, aber den Geber weiter zählen lassen. 
Z.B Geber steht bei 456723 und ich möchte mein internen Zähler jetzt auf null setzen und ihn dann immer jeder Umdrehung von 0-4096 zählen lassen.

Sonnige Grüße von der Ostsee

Nordischerjung


----------



## peter(R) (23 Oktober 2008)

Warum habt ihr eigentlich einen multiturn Geber genommen ????
Macht doch keinen Sinn wenn man einzelne Umdrehungen erfassen will

Ansonsten kannst Du den Geberausgang genau wie einen Analogwert behandeln und skalieren. Z.B.  Null ist 0.0 und 32676 ist 10.0 wenn dein Geber bei 10 Umdrehungen 32676 anzeigt. Allerdings hast du dann eine dezimale skalierung ( x,5 wäre x+1/2 Umdrehung.



peter(R)


----------



## Steff_F (23 Oktober 2008)

```
L     0
      LAR1                              // Pointer initialisieren
      AUF   DB     3                    // Nummer des zu beschreibenden DB

      L     16                          // Anzahl der DW im DB
next: T     #Schleifenzaehler           // Schleifenzähler initialisieren

      L     0
      T     DBD [AR1,P#0.0]             // 0 in das DW schreiben auf das der Pointer zeigt
      +AR1  P#4.0                       // Poiner um 4 Byte (1DW) erhöhen

      L     #Schleifenzaehler
      LOOP  next
```

oder so


----------



## Steff_F (23 Oktober 2008)

Hab da wohl ne Seite übersprungen beim lesen


----------



## Nordischerjung (23 Oktober 2008)

peter(R) schrieb:


> Warum habt ihr eigentlich einen multiturn Geber genommen ????
> Macht doch keinen Sinn wenn man einzelne Umdrehungen erfassen will



Tja, das hab ich mir nicht ausgesucht. Den benutzen die immer *ROFL*



peter(R) schrieb:


> Ansonsten kannst Du den Geberausgang genau wie einen Analogwert behandeln und skalieren. Z.B. Null ist 0.0 und 32676 ist 10.0 wenn dein Geber bei 10 Umdrehungen 32676 anzeigt. Allerdings hast du dann eine dezimale skalierung ( x,5 wäre x+1/2 Umdrehung.


Wird das nich zu ungenau? Der Geber macht 4096 Umdrehungen und 
pro U 4096 Impulse, oder nicht???


----------



## Larry Laffer (23 Oktober 2008)

... hatte ich dir nicht einen Inkrementalgeber empfohlen ...?

Spaß beiseite ...
Die einzige Chance, die ich da sehe ist, dass du dir einen "Berechne_Position-FB" baust.
Grundsätzlich kannst du den Befehl MOD (Modulo) verwenden um dafür zu sorgen, dass du keine Werte oberhalb von 4096 bekommst. Das Problem ist nur, dass auch dein Multiturn-Geber irgendwann einmal überläuft und dann wahrscheinlich so, dass es nicht in dein bisheriges Modulo passt.

Gruß
LL


----------



## Ralle (23 Oktober 2008)

Probier es mal so:


```
FUNCTION_BLOCK FB 100
TITLE =
VERSION : 0.1


VAR_INPUT
  Istwert : DINT ;	
  Set : BOOL ;	
END_VAR
VAR_OUTPUT
  Istwert_Scale : DINT ;	
END_VAR
VAR
  Offset : DINT ;	
  HMFlanke_Set : BOOL ;	
END_VAR
BEGIN
NETWORK
TITLE =

      U     #Set; 
      FP    #HMFlanke_Set; 
      SPBN  NIX; 

      L     #Istwert; 
      T     #Offset; 
NIX:  NOP   0; 

      L     #Istwert; 
      L     #Offset; 
      -D    ; 
      L     L#4096; 
      MOD   ; 
      L     L#0; 
      TAK   ; 
      <=D   ; 
      SPB   ENDE; 

      L     4096; 
      +D    ; 
ENDE: T     #Istwert_Scale; 
END_FUNCTION_BLOCK
```

Der geht dann von 0-4095, bei 4096 springt er wieder auf 0. Wenn das so nicht sein soll, sondern 1-4096, dann am Ende noch 1 drauf rechnen.


----------



## peter(R) (23 Oktober 2008)

@ larry Laffer
Und wieso nicht singleturn ??? Hüpft nach einer Umdrehung auf Null und ich brauche nie zu referenzieren.

0  -> 4096 auf 360°  macht einen Schritt auf 0,08789 ° das ist fast nix. Ausser deine Walze hat einen sehr großen Durchmesser. Wie groß ist denn der Umfang ??

peter(R)


----------



## Nordischerjung (23 Oktober 2008)

peter(R) schrieb:


> Wie groß ist denn der Umfang ??



Irgendetwas bei 630 mm



peter(R) schrieb:


> Und wieso nicht singleturn ???



Kann ich so etwas am Geber auch einstellen? 
In der HW geht das ja über die Baugruppe, aber Geber???
Es ist ein Kübler Absolut Drehgeber Multiturn SSI 5863
Auflösung 13 bit ST + 12 bit MT.
Oder muss ich einfach nicht PED einlesen sondern nur ein PEW? 
Der Geber liegt bei mit bei PED 264


----------



## peter(R) (23 Oktober 2008)

Theoretisch schon aber dann liegt deine Auflösung bei > 1 ° . Wie gesagt hängt auch vom Durchmesser ( bzw. evtl. der Wegstrecke je Umdrehung )ab.

1° bei einem Durchmesser von 20 mm ist als Weg fast nix. Bei einem Durchmesser von 2 m eine ganze Menge.

Es gibt programmierbare Geber aber deiner ist leider keiner.

peter(R)


----------



## peter(R) (23 Oktober 2008)

Bei der Geberauflösung von 256 / Umdrehung hättest du damit eine Wegauflösung von ca. 7,7 mm. DAS IST VERDAMMT VIEL !!
Bei dem was Du machen willst solltest du schon unter 1 mm liegen.

peter(R)


----------



## Nordischerjung (23 Oktober 2008)

Larry Laffer schrieb:


> Das Problem ist nur, dass auch dein Multiturn-Geber irgendwann einmal überläuft und dann wahrscheinlich so, dass es nicht in dein bisheriges Modulo passt.



Und was kann man dagegen machen?



Larry Laffer schrieb:


> Grundsätzlich kannst du den Befehl MOD (Modulo) verwenden um dafür zu sorgen, dass du keine Werte oberhalb von 4096 bekommst.



Ich werde das Prog mal von Ralle ausprobieren. 
Wo finde ich etwas über MOD?


----------



## peter(R) (23 Oktober 2008)

Bei der 4096 er Version liegst Du bei 0,48 mm das sieht schon besser aus.
Ralles Programm sieht dafür sehr gut aus. Sein MOD Befehl setzt ja direkt auf der Auflösunfg des Gebers auf. Dann stimmts am Schluss auch wieder.

peter(R)


----------



## Nordischerjung (23 Oktober 2008)

peter(R) schrieb:


> Bei der Geberauflösung von 256 / Umdrehung hättest du damit eine Wegauflösung von ca. 7,7 mm. DAS IST VERDAMMT VIEL !!
> Bei dem was Du machen willst solltest du schon unter 1 mm liegen.



Also 1-2 mm wären nicht schlimm, da die Nuten groß genug sind, 
aber 7,7 mm sind dann doch zu viel. So wie es jetzt ist, passt es ganz gut.
Ich muss es nur noch hinbekommen 
Danke schon mal für eure tolle Hilfe


----------



## Ralle (23 Oktober 2008)

Nordischerjung schrieb:


> Wo finde ich etwas über MOD?



Im Bausteineditor in AWL in einer Zeile MOD eingeben , Maus drauf und F1 drücken.


----------



## Nordischerjung (23 Oktober 2008)

Habe leider nur WinPLC7 von Vipa zur Zeit.

Bekomme nächsten Monat Step7.

Ob dann alles besser wird, weiß ich auch nicht


----------



## peter(R) (23 Oktober 2008)

Dann schau mal hier

http://support.automation.siemens.c...tion=cssearch&searchinprim=&nodeid99=&x=0&y=0

peter(R)


----------



## Nordischerjung (23 Oktober 2008)

Habe es doch noch bei mir in der WinPLC7 Hilfe gefunden 

Kann mir mal kurz jeamand diesen Abschnitt erklären?


```
L     #Istwert;//Ist Klar
      L     #Offset; //Ist KLar
      -D    ; 
      L     L#4096; 
      MOD   ;        //Warum?
      L     L#0;     //Warum?
      TAK   ;        //Was passiert hier?
      <=D   ;
      SPB   ENDE;       
      L     4096;   // Warum?
      +D    ; 
ENDE: T     #Istwert_Scale;
```

Danke


----------



## peter(R) (23 Oktober 2008)

MOD bildet den Divisionsrest der vorhergehenden Ladebefehle

TAK tauscht Akku 1 und Akku 2

peter(R)


----------



## Nordischerjung (23 Oktober 2008)

So weit habe ich das verstanden, aber rein von den Zahlen her,
was steht wann in Akku 1 und 2 und warum tauschen?
Ich stehe irgendwie auf dem Schlauch


----------



## Ralle (23 Oktober 2008)

Das ist Faulheit von mir.

MOD  ;        //bildet den Divisionsrest, dieser steht dann in Akku 1
L     L#0;     //lädt 0 in Akku 1, was vorher in Akku 1 war, wird dabei automatisch in Akku 2 geschoben
TAK   ;        //Tauscht Akku 1 mit Akku 2, also steht nun der Divisionsrest in Akku 1 und die 0 in Akku 2
<=D   ;       //Vergleich
SPB   ENDE; //wenn der Divisionsrest >= 0 (genauer, wenn 0 <= Divisionsrest) dann Sprung zum Ende. Dabei steht der Divisionsrest in Akku1 und kann so bei der Marke ENDE  sofort in #Istwert_Scale gespeichert werden    
L     4096;   // Wenn der Divisonsrest negativ ist, dann muß man ihn positiv machen, indem man eine Umdrehung dazu addiert, ohne TAK hätte ich den Divisionsrest oben zwischenspeichern und hier wieder laden müssen, mit TAK steht er ja aber schon in Akku1 bereit!
+D    ; 
ENDE: T     #Istwert_Scale;

Noch zur Erklärung. Der Divisionsrest ist natürlich nur negativ, wenn schon das Ergebnis von Istwert - Offsett negativ war, also falls der Geber mal ein Stück rückwärts läuft. 

Nehmen wir an, der Offset war 7000
7001 ergibt einen Output von 1
6999 ergibt -1, was aber eigentlich Unsinn ist
also -1 + 4096 = 4095
so muß das ja auch sein, wenn man den Geber vor den Offset zurückdreht.


----------



## HaDi (23 Oktober 2008)

Das Tauschen kannst du auch weglassen, wenn du im nächsten Schritt das <=D durch >D ersetzt. Es geht ja nur darum, dass durch den Offset ein negativer Wert herauskommen kann und für diesen Fall dann wieder 4096 drauf addiert werden muss.
Der MOD-Befehl macht ja im Grunde genommen aus deinem Multiturn einen Singleturn-Geber.

Grüße von HaDi

[edit]
mal wieder zu langsam...
[/edit]


----------



## Ralle (23 Oktober 2008)

HaDi schrieb:


> Das Tauschen kannst du auch weglassen, wenn du im nächsten Schritt das <=D durch >D ersetzt. Es geht ja nur darum, dass durch den Offset ein negativer Wert herauskommen kann und für diesen Fall dann wieder 4096 drauf addiert werden muss.
> Der MOD-Befehl macht ja im Grunde genommen aus deinem Multiturn einen Singleturn-Geber.
> 
> Grüße von HaDi
> ...



Nicht ganz, er muß dann (wenn er TAK wegläßt) auch den Divisionsrest zwischenspeichern, um damit weiterrechnen zu können und das Ergebnis in den Output zu bekommen. Aber das hab ich ja schon geschrieben .


----------



## Nordischerjung (23 Oktober 2008)

@Ralle
Vielen Dank, das ist mal ne toll Erklärung.
Das habe selbst ich verstanden. 
Dein kleines aber eigentlich simples Netzwerk hilf mir sehr weiter.
Funktioniert das denn auch wenn der Geber überläuft, 
sprich wieder bei null anfängt? Zählt #Istwert_Scale dann weiter oder?


----------



## Ralle (23 Oktober 2008)

@Nordischerjung

Ehrlich, darüber hab ich noch gar nicht nachgedacht, da ich ja nur mit irgendwelchen Werten getestet habe. Aber wenn der Überlauf genau im Modulo von 4096 liegt (wovon ich mal ausgehe) könnte das funktionieren. Die Frage ist ja auch, ob nicht vorher die DINT überläuft. wieviel Bit hatte nochmal der Geber, also wo läuft er über?


----------



## Nordischerjung (23 Oktober 2008)

25 Bit, er läuft bei 16777216 über so viel ich weiß


----------



## Ralle (23 Oktober 2008)

Nordischerjung schrieb:


> 25 Bit, er läuft bei 16777216 über so viel ich weiß



Dann geht es, das liegt im Modul von 4096, ist also ein Vielfaches davon.

4096 * 4096 = 16777216

Kannst das mit dem FB leicht ausprobieren. Scheibe an den Input ein MD
dort hinein 16777210, dann Set setzen. Danach den Wert schrittweise erhöhen und dann bei 16777216 eine 0 rein, Ergebnis beobachten, das funzt.


----------



## Nordischerjung (23 Oktober 2008)

Ja super, hab das gleich nach meiner Frage ausprobiert,
funktioniert super. Vielen Dank nochmal :TOOL:


Sonnige Grüße von der Ostsee


----------

