TIA Impuls aus Summenzähler

sps_mitte

Level-2
Beiträge
172
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,
ich suche ein eleganten Weg um aus einer Summenzählung (Real-Format) Impulse bei jeder vollen Zählung zu erzeugen. Also der umgekehrte Weg.
Wer hat hier eine Idee?
 
Zuviel Werbung?
-> Hier kostenlos registrieren
- Was ist eine "volle Zählung"?
- davon die steigende Flanke
- auf eine Ausschaltverzögerung/TOF oder TP geben


btw: Hast Du Deine REAL-Summen"zählung" gut ausgetestet, auch mal hohe Zählerstände? Zählen tut man normalerweise Ganzzahlen (DINT) wegen den ungünstigen Eigenschaften des REAL-Formats

Harald
 
Ich kann auch aus dem Real Formal zum DINT umwandeln (RTD) oder TRUNC.
Jetzt soll bei jeder vollen Zählung ein Impuls ausgegeben werden.
2322 > Impuls > 2323 > Impuls > 2324 > Impuls > 2325 > Impuls
 
Bedenke, dass es verschiedene Konvertierungsfunktionen gibt. Ggf. wird das DINT nicht immer das Ergebnis bringen, dass du erwartest.
Ansonsten könntest Du das etwa so machen:

Bei Start den Startwert merken und mit dem Istwert vergleichen. Ist der Vergleich ungleich, machst Du Dir den gewünschten Merker an und speicherst den neuen Wert.
Denkbar wäre auch dabei abzufragen, ob der Istwert größer oder kleiner als der letzte Wert ist, wenn er sich geändert hat.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Mit "volle Zählung" meinst Du wenn beim Zählerstand die Einer-Ziffer weiterschaltet?

Vergleiche ob der Zählerstand ohne Kommastellen größer ist als der Zählerstand vom Zyklus vorher.
Code:
L rZaehlerstand
TRUNC
L DBx.diZaehlerstand_vorher
TAK
T DBx.diZaehlerstand_vorher
<D           //oder <>D
L S5T#100ms
SA T1        //TOF
U T1
= A0.0
Wie hoch kann Dein Zähler zählen? (vermutlich viel kleiner als 10'000'000)
Kann Dein Zähler auch rückwärts zählen? Soll da auch ein Impuls ausgegeben werden?
Wie schnell kann Dein Zählerstand steigen?

Harald
 
Zuletzt bearbeitet:
Hallo Harald,
der Summenzähler läuft nur vorwärts. Daher nur Impuls bei jeder einzelnen Änderung. Ist fürn Durchflusszähler, eine Impulszählung bei jedem m3 Wasser.
 
Das ist ein Impulsteiler! Der Durchflusszähler bringt z.B. 1Impuls für 10L und man will einen Impuls pro m³
Mit dem Baustein mach ich das!

Hier die AML Quelle: Übersetzt kann man das wieder auf KOP/FUP umschalten
Code:
FUNCTION "ImpulsTeiler" : VOID
TITLE =Impulsteiler
VERSION : 0.1


VAR_INPUT
  Impuls : BOOL ;    
  Teilung : DINT ;    //Impulsteilung: alle x Impulse am Eingang 1x Ausgang
END_VAR
VAR_OUTPUT
  Q : BOOL ;    
END_VAR
VAR_IN_OUT
  memDI : DINT ;    
END_VAR
VAR_TEMP
  HM_Q : BOOL ;    
END_VAR
BEGIN
NETWORK
TITLE =



NETWORK
TITLE =
      U     #Impuls; 
      SPBNB _001; 
      L     #memDI; 
      L     L#1; 
      +D    ; 
      T     #memDI; 
_001: NOP   0; 
NETWORK
TITLE =

      L     #memDI; 
      L     #Teilung; 
      >=D   ; 
      =     #Q; 
      =     #HM_Q; 
NETWORK
TITLE =

      U     #HM_Q; 
      SPBNB _002; 
      L     0; 
      T     #memDI; 
      SET   ; 
      SAVE  ; 
      CLR   ; 
_002: U     BIE; 
      SAVE  ; 
END_FUNCTION
 
Was man oft auch noch braucht ist die Impulserzeugung für Gas/Strom/Wasserzähler, die nur einen
Analogausgang haben und keinen Mengenimpuls liefern.
Dann muss man sich aus dem Anaolgsignal der Durchflusses, selbst die Impulse generieren.

