# Drehzahlmessung



## stift (6 Februar 2008)

Hallo, 
ich komme gerade nicht weiter. 
ich möchte eine drehzahlmessung programmieren. 
an meiner welle sitzt ein punkt den ich mittels bero abfragen kann. 
Wie kann ich denn am besten die drehzahl errechnen. 
ich hab mir gedacht ich nehme einen zeitraum von z.b. 10s und zähle dann wie oft mir mein bero signal gibt. 
dummerweise muss ich die timer allerdings mit dem signal das der motor ein ist starten. dies ist allerdings dauersignal und desshalb läuft der zyklus nur einmal durch da ich ja eine positive taktflanke an meinem zeitglied brauche. kann mir jemand helfen?


----------



## kpeter (6 Februar 2008)

wie oft kommt denn dein bero

bzw anders gefragt wie schnell dreht sich dein motor


----------



## stift (6 Februar 2008)

Ich schätz mal so 100-200 u/min


----------



## Ralle (6 Februar 2008)

Du startest z.Bsp. einen SE-Timer. Wenn der Timer die 10 Sek. erreicht hat, geht sein Ausgang auf Signal True. Daraus erzeugst du eine Flanke. Mit dieser Flanke springst du einerseits in einen kleinen Programmabschnitt, der dir die Drehzahl berechnet, ausgibt und den Zähler wieder auf Null stellt. Außerdem baust du die Flanke als UN in deine Timerstartbedingung mit ein, so daß der Timer wieder einen Start bekommt.



```
U     E      0.0                  //BERO
      FP    M      1.0                  //HM Zählflanke BERO
      SPBN  NZAE                        //wenn keine Flanke, dann nicht zählen

      L     MD    10                    //wenn Flanke, dann zählen
      L     1
      +D    
      T     MD    10

NZAE: U     M      0.0                  //Motor EIN
      UN    M      1.3                  //Flankenmerker
      L     S5T#10S
      SE    T      1
      U     T      1
      FP    M      1.2                  //Hilfsmerker Flanke
      =     M      1.3                  //Flankenmerker

      U     M      1.3
      SPBN  M001

      L     MD    10                    //gezählte Impulse
      DTR   
      L     1.000000e+001               //10 Sekunden
      /R    
      T     MD    14                    //Impulse pro Sekunde

      L     0
      T     MD    10                    //wieder auf Null stellen

M001: NOP   0
```


----------



## stift (6 Februar 2008)

Alles klar. 
danke schön


----------



## kpeter (6 Februar 2008)

die frage ist wie genau du es messen musst wenn du 10 sek mist und die impulse zählst kommt es zu einer ungenauigkeit von ca +-0,3 umdrehungen bei max drehzahl bei min drehzahl +- 0,6 umdrehungen


----------



## jackjones (7 Februar 2008)

Ich hoffe du willst damit nicht positionieren!


----------



## stift (9 Februar 2008)

selbstverständlich nicht. 
nur die geschwindigkeit eines kolbens ermitteln. 
siehe thread "Rechenoperationen mit sich ändernden Variablen"
mfg
Stift


----------



## stift (1 April 2008)

Hi 
ich muss noch mal nachhaken, 
ich hab das problem dass mir die zeit bis zur auswertung (10s) zu groß ist. 
d.h. die nachregelzeit ist mir zu groß, da ich wenn ich meine drehzahl verändere erst nach 10s die neue drehzahl angezeigt bekomme. 
Wie würdet ihr vorgehen um eine schnelle auswertung zu erhalten. 
mein problem ist dass ich keinen drehzahlgeber anflanschen kann. Ich hatte auch überlegt ein zahnrad einzubauen und die taktung, wie oft die zähne kommen mit einem hall-sensor abzufragen, allerdings ist auch dafür kein platz. 
mein neuster ansatz ist dass ich die zeit stoppe für eine umdrehung. daraus errechne ich die drehzahl, die ich auf ein mw lege. 
ändert sich nun die zeit für eine umdrehung mehr wie +/- 10ms so soll die die neue drehzahl errechnet und auf das mw geschoben werden. Leider haperts mit der Umsetzung. 
Wie würdet ihr bei der programmierung vorgehen. 
Die zeit könnte ich ja im ob35 messen. Allerdings habe ich angst dass dieser zu groß wird.


----------



## zotos (1 April 2008)

Ich würde mit dem OB1_precycle arbeiten. Da steht die Zykluszeit des letzten Zyklus drin. Wenn Du einen Positiven Impuls vom Sensor bekommst Setzt Du eine INT Variable auf 0 und dann addierst in jedem Zyklus den OB1_precycle auf diese INT Variable auf. Somit hast Du die Dauer einer Umdrehung.


----------



## stift (1 April 2008)

wie erstelle ich denn diesen ob1_precycle und wo lege ich da die zykluszeit fest?


----------



## zotos (1 April 2008)

Der OB1_pre_cycle (bei der Schreibweise bin ich mir nicht sicher) ist eine Variable im OB1 schau mal oben in die Variablen Deklaration vom OB1.

Such mal hier im Forum und in der Step7 Hilfe nach diesem Begriff.

Edit: es ist wohl der OB1_prev_cycle


----------



## Falcon4 (2 April 2008)

Hallo
hast Du die Möglichkeit ein weiteres Bauteil einzubauen?
In der letzten Firma hatten wir einen Frequenz/Strom umsetzer verbaut der die Impulse in 0-20mA vor der SPS wandelt und dann skaliert eingelesen wurde die Istwerterfassung war recht flott und genau.
Ist nur eine Idee.


----------



## stift (3 April 2008)

Hatte ich mir auch schon überlegt. 
Mein problem ist nur dass ich oben auf die welle keinen umsetzer anbauen kann wegen platzproblemen. 
Ein Zahnrad dessen zähne ich mittels hall-sensor erfasse müsste eigentlich auch gehen, nur wäre es ein wahnsinniger aufwand das zahnrad zwischen motorwelle und die sekundärwelle einzubauen. Aus diesem grund muss ich die zeit stoppen bis mein bero einmal kommt. dann weiß ich dass ich eine halbe umdrehung zurückgelegt habe und kann es hochrechnen.


----------



## stift (3 April 2008)

hab folgenden thread gefunden, aber der hilft mir auch nicht wirklich weiter.
http://www.sps-forum.de/showthread.php?t=17739&highlight=ob1_prev_cycle://


----------



## Larry Laffer (3 April 2008)

Ich verstehe dein Problem an dieser Stelle nicht ...
Ich würde es so machen (im OB1) :

```
wenn nicht INI dann 
 
L OB1_Prev_Cycle
L Zwischenspeicher
+D
T Zwischenspeicher
 
wenn INI und nicht Flanke dann
Flanke bilden
 
L OB1_Prev_Cycle
L Zwischenspeicher
+D
T Zwischenspeicher
 
In Zwischenspeicher steht die Dauer für 1 Umdrehung
daraus Drehzahl berechnen
Zwischenspeicher löschen
```
 
Kannst du dir daraus selbst eine Routine bauen ...?


----------



## stift (3 April 2008)

Ich versteh nur nicht wo ich die zeit für eine umdrehung herbekommen. Was hat den dieser ob1_prev_cycle damit zu tun? Und was meinst du mit Flanke? Das Signal von meinem Bero?


----------



## Larry Laffer (3 April 2008)

OB1_Prev_Cycle ist die Dauer in ms, die der vorangegangene Programm-Zyklus gedauert hat. Diese Angabe erhälst du aus den TEMP-Variablen des OB1.
Du kannst dir natürlich auch eine Mess-Routine auf Basis der Systemzeit selber bauen. Das ist auch nicht viel schwieriger. Das mit der OB1-Zeit ist halt nur der einfachste Weg ... die ist schon da ...


----------



## stift (3 April 2008)

aber ich versteh nicht ganz was die programm-zykluszeit mit der zeit zu tun hat die meine pleuelwelle für eine umdrehung braucht


----------



## Larry Laffer (3 April 2008)

Na na na ...
Die SPS wird ja bei 200 Upm deiner Pleuel-Welle einige Zyklewn machen bevor deine Welle einmal rum ist. Das heißt, du addierst dann mehrere Zyklen auf und damit (einigermassen genau) die Dauer für eine Umdrehung (5 ms + 6 ms + 4 ms + 5 ms ... = 37 ms für einen Umlauf z.B.). Daraus / damit kannst du dir dann schon die Drehzahl errechnen. 
Aber nicht vergessen. Nach einem Umlauf Zeitwert verrechnen und resetten für nächste Messung ...


----------



## stift (3 April 2008)

Ich hab mal versucht deine obige empfehlung umzusetzten: 
	
	



```
[FONT=Arial]    UN    "Sensor-Drehzahl"[/FONT]
[FONT=Arial]     U     "Merker_Motor_Ein"[/FONT]
[FONT=Arial]     SPBN  M001[/FONT]
 
[FONT=Arial]     L     #OB1_PREV_CYCLE[/FONT]
[FONT=Arial]     L     #Zwischenspeicher[/FONT]
[FONT=Arial]     +I    [/FONT]
[FONT=Arial]     T     #Zwischenspeicher[/FONT]
 
 
 
[FONT=Arial]     U     "Sensor-Drehzahl"[/FONT]
[FONT=Arial]     U     "Merker_Motor_Ein"[/FONT]
[FONT=Arial]     U(    [/FONT]
[FONT=Arial]     U(    [/FONT]
[FONT=Arial]     O(    [/FONT]
[FONT=Arial]     U     "Sensor-Drehzahl"[/FONT]
[FONT=Arial]     BLD   100[/FONT]
[FONT=Arial]     FP    M     25.3[/FONT]
[FONT=Arial]     )     [/FONT]
[FONT=Arial]     O(    [/FONT]
[FONT=Arial]     U     "Sensor-Drehzahl"[/FONT]
[FONT=Arial]BLD   100[/FONT]
[FONT=Arial]     FN    M     25.3[/FONT]
[FONT=Arial]     )     [/FONT]
[FONT=Arial]     )     [/FONT]
[FONT=Arial]     NOT   [/FONT]
[FONT=Arial]     )     [/FONT]
 
[FONT=Arial]     SPBN  M001[/FONT]
 
[FONT=Arial]L     #Zwischenspeicher[/FONT]
[FONT=Arial]     T     "DB_V-Messung".Zeit_fuer_Umdrehung_OB1[/FONT]
 
 
 
[FONT=Arial]M001: NOP   0[/FONT]
```
 
Ich versteh aber nicht ganz warum du folgendes programmieren würdest:





> wenn INI und nicht Flanke dann
> Flanke bilden
> 
> L OB1_Prev_Cycle
> ...


----------



## Larry Laffer (3 April 2008)

... du must doch dem Ding sagen, wann ein Umlauf rum ist und du die Zeit zur Drehzahlmessung verwerten möchtest. Das wäre nach meinem Vorschlag mit der pos. Flanke des INI's. Danach misst du dann einfach den nächsten Umlauf ... usw.

Was du da in dem Netztwerk mit dem BLD-Befehl veranstaltet hast verstehe ich nun nicht so ganz ...


----------



## stift (3 April 2008)

Ja ich hab selber schon gemerkt dass das recht schwachsinnig ist. Ich hab in fup irgendwas zusammengebastelt, dann in awl umgewandelt und in awl weiterprogrammiert da ich nicht wusste wie man einen flankensprung in awl programmiert. 
Da ist das BLD wohl irgendwie reingeraten.


----------



## Larry Laffer (3 April 2008)

Beispiel für Flnake in AWL:
	
	



```
U INI
UN M10.0
SPBN X001
 
hier dann die Aktion
 
X001: U INI
= M 10.0
```


----------



## stift (3 April 2008)

so siehts schon besser aus:
	
	



```
[FONT=Arial]     U     "Merker_Motor_Ein"[/FONT]
[FONT=Arial]     SPBN  M001[/FONT]
 
[FONT=Arial]     L     #OB1_PREV_CYCLE[/FONT]
[FONT=Arial]     L     #Zwischenspeicher[/FONT]
[FONT=Arial]     +I    [/FONT]
[FONT=Arial]     T     #Zwischenspeicher[/FONT]
 
[FONT=Arial]     U     "Sensor-Drehzahl"[/FONT]
[FONT=Arial]     UN    M     25.4[/FONT]
[FONT=Arial]     SPBN  M001[/FONT]
 
[FONT=Arial]     U     "Merker_Motor_Ein"[/FONT]
[FONT=Arial]     SPBN  M002[/FONT]
 
[FONT=Arial]     L     #Zwischenspeicher[/FONT]
[FONT=Arial]     L     2[/FONT]
[FONT=Arial]     *I    [/FONT]
[FONT=Arial]     T     "DB_V-Messung".Zeit_fuer_Umdrehung[/FONT]
 
[FONT=Arial]     L     0[/FONT]
[FONT=Arial]     T     #Zwischenspeicher[/FONT]
 
[FONT=Arial]M001: U     "Sensor-Drehzahl"[/FONT]
[FONT=Arial]     =     M     25.4[/FONT]
 
[FONT=Arial]M002: NOP   0[/FONT]
```
 
Die Drehzahl wäre dann ja einfach nur noch 
	
	



```
L 6.00000000e+004
L "DB_V-Messung".Zeit_fuer_Umdrehung
ITD
DTR
/R
T "DB_V-Messung".Momentandrehzahl
```
 
oder???
Wie kann ich n das ganze am besten mit pcl_sim testen?


----------



## zotos (3 April 2008)

Zum Testen entweder einen langsamen Taktmerker drauf legen oder eben einen eigenen Blinker bauen in dem Du die Frequenz vorgeben kannst.

Um die Messung der Drehzahl noch verbessern würde ich eine Glättung einbauen und/oder nicht die Dauer einer Umdrehung sondern z.B. von 10 Umdrehungen messen dadurch verringerst Du den Einfluss der Zykluszeit Abweichung. Aber immer ein schritt nach dem anderen.


----------



## stift (3 April 2008)

ja genau das mit der glättung hab ich mir auch schon überlegt. wäre ja recht einfach umzusetzen indem ich z.b. sage dass er mir den zwischenspeicher nur dann auf die zeit_fuer_umdrehung schieben soll wenn die neue zeit_fuer_umdrehung mehr als +/- 20ms von der zeit_fuer_umdrehung die gespeichert ist abweicht. 
Meine Drehzahl ist allerdings nur 0-40 1/min und deswegen würde die messung von 10 umdrehungen zu lange dauern. Da man über ein stufenloses getriebe die geschwindigkeit regeln kann wäre das nicht so gut.


----------



## Larry Laffer (3 April 2008)

... oder du addierst die auf und teilst durch die Anzahl der Messungen ...

... oder du nimmst jeweils den aktuellen und letzten Wert als Summe und teilst durch 2 ...

Gruß
LL


----------



## stift (7 April 2008)

Hi, ich hab wohl wieder irgendwo nen fehler programmiert. leider finde ich ihn nicht habe jetzt schon 3 stunden gesucht. sieht von euch jemand den fehler? Meine "Zeit_fuer_Umdrehung" wird nicht berechnet: 
	
	



```
U "Merker_Motor_Ein"
         SPBN M001
 
        L #OB1_PREV_CYCLE
        L #Zwischenspeicher
        +I
        T #Zwischenspeicher
 
        U "Sensor-Drehzahl"
        UN M 25.4
        SPBN M001
 
        U "Merker_Motor_Ein"
        SPBN M002
 
        L #Zwischenspeicher
        L 2
        *I
        ITD
        DTR
 
        L 1000
        /R
        T #Vergleichswert
 
        L #Vergleichswert
        T "DB_V-Messung".Zeit_fuer_Umdrehung
 
        L 0
        T #Zwischenspeicher
 
M001: U "Sensor-Drehzahl"
         = M25.4
 
M002: Nop 0
```


----------



## Larry Laffer (7 April 2008)

Ich würtde folgendes vorschlagen :
	
	



```
U "Sensor-Drehzahl"
   [COLOR=magenta]     U  M 25.4
        SPB M001
[/COLOR]
```
 
Du willst ja auswerten, wenn der Ini da ist und der Flankenmerker noch nicht.
Ist Ini und FM da, dann überspringen ...


----------



## stift (7 April 2008)

Ich glaubs nicht. Ich hab jetzt drei stunden lang mein netzwerk durchgeschaut und sobald ich das netzwerk ins forum gestellt hab seh ich den fehler gleich.  


```
L #Zwischenspeicher
        L 2
        *I
        ITD
        DTR
 
        L 1000
        /R
        T #Vergleichswert
```
 
besser wäre wohl 
	
	



```
L #Zwischenspeicher
        L 2
        *I
        ITD
        DTR
 
        [COLOR=red]L 1.0000000e+003[/COLOR]
        /R
        T #Vergleichswert
```


----------



## Larry Laffer (7 April 2008)

... das könnte natürlich auch noch helfen ...


----------



## stift (7 April 2008)

Ich wollte jetzt mein netzwerk auslagern und zur übersichtlichkeit in einen fc stellen. 
Leider funktioniert das irgendwie nicht. Ich schiebe die zykluszeit von ob1 einfach direkt immer in ein dbw. Im fc wird dann das dbw genommen und wie gewohnt aufaddiert. 
aber leider addiert der mir irgendwie so schnell, ich weiß auch nicht. 
Kann das so funktionieren oder ist das problematisch?
Im ob1 hat mein netzwerk nämlich spitze funktioniert. Ich habs eigentlich nur kopiert und in den fc eingefügt.


----------



## vierlagig (7 April 2008)

stift schrieb:


> aber leider addiert der mir irgendwie so schnell, ich weiß auch nicht.



was meint das?


----------



## zotos (7 April 2008)

Wenn Du die AWL Quelle hier eingefügt hättest könnte man den Fehler suchen und müsste nicht raten ;o(

Hast Du daran gedacht das ein FC nur temporäre lokale Variablen hat un keine statischen. Also sowas wie den Zwischenspeicher muss dann von außen via VAR_IN_OUT an den FC zur Verfügung gestellt werden (oder FB nutzen, oder ganz schlecht eine Globale Variable im FC nutzen).


----------



## vierlagig (7 April 2008)

zotos schrieb:


> oder ganz schlecht eine Globale Variable im FC nutzen.



wenn da nur globale variablen drin sind, ist das durchaus nicht unsauber  ...nur die mischung machts :sb5:


----------



## Larry Laffer (7 April 2008)

Ich schliesse mich Zotos und Vierlagig an ... "keine Arme ... keine Kekse ..."


----------



## stift (8 April 2008)

ihr habt ja recht, ich hab mein problem recht besch.... beschrieben. mein problem ist nämlich dass mein pg keinen netzwerkanschluss hat. deswegen muss ich mein netzwerk immer in word einfügen, mit nem usb-stick übertragen und kann das ganze dann erst ins forum stellen. 

ok also folgendes: 
meine messung lief am freitag hervorragend. dann habe ich ein paar datenformate ändern müssen und seitdem läuft die sache irgendwie nicht mehr so wie sie soll. 
die zeit pro umdrehung soll immer wenn eine neue messung da ist überträgen werden, dann aber ein fester gespeicherter wert. im moment läuft die zeit immer weiter. ich versteh nicht warum der wert jetzt weiterläuft und ich freitag konstante werte hatte. 
außerdem steht mein netzwerk jetzt im fc10. allerdings übertrage ich mein 0b1_prev_cycle mit globaldaten. 

ob1: 
	
	



```
[FONT=Arial]     CALL  "Systemsteuerteil"[/FONT]
[FONT=Arial]     CALL  "Drehzahlmessung"[/FONT]
[FONT=Arial]     CALL  "Geschwindigkeit"[/FONT]
[FONT=Arial]     CALL  "Stromüberwachung"[/FONT]
 
 
[FONT=Arial]     L     #OB1_PREV_CYCLE[/FONT]
[FONT=Arial]     T     "DB_V-Messung".Zykluszeit_OB1[/FONT]
```
 
fc10: 
	
	



```
[FONT=Arial] U     "Merker_Motor_Ein"[/FONT]
[FONT=Arial]     SPBN  M002[/FONT]
 
 
[FONT=Arial]//Aufaddieren der Zykluszeit von 0b1 zum erhalten der Zeit für eine halbe Umdrehung in ms[/FONT]
 
[FONT=Arial]     L     "DB_V-Messung".Zykluszeit_OB1[/FONT]
[FONT=Arial]     L     #Zwischenspeicher[/FONT]
[FONT=Arial]     +I    [/FONT]
[FONT=Arial]     T     #Zwischenspeicher[/FONT]
 
 
[FONT=Arial]//Bedingung für weiteren Verlauf[/FONT]
 
[FONT=Arial]     U     "Sensor-Drehzahl"[/FONT]
[FONT=Arial]     U     M     25.4[/FONT]
[FONT=Arial]     SPBN  M001[/FONT]
 
 
[FONT=Arial]//Berechnen der Zeit für Umdrehung in s (Datentyp real)[/FONT]
 
[FONT=Arial]     L     #Zwischenspeicher[/FONT]
[FONT=Arial]     L     2[/FONT]
[FONT=Arial]     *I    [/FONT]
[FONT=Arial]     ITD   [/FONT]
[FONT=Arial]     DTR   [/FONT]
 
[FONT=Arial]     L     1.000000e+003[/FONT]
[FONT=Arial]     /R    [/FONT]
[FONT=Arial]     T     #Vergleichswert[/FONT]
 
 
[FONT=Arial]//Schmitt-Trigger zum Stabilisieren aller folgenden Rechenwerte[/FONT]
 
[FONT=Arial]     L     #Vergleichswert[/FONT]
[FONT=Arial]     L     2.000000e-001[/FONT]
[FONT=Arial]     +R    [/FONT]
[FONT=Arial]     T     #oberer_Schaltpunkt[/FONT]
 
[FONT=Arial]     L     #Vergleichswert[/FONT]
[FONT=Arial]     L     2.000000e-001[/FONT]
[FONT=Arial]     -R    [/FONT]
[FONT=Arial]     T     #unterer_Schaltpunkt[/FONT]
 
[FONT=Arial]     L     #oberer_Schaltpunkt[/FONT]
[FONT=Arial]     L     #Vergleichswert[/FONT]
[FONT=Arial]     >R    [/FONT]
[FONT=Arial]     SPBN  M010[/FONT]
 
[FONT=Arial]     L     #Vergleichswert[/FONT]
[FONT=Arial]     T     "DB_V-Messung".Zeit_fuer_Umdrehung[/FONT]
 
[FONT=Arial]M010: L     #unterer_Schaltpunkt[/FONT]
[FONT=Arial]     L     #Vergleichswert[/FONT]
[FONT=Arial]     <R    [/FONT]
[FONT=Arial]     SPBN  M011[/FONT]
 
[FONT=Arial]     L     #Vergleichswert[/FONT]
[FONT=Arial]     T     "DB_V-Messung".Zeit_fuer_Umdrehung[/FONT]
 
 
[FONT=Arial]//Rücksetzten des Zwischenspeichers[/FONT]
 
[FONT=Arial]M011: L     0[/FONT]
[FONT=Arial]     T     #Zwischenspeicher[/FONT]
 
[FONT=Arial]M001: U     "Sensor-Drehzahl"[/FONT]
[FONT=Arial]     =     M     25.4[/FONT]
 
[FONT=Arial]M002: NOP   0[/FONT]
```
 
gibts jetzt kekse? *g*


----------



## vierlagig (8 April 2008)

stift schrieb:


> ihr habt ja recht, ich hab mein problem recht besch.... beschrieben. mein problem ist nämlich dass mein pg keinen netzwerkanschluss hat. deswegen muss ich mein netzwerk immer in word einfügen, mit nem usb-stick übertragen und kann das ganze dann erst ins forum stellen.



...erzeuge eine quelle und exportier sie, die *.AWL kannst du dann mit dem editor öffnen, da brauch man noch nicht mal word UND alle daten sind vorhanden...




stift schrieb:


> ob1:
> 
> 
> 
> ...



wenn du die zykluszeit am ende erst in deinen DB schreibst rechnest du immer mit der vorletzten zykluszeit ... erklärt zwar nicht das weiterlaufen ... 



stift schrieb:


> fc10:
> 
> 
> 
> ...



#zwischenspeicher ist vom typ INT und nicht TEMP   ... kann ich mir nicht vorstellen, also INT schon ... aber das es ein INOUT ist nicht, denn der aufruf in OB1 spricht eine andere sprache...



stift schrieb:


> gibts jetzt kekse? *g*


----------



## stift (8 April 2008)

sorry ich versteh nicht ganz: 





> #zwischenspeicher ist vom typ INT und nicht TEMP  ... kann ich mir nicht vorstellen, also INT schon ... aber das es ein INOUT ist nicht, denn der aufruf in OB1 spricht eine andere sprache...


 
ist ja ziemlich toll mit den quellen exportieren. Danke 
Hier noch mal der komplette fc


```
FUNCTION "Drehzahlmessung" : VOID
TITLE =
VERSION : 0.1

VAR_TEMP
  Zwischenspeicher : INT ; 
  Vergleichswert : REAL ; 
  oberer_Schaltpunkt : REAL ; 
  unterer_Schaltpunkt : REAL ; 
END_VAR
BEGIN
NETWORK
TITLE =Stoppen der Zeit für eine Umdrehung

      U     "Merker_Motor_Ein"; 
      SPBN  M002; 

//Aufaddieren der Zykluszeit von 0b1 zum erhalten der Zeit für eine halbe Umdrehung in ms
      L     "DB_V-Messung".Zykluszeit_OB1; 
      L     #Zwischenspeicher; 
      +I    ; 
      T     #Zwischenspeicher; 

//Bedingung für weiteren Verlauf
      U     "Sensor-Drehzahl"; 
      U     M     25.4; 
      SPBN  M001; 

//Berechnen der Zeit für Umdrehung in s (Datentyp real)
      L     #Zwischenspeicher; 
      L     2; 
      *I    ; 
      ITD   ; 
      DTR   ; 
      L     1.000000e+003; 
      /R    ; 
      T     #Vergleichswert; 

//Schmitt-Trigger zum Stabilisieren aller folgenden Rechenwerte
      L     #Vergleichswert; 
      L     2.000000e-001; 
      +R    ; 
      T     #oberer_Schaltpunkt; 
      L     #Vergleichswert; 
      L     2.000000e-001; 
      -R    ; 
      T     #unterer_Schaltpunkt; 
      L     #oberer_Schaltpunkt; 
      L     #Vergleichswert; 
      >R    ; 
      SPBN  M010; 
      L     #Vergleichswert; 
      T     "DB_V-Messung".Zeit_fuer_Umdrehung; 
M010: L     #unterer_Schaltpunkt; 
      L     #Vergleichswert; 
      <R    ; 
      SPBN  M011; 
      L     #Vergleichswert; 
      T     "DB_V-Messung".Zeit_fuer_Umdrehung; 

//Rücksetzten des Zwischenspeichers
M011: L     0; 
      T     #Zwischenspeicher; 
M001: U     "Sensor-Drehzahl"; 
      =     M     25.4; 
M002: NOP   0; 

NETWORK
TITLE =Berechnen der Drehzahl

      L     6.000000e+001; 
      L     "DB_V-Messung".Zeit_fuer_Umdrehung; 
      /R    ; 
      RND   ; 
      DTB   ; 
      BTI   ; 
      T     "DB_V-Messung".Momentandrehzahl; 
NETWORK
TITLE =Schieben der Vergleichsdrehzahl
//Schiebt die momentane Drehzahl auf das DBW Vergleichdrehzahl
      U     "Merker_Motor_Ein"; 
      S     "HLM_Vergleichsdrehzahl"; 
      U     "HL_Timer_Vergleichsdrehz"; 
      R     "HLM_Vergleichsdrehzahl"; 
      NOP   0; 

      U(    ; 
      U     "HLM_Vergleichsdrehzahl"; 
      L     S5T#100MS; 
      SE    "Timer_Vergleichsdrehzahl"; 
      U(    ; 
      U     "HLM_Vergleichsdrehzahl"; 
      L     S5T#150MS; 
      SE    "HL_Timer_Vergleichsdrehz"; 
      U     "HL_Timer_Vergleichsdrehz"; 
      )     ; 
      R     "Timer_Vergleichsdrehzahl"; 
      U     "Timer_Vergleichsdrehzahl"; 
      )     ; 
      SPBNB _003; 
      L     "DB_V-Messung".Momentandrehzahl; 
      T     "DB_V-Messung".Vergleichsdrehzahl; 
_003: NOP   0; 
 
NETWORK
TITLE =Rücksetzen der DBD
//Schiebt eine 0 auf alle Geschwindigkeits- und Beschleunigungswerte falls sich 
//die Drehzahl ändert
//ändert.
      U(    ; 
      L     "DB_V-Messung".Momentandrehzahl; 
      L     "DB_V-Messung".Vergleichsdrehzahl; 
      <>I   ; 
      )     ; 
      SPBNB M004; 
      L     0.000000e+000; 
      T     "DB_V-Messung".Maximalgeschwindigkeit; 
      T     "DB_V-Messung".Durchschnittsgeschw; 
      T     "DB_V-Messung".Maximalbeschleunigung; 
      T     "DB_V-Messung".Durchschnittsbeschl; 
M004: NOP   0; 
 
END_FUNCTION
```


----------



## vierlagig (8 April 2008)

stift schrieb:


> sorry ich versteh nicht ganz





> *TEMP*
> Temporäre Daten sind Lokaldaten eines Bausteins, die während der Bearbeitung eines Bausteins im Lokaldaten-Stack (L-Stack) abgelegt werden und nach der Bearbeitung *nicht mehr verfügbar sind*.



...da du sie aber brauchst, weil du möchtest ja auf den wert vom vorhergehenden zyklus addieren müssen diese lokaldaten nach der bearbeitung verfügbar sein ...

also z.B.



> *INOUT*
> Durchgangsparameter gibt es bei Funktionen und Funktionsbausteinen. Mit Durchgangsparametern werden Daten an den aufgerufenen Baustein übergeben, dort verarbeitet, und die Ergebnisse vom aufgerufenen Baustein wieder in der gleichen Variablen abgelegt.



oder eben global ...


----------



## stift (8 April 2008)

meine flankenauswertung funktioniert aber irgendwie auch nicht. 
mein netzwerk ab "Bedingung für weiteren Verlauf" ist immer aktiv sobald "Sensor-Drehzahl" da ist. 
Der fragt anscheinend keine flanke ab!
Ich hab jetzt auch in ob1 mein Lade-transferiere nach vorne geschoben, dass die aktuelle zykluszeit addiert werden kann und nicht die vorhergehende.


----------



## vierlagig (8 April 2008)

für flanken gilt dasselbe ... die müssen im nächsten zyklus vorhanden sein


----------



## stift (8 April 2008)

sorry, ich steh leider immer noch auf dem schlauch. 
wenn ich doch jetzt meine zykluszeit in ob1 als erstes übertrage, dann müsste mein programm doch ohne probleme laufen. ich verwende doch nur bits aus dem aktuellen zyklus.


----------



## vierlagig (8 April 2008)

eine flankenauswertung besteht eben nicht nur aus bits aus dem aktuellen zyklus ... dazu sollte man sich mal anschauen wie die CPU arbeitet:

1. Prozessabbild Eingänge lesen
2. Bearbeitung
3. Prozessabbild Ausgänge schreiben

... in der informatik nennt man das EVA 

das heißt eine flankenauswertung passiert zyklusübergreifend und muß dementsprechend über mehrer zyklen vorhanden sein


----------



## stift (8 April 2008)

ja aber mein "Sensor-Drehzahl" und mein Merker 25.4 sind doch beides zyklusübergreifende bestandteile. da müsste die flankenauswertung doch funktionieren.


----------



## vierlagig (8 April 2008)

finde die FP oder FN nicht in deinem FC ... hmm, also:


```
U   E0.0        //soll auf flanke geprüft werden
FP  #help_flag  //muß zyklusübergreifend da sein (INOUT, STAT(FB) oder global
=   #irgendwas  //nur einen zyklus an
```


----------



## Larry Laffer (8 April 2008)

... ihr habt das TEMP-Thema ein bißchen ignoriert ...

Stift nimmt zur Berechnung der Zeiten etc. TEMP-Variablen aus dem FC10. Die sind mit dem nächsten FC10-Aufruf nicht mehr brauchbar ... Das war im OB1 anderes gewesen.
Ergo : Du musst hier für Flanke und Zwischenwert etc. natürlich auch Global-Daten nehmen ... oder noch schöner ... du baust alles in einen FB und hinterlegst deine relevanten Sachen im STAT-Bereich. Dann fluppt das auch ...

Gruß
LL

Nachsatz: Vielleicht habe ich (jetzt auf die Schnelle) auch etwas überlesen, was ihr schon hattet - glaube ich aber nicht wirklich ...


----------



## vierlagig (8 April 2008)

Larry Laffer schrieb:


> ... ihr habt das TEMP-Thema ein bißchen ignoriert ...
> 
> Nachsatz: Vielleicht habe ich (jetzt auf die Schnelle) auch etwas überlesen, was ihr schon hattet - glaube ich aber nicht wirklich ...



ich würde sagen: überlesen ... is doch aber nicht schlimm 



vierlagig schrieb:


> #zwischenspeicher ist vom typ INT und nicht TEMP   ... kann ich mir nicht vorstellen, also INT schon ... aber das es ein INOUT ist nicht, denn der aufruf in OB1 spricht eine andere sprache...


----------



## Larry Laffer (8 April 2008)

... hast ja recht ... Beitrag #41 von dir ...
Aber die Sache FB kontra FC finde ich in diesem Zusammenhang gar nicht so schlecht ...


----------



## vierlagig (8 April 2008)

Larry Laffer schrieb:


> ... hast ja recht ... Beitrag #41 von dir ...
> Aber die Sache FB kontra FC finde ich in diesem Zusammenhang gar nicht so schlecht ...



das könnte man mal abwägen, japp *ACK* ... da fällt mir die frage ein, die mir schon lange unter den nägeln brennt: was soll die CPU sonst noch machen? wenn sie wirklichst nur für die drehzahl-dingens ist, könnte man das auch alles global machen ... egal: nachteil FC: kann nich speichern, also alles was du späters brauchst mußt du irgendwo ablegen ... also stift, prüfe mal, ob du vielleicht mit einem FB besser fährst ...


----------



## stift (8 April 2008)

> was soll die CPU sonst noch machen? wenn sie wirklichst nur für die drehzahl-dingens ist, könnte man das auch alles global machen ...


Mit der CPU steuere ich einen Motor, messe die Drehzahl des Getriebes, Errechne die Beschleunigung und die Verfahrgeschwindigkeit eines Tischen und fahre eine Strommessung bei 4 steckdosen, deren min und max strom man über ein touch-panel einstellen kann. 



> also stift, prüfe mal, ob du vielleicht mit einem FB besser fährst ...


ein fb ist echt besser... den hab ich jetzt auch gleich erstellt aber leider funktioniert die sache immer noch nicht. mein zwischenwert wird nach jedem zyklus auf null gesetzt und bei allen zeilen beim programm-teil "schmitt-trigger" ist vke überall 1.  


```
FUNCTION_BLOCK "Drehzahlerrechnung"
TITLE =
VERSION : 0.1
 
VAR_INPUT
  Motor_Ein : BOOL ; 
  Zykluszeit : INT ; 
  Drehzahlsensor : BOOL ; 
END_VAR
VAR_OUTPUT
  Zeit_fuer_Umdrehung : REAL ; 
  Momentandrehzahl : INT ; 
END_VAR
VAR
  Zwischenspeicher : INT ; 
  Vergleichswert : REAL ; 
  unterer_Schaltpunkt : REAL ; 
  oberer_Schaltpunkt : REAL ; 
  Flankenmerker : BOOL ; 
END_VAR
BEGIN
NETWORK
TITLE =Stoppen der Zeit für eine Umdrehung
 
      U     #Motor_Ein; 
      SPBN  M002; 
 
//Aufaddieren der Zykluszeit von 0b1 zum erhalten der Zeit für eine halbe Umdrehung in ms
      L     #Zykluszeit; 
      L     #Zwischenspeicher; 
      +I    ; 
      T     #Zwischenspeicher; 
 
//Bedingung für weiteren Verlauf
      U     #Drehzahlsensor; 
      U     #Flankenmerker; 
      SPB   M001; 
 
//Berechnen der Zeit für Umdrehung in s (Datentyp real)
      L     #Zwischenspeicher; 
      L     2; 
      *I    ; 
      ITD   ; 
      DTR   ; 
      L     1.000000e+003; 
      /R    ; 
      T     #Vergleichswert; 
 
//Schmitt-Trigger zum Stabilisieren aller folgenden Rechenwerte
      L     #Vergleichswert; 
      L     2.000000e-001; 
      +R    ; 
      T     #oberer_Schaltpunkt; 
      L     #Vergleichswert; 
      L     2.000000e-001; 
      -R    ; 
      T     #unterer_Schaltpunkt; 
      L     #oberer_Schaltpunkt; 
      L     #Vergleichswert; 
      >R    ; 
      SPBN  M010; 
      L     #Vergleichswert; 
      T     #Zeit_fuer_Umdrehung; 
M010: L     #unterer_Schaltpunkt; 
      L     #Vergleichswert; 
      <R    ; 
      SPBN  M011; 
      L     #Vergleichswert; 
      T     #Zeit_fuer_Umdrehung; 
 
//Rücksetzten des Zwischenspeichers
M011: L     0; 
      T     #Zwischenspeicher; 
M001: U     "Sensor-Drehzahl"; 
      =     #Flankenmerker; 
M002: NOP   0; 
NETWORK
TITLE =Berechnen der Drehzahl
 
      L     6.000000e+001; 
      L     #Zeit_fuer_Umdrehung; 
      /R    ; 
      RND   ; 
      DTB   ; 
      BTI   ; 
      T     #Momentandrehzahl; 
 
END_FUNCTION_BLOCK
```
 
ich habe auch schon folgendes probiert: 

```
...
//Bedingung für weiteren Verlauf
      U     #Drehzahlsensor; 
      FP    #Flankenmerker; 
      SPB   M001;
 
...
 
M001: U     "Sensor-Drehzahl"; 
      =     #Flankenmerker;
```
 
hat aber auch nicht funktionert


----------



## vierlagig (8 April 2008)

tausche mal den inhalt von marke M010 und M011 und passe die sprünge entsprechend an ... das laden von 0 wird immer durchgeführt ...


----------



## Larry Laffer (8 April 2008)

... ist für mich logisch, was da passiert ...

Wenn dein INI "Drehzahlsensor" nicht da ist, dann solltest du auch nach M001 springen ...


----------



## stift (8 April 2008)

den programmteil "Schmitt-Trigger" hab ich jetzt mal ausgeklammert und habe auch programmiert dass ich zu m001 springe sobald "Sensor-Drehzahl" nicht da ist. 
Jetzt ist folgendes: 
Solange "Sensor-Drehzahl" da ist wird mein zwischenspeicher in jedem zyklus auf null gesetzt. Man sieht außerdem den wert direkt d.h. er wird nicht einmal bei steigender flanke auf mein dbd gelegt, welches ich über den fb ansteuere sondern er wird in jedem zyklus geschoben. 
Sobald "Sensor-Drehzahl" nicht mehr da ist wird mein zwischenspeicher wie gewohnt erhöht. Kommt aber der "sensor-Drehzahl wieder wird alles wieder auf null gesetzt.


----------



## Larry Laffer (8 April 2008)

dann versuch es mal so :
	
	



```
UN     #Drehzahlsensor; 
      O    #Flankenmerker; 
      SPB   M001;
```


----------



## stift (8 April 2008)

das war die lösung. 
bis auf den schmitt-trigger funktioniert jetzt alles. aber den bekomm ich auch noch zum laufen. danke!
:s18:


----------



## Larry Laffer (8 April 2008)

... nicht verzagen ... Larry fragen ...

Was klappt den an deinem "Schmitt-Trigger" nicht ?
Das Code-Segment sah für mich erstmal nicht schlecht aus ...
Aber ... was war der Sinn des Ganzen ...? Glättung der Werte ?
Das Ginge auch schön mit :
	
	



```
L  letzter_Messwert
L  neuer_Messwert
+  R
L  2.0
/  R
T  neuer_Messwert
```


----------



## stift (8 April 2008)

ich versuch erst mal selbst den fehler im schmitt-trigger zu finden. 
aber jetzt mal ne blöde frage: 
wieso hat die flankenauswertung mit
	
	



```
U "Sensor-Drehzahl"
U #Flankenmerker
SPA ....
```
in OB1 funktionert und in meinem FB dann plötzlich nicht mehr trotz statischer variable für den flankenmerker


----------



## vierlagig (8 April 2008)

stift schrieb:


> ich habe auch schon folgendes probiert:
> 
> ```
> ...
> ...



das kann auch nicht funktionieren ... den flankenmerker zu beschreiben macht keinen sinn und die operation auch z.T. funktionsunfähig ... denn wie die hilfe weiß wird in diesem bit der zustand gespeichert ...



> *FP* <Bit> (Flanke Positiv) erkennt eine steigende Flanke, wenn das VKE von "0" auf "1" wechselt und zeigt dies mit VKE = 1 an.
> 
> Während eines jeden Programmzyklus wird der Signalzustand des VKE-Bits mit dem Signalzustand des VKE-Bits des vorherigen Zyklus verglichen, um Änderungen des Zustands festzustellen. Um den Vergleich ausführen zu können, muß der vorherige VKE-Zustand in der Adresse des Flankenmerkers (<Bit>) gespeichert werden. Unterscheidet sich der aktuelle Signalzustand des VKE-Bits vom vorherigen Zustand ("0") (Erkennung einer steigenden Flanke), ist das VKE-Bit nach dieser Operation "1".


----------



## Larry Laffer (8 April 2008)

```
//Bedingung für weiteren Verlauf
      U     #Drehzahlsensor; 
      U     #Flankenmerker; 
      SPB   M001;
```
 
Das hat nicht funktioniert, weill der Sprung nur ausgeführt wird, wenn INI da und FM da. sonst wird nicht gesprungen.
Du willst aber eigentlich Springen wenn INI nicht da oder FM da. Das war dann auch mein Vorschlag ...


----------



## vierlagig (8 April 2008)

das hier ist vielleicht noch interessant für dich zu wissen:



> Der Flankenoperand FO hat in Step7® ein speicherndes Verhalten. Aus diesem Grund kann der Flankenoperand nur in Merkerbits, in Datenbits von Globaldatenbausteinen oder in statische Lokaldatenbits gespeichert werden.
> 
> Eine Ausnahme bilden Flankenoperanden die im Organisationsbaustein OB1 programmiert sind. Hier können Flankenoperanden in temporären Lokaldatenbits gespeichert werden. In Funktionsbausteinen FB und in Funktionen FC erzeugt die Speicherung eines Flankenoperanden in temporären Lokaldatenbits ein Fehlverhalten des Anwenderprogrammes.



*Quelle*


----------



## stift (9 April 2008)

hi, ich hab meine zweipunktregelung gerade zum laufen gebracht. 
1. habe ich auf die momentane zeit für umdrehung 20 addiert und 20 abgezogen und die ergebnisse dann wieder mit der momentanen zeit verglichen. Jetzt speichere ich immer ne vergleichswert vom letzten zyklus. 
2. hat meine bitverknüpfung überhaupt nicht gepasst. 

Hier mal meine lösung, falls es euch interessiert: 
	
	



```
FUNCTION_BLOCK "Drehzahlerrechnung"
TITLE =
VERSION : 0.1

VAR_INPUT
  Motor_Ein : BOOL ; 
  Zykluszeit : INT ; 
  Drehzahlsensor : BOOL ; 
END_VAR
VAR_OUTPUT
  Zeit_fuer_Umdrehung : REAL ; 
  Momentandrehzahl : INT ; 
END_VAR
VAR
  Zwischenspeicher : INT ; 
  Vergleichswert : REAL ; 
  unterer_Schaltpunkt : REAL ; 
  oberer_Schaltpunkt : REAL ; 
  Flankenmerker : BOOL ; 
  Zeit_f_Umdrehung : REAL ; 
END_VAR
BEGIN
NETWORK
TITLE =Stoppen der Zeit für eine Umdrehung

      U     #Motor_Ein; 
      SPBN  M002; 

//Aufaddieren der Zykluszeit von 0b1 zum erhalten der Zeit für eine halbe Umdrehung in ms
      L     #Zykluszeit; 
      L     #Zwischenspeicher; 
      +I    ; 
      T     #Zwischenspeicher; 

//Bedingung für weiteren Verlauf
      UN    #Drehzahlsensor; 
      O     #Flankenmerker; 
      SPB   M001; 

//Berechnen der Zeit für Umdrehung in s (Datentyp real)
      L     #Zwischenspeicher; 
      L     2; 
      *I    ; 
      ITD   ; 
      DTR   ; 
      L     1.000000e+003; 
      /R    ; 
      T     #Zeit_f_Umdrehung; 

//Schmitt-Trigger zum Stabilisieren aller folgenden Rechenwerte
      L     #Zeit_f_Umdrehung; 
      L     2.000000e-002; 
      +R    ; 
      T     #oberer_Schaltpunkt; 
      L     #Zeit_f_Umdrehung; 
      L     2.000000e-002; 
      -R    ; 
      T     #unterer_Schaltpunkt; 
      U(    ; 
      U(    ; 
      L     #oberer_Schaltpunkt; 
      L     #Vergleichswert; 
      >R    ; 
      )     ; 
      NOT   ; 
      O(    ; 
      U(    ; 
      L     #unterer_Schaltpunkt; 
      L     #Vergleichswert; 
      <R    ; 
      )     ; 
      NOT   ; 
      )     ; 
      )     ; 
      SPBNB M004; 
      L     #Zeit_f_Umdrehung; 
      T     #Zeit_fuer_Umdrehung; 
      T     #Vergleichswert; 

//Rücksetzten des Zwischenspeichers
M004: L     0; 
      T     #Zwischenspeicher; 
M001: U     "Sensor-Drehzahl"; 
      =     #Flankenmerker; 
      LOOP  M003; 

M002: L     0; 
      T     #Zwischenspeicher; 
      T     #Vergleichswert; 
      T     #Zeit_fuer_Umdrehung; 
      T     #Momentandrehzahl; 
M003: NOP   0; 
NETWORK
TITLE =Berechnen der Drehzahl

      L     6.000000e+001; 
      L     #Zeit_fuer_Umdrehung; 
      /R    ; 
      RND   ; 
      DTB   ; 
      BTI   ; 
      T     #Momentandrehzahl; 

END_FUNCTION_BLOCK
```


----------



## vierlagig (9 April 2008)

es gibt eine stelle in deinem code, die mir nicht gefällt


```
U    "Sensor-Drehzahl"
```

es handelt sich dabei ja offensichtlich um eine globale variable mit symbol...

nachteil: du kannst deinen baustein nicht wirklich in eine bibliothek ablegen und für andere anwendungen wieder auspacken, also nicht ohne zu prüfen ob "Sensor-Drehzahl" in dem anderen programm der globalen adresse in deinem aktuellen programm entspricht und diese ggf. anzupassen ... auch kannst du so nicht mehrere drehzahlmessungen in einer CPU realisieren


----------



## stift (9 April 2008)

hast recht 
werd ich ändern


----------



## stift (10 April 2008)

hi, ich brauch noch ne kleine ergänzung, komm aber nicht klar. 
ich möchte in meinem fb sowas wie ein statusbit, als ausgang der 1 ist, wenn eine änderung erfolgt, also der zweipunktregler 1 ist, und meine neue zeit_fuer_umdrehung schiebt. Drum hab ich folgendes ergänzt: 


```
U(    ; 
      U(    ; 
      L     #oberer_Schaltpunkt; 
      L     #Vergleichswert; 
      >R    ; 
      )     ; 
      NOT   ; 
      O(    ; 
      U(    ; 
      L     #unterer_Schaltpunkt; 
      L     #Vergleichswert; 
      <R    ; 
      )     ; 
      NOT   ; 
      )     ; 
      )     ; 
      SPBNB M004; 
 
      [COLOR=red]FP   #HM_Aenderung[/COLOR]
[COLOR=red]     =    #Aenderung[/COLOR]
      L     #Zeit_f_Umdrehung; 
      T     #Zeit_fuer_Umdrehung; 
      T     #Vergleichswert; 
 
//Rücksetzten des Zwischenspeichers
M004: L     0; 
      T     #Zwischenspeicher; 
M001: U     "Sensor-Drehzahl"; 
      =     #Flankenmerker; 
      LOOP  M003; 
 
M002: L     0; 
      T     #Zwischenspeicher; 
      T     #Vergleichswert; 
      T     #Zeit_fuer_Umdrehung; 
      T     #Momentandrehzahl; 
M003: NOP   0;
```
 
Allerdings geht meine CPU jetzt wegen eines bereichslängenfehlers immer in stop. Wie würdet ihr mein problem lösen?


----------



## vierlagig (10 April 2008)

hast du den aufrufenden baustein auch nochmal hochgeladen? und den instanz-db? schließlich hast du ja eine lokaldaten-änderung vorgenommen...


----------



## stift (10 April 2008)

oops, ich hab in meinem fc den aufruf zum fb zwar geändert, aber dadurch dass ich meinen fb noch mal leicht umstrukturiert habe, hat er den aufruf wohl nicht akzeptiert. 
Leider funktioniert mein programm aber auch nicht. 
#Aenderung ist immer 0 und geht nie auf 1


----------



## vierlagig (10 April 2008)

stift schrieb:


> #Aenderung ist immer 0 und geht nie auf 1



so wie du es programmiert hast ist #aenderung auch nur einen zyklus aktiv


----------



## stift (10 April 2008)

und wie sollte ich das dann lösen?
ich bin schon seit 9 uhr am kämpfen. Leider fällt mir keine andere lösung ein. Wenn mein zweipunktregle auslöst, hab ich doch ne flanke... ahh, das problem liegt darin dass mein #HM_Aenderung einmal auf 1 geht und dann nie mehr auf null gehen kann oder. Desshalb kann er auch keine positive flanke registrieren oder?
Wie kann ich denn dann dieses problem lösen?

....
FB  #Aenderung
= #Aenderung ????


----------



## vierlagig (10 April 2008)

stift schrieb:


> FP  #Aenderung
> = #Aenderung ????



so nicht! pfui pfui pfui 

eine möglichkeit wäre das setzen... doch wann rücksetzen?
du kannst im FB setzen, mußt dann aber auch da rücksetzen
ODER
du beschaltest deinen ausgang im aufrufenden baustein mit einem merker der im darauffolgend netzwerk etwas setzt, das dir zeigt das eine aenderung stattfand ... und dann vielleicht nach einer zeit zurücksetzen ... weiß ja nicht, wie du den fakt der änderung weiter verarbeiten möchtest


----------



## stift (10 April 2008)

ich habs schon versucht mit einem flipflop bin aber auch gescheitert. 
diese variante wäre mir am liebsten. 
ich muss einige werte rücksetzen sobald eine änderung erfolgt. das will ich mit diesem statusbit machen. 
	
	



```
U(    ; 
      U(    ; 
      L     #oberer_Schaltpunkt; 
      L     #Vergleichswert; 
      >R    ; 
      )     ; 
      NOT   ; 
      O(    ; 
      U(    ; 
      L     #unterer_Schaltpunkt; 
      L     #Vergleichswert; 
      <R    ; 
      )     ; 
      NOT   ; 
      )     ; 
      )     ; 
      [COLOR=red]SPBNB M005; [/COLOR]
 
      [COLOR=red]S    #Aenderung[/COLOR]
      L     #Zeit_f_Umdrehung; 
      T     #Zeit_fuer_Umdrehung; 
      T     #Vergleichswert; 
      [COLOR=red]Loop M004[/COLOR]
 
//Rücksetzten des Zwischenspeichers
[COLOR=red]M005: R   #Aenderung[/COLOR]
 
M004: L     0; 
      T     #Zwischenspeicher; 
M001: U     "Sensor-Drehzahl"; 
      =     #Flankenmerker; 
      LOOP  M003; 
 
M002: L     0; 
      T     #Zwischenspeicher; 
      T     #Vergleichswert; 
      T     #Zeit_fuer_Umdrehung; 
      T     #Momentandrehzahl; 
M003: NOP   0;
```


----------



## vierlagig (10 April 2008)

stift schrieb:


> ich muss einige werte rücksetzen sobald eine änderung erfolgt. das will ich mittels dieses statusbits machen.



dann müßte


```
SPBNB   M005;
FP   #HM_aenderung
=     #aenderung
```

eigentlich reichen

mit dem am ausgang hängenden Merker dann


```
U   "Aenderung"
R   "rückzusetzendes1"
R   "rückzusetzendes2"
R   "rückzusetzendes3"
```

wobei durch FP nur eine änderung und keine stetige aenderung erkannt wird ... läßt du die flankenauswertung weg wird jede änderung erkannt


----------



## stift (10 April 2008)

ja genau, 
ich habs gerade auch hinbekommen. 
ich hab das obige netzwerk noch mal programmiert und hab dann vor das rücksetzten ne flankenauswertung programmiert, weil die obige funktion ja keine flankenauswertung aufweist. 
	
	



```
U      "Drehzahl_Änderung
FP     "HM_Drehzahl_Änderung"
L       0
T       DB10.dbd0
```


----------



## vierlagig (10 April 2008)

stift schrieb:


> ich habs gerade auch hinbekommen.



siehste, alles wird gut


----------