Das mach ich mit folgendem Baustein. Der angängete ScreenShot zeigt den korrekten Aufruf (am Beispiel einer Stomzählung: Erzeugung 1Impuls/kWh)
Code:
FUNCTION "m7b_IMPULS_REAL" : VOID
TITLE =Integrator mit Impuls nach Sollwert für REAL
//aufsummieren von Sensorsignalen (z.B.) kW und erzeugen eines Impulses alle
//x kWh.
//Bei z.B. einem Stromzähler der als Analogsignal die aktuelle kW-Zahl liefert,
//am besten im Takt von 1sec und NoOfCounts 3600 aufaddieren. Als Summe werden
//dann kWh geliefert. Mit rSollImpuls (z.B. 100) dann alle 100kWh einen Impuls 
//ausgeben.
//
//ENO : Zählimpuls: mit diesem Impuls den I/0-Wert 'rINTEGRAL' kopieren
//      dieser enthält zu diesem Zeitpukt den summierten Wert. Beim
//      nächsten TAKT wird dieser wieder gelöscht.
//
//DATUM: 09/2013
//
//AENDERUNGSVERMERKE:
//--------------------------------------------------------------------------------
//DATUM        NAME        AENDERUNG
//--------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------
//
//HINWEISE:
AUTHOR : 'SM'
FAMILY : Maagic7
VERSION : 0.1


VAR_INPUT
  TAKT : BOOL ;    //Taktgeber: (Flankenauswertung erfolgt im FC)
  RESET : BOOL ;    //RESET: Zähler rücksetzen
  VALUE : REAL ;    //Zu integrierender WERT
  dNoOfCounts : DINT ;    //Anzahl zu integrierender Werte
  rSollImpuls : REAL ;    //Sollwert: 1 Impuls alle 'rSollImpuls'; Sollwert bei dem 1 Impuls ausgelöst wird
END_VAR
VAR_IN_OUT
  mem_rINTEGRAL : REAL ;    //Integralwert
  memByte : BYTE ;    //statisches Hifls-Byte
END_VAR
VAR_TEMP
  lb0_Impuls : BOOL ;    //Lokaler Speicher:  
  lb1_HM_FP_TAKT : BOOL ;    //Lokaler Speicher:  
  lb2 : BOOL ;    //Lokaler Speicher:  
  lb3 : BOOL ;    //Lokaler Speicher:  
  lb4 : BOOL ;    //Lokaler Speicher
  lb5 : BOOL ;    //Lokaler Speicher
  lb6 : BOOL ;    //Lokaler Speicher 
  lb7 : BOOL ;    //Lokaler Speicher
  tmpTAKT : BOOL ;    
END_VAR
BEGIN
NETWORK
TITLE =statisches Hilfsbyte in temporäre Bits

      L     #memByte; 
      T     LB     0; 
      NOP   0; 

NETWORK
TITLE =Impulsmerker wieder löschen, falls aktiv

      U     #lb0_Impuls; 
      R     #lb0_Impuls; 

NETWORK
TITLE =RESET

      UN    #RESET; 
      SPB   ne4; 

      L     0.000000e+000; 
      T     #mem_rINTEGRAL; 

ne4:  NOP   0; 
NETWORK
TITLE =Zählen
//Bei Sollwert erreicht wird erst beim nächsten Takt der Integralwert 
//zurückgesetzt, somit kann mit dem IMPULS der aktuelle Integralwert
//für die weitere Verarbeitung noch zur Verfügung gestellt werden.
//
      U     #TAKT; 
      FP    #lb1_HM_FP_TAKT; 
      =     #tmpTAKT; 

      ON    #tmpTAKT; 
      O     #RESET; 
      SPB   ne5; 

      L     #mem_rINTEGRAL; 
      L     #rSollImpuls; 
      <R    ; 
      SPB   weit; 

      L     #mem_rINTEGRAL; // Sollwert von Integral abziehen,
      L     #rSollImpuls; // wenn Sollwert erreicht war
      -R    ; 
      T     #mem_rINTEGRAL; 

weit: L     #VALUE; // Zählen
      L     #dNoOfCounts; 
      DTR   ; 
      /R    ; 
      L     #mem_rINTEGRAL; 
      +R    ; 
      T     #mem_rINTEGRAL; 
      L     #rSollImpuls; 
      >=R   ; 
      S     #lb0_Impuls; // Impuls Sollwert erreicht
      SPA   ne5; 

ne5:  NOP   0; 

NETWORK
TITLE =FC-ENO-Ausgang = Zählimpuls

      U     #lb0_Impuls; 
      SAVE  ; 
      CLR   ; 
NETWORK
TITLE =temporäre Bits zurück in statisches Hilfsbyte

      L     LB     0; 
      T     #memByte; 
      NOP   0; 

END_FUNCTION

[ATTACH=CONFIG]40714._xfImport[/ATTACH]
 

Anhänge

  • FC231_Aufruf.jpg
    FC231_Aufruf.jpg
    35,1 KB · Aufrufe: 50
Zurück
Oben