marekf/laatzen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
265c534d2b
laatzen/Pruef2000/source/modUS2000_Algorithmen.bas

1065 lines
51 KiB
QBasic
Raw Normal View History

Initial commit 3
2021-10-01 09:11:04 +00:00
Attribute VB_Name = "modUS2000_Algorithmen"
Option Explicit
'---Freigabe f<>r Produktion: 04.12.01 - Version 9.1 - Uwe Gro<72>
'---Freigabe f<>r Produktion: 14.12.01 - Version 9.3 - Uwe Gro<72>
'********************************************************************************************
' History: Version 4.0: Startup f<>r Me<4D>referenzsystem
' Version 4.3: Subroutine Justage und Functions Geberkonstante bzw. Offset
' hinzugef<65>gt
' Version 4.7: Function PLZausTemperatur hinzugef<65>gt
' Version 4.8: PLZausTemperatur und Q_H2OausDT entf<74>llt.
' Version 4.9: <20>nderung Geberkonstante_m3 auf Geberkonstante_m
' Version 4.10: <20>nderung Geberkonstante_m und Offset_s
' Version 6.0: Function MSP430FloatToDez und DezToFloatMSP430 aus Algorithmus zur Vollst<73>ndigkeit aufgenommen.
' Version 7.0: wie 6.0
' Version 8.0: Q_US_lph zur Bestimmung des Durchflu<6C> erweitert auf
' temperaturab<61>ngigen Offset und Unlinearit<69>tsausgleich
' Neuer Abgleich mit Geberkonstante_m und Offset_s
' Version 8.5: temperaturabh<62>ngige Steilheit f<>r DiffTof_ns hinzugef<65>gt in Function Q_US_lph.
' Subroutine Justage_Execute
' Version 8.11: FloatMSP430 = "00000000" f<>hrt zu 0,00 in Function FloatMSP430_To_DEZ(FloatMSP430)
' Version 8.16: Function DEZ_To_FloatMSP430(Dezimal)ge<67>ndert
' Version 8.17: Function Diff_Tof hinzugef<65>gt incl. <20>nderung
' Function GibtEinenWertAus(Zeile, Spalte, Blatt_Nr) eingef<65>gt
' Version 8.19: Function Diff_Tof ge<67>ndert. Sub Justage_Execute ge<67>ndert.
' Version 9.1: Function Justage_Execute ge<67>ndert.
' Version 9.7: Neue Function Q_US_Bereich_lph, Function Justage_Execute ge<67>ndert.
' Version 9.8: Function Diff_Tof ge<67>ndert.
' Version 9.10: Neue Function Volume_2_DiffTof (...)
' Version 9.13: 22.03.2002 neue Function Checksumme_Master
' neue Function CheckHEX und Aufruf aus FloatMSP430_To_DEZ
' neue Function CheckConfig
' 25.03.2002 <20>nderung Function Checksumme_Master
' 12.06.2002: Function DEZ_To_FloatMSP430, Q_US_Bereich_lph und Diff_Tof ge<67>ndert
' 26.06.2002: neue Function ZeroFlowOffset
' 31.07.2002: neue Function ZeroFlowOffset_ErmitteltAusEinerTemperatur
' Version 9.14: <20>nderung in Function Diff_Tof und Q_US_Bereich_lph
' Version 9.16: <20>nderung in Function ZeroFlowOffset_ErmitteltAusEinerTemperatur
' Neue Function DiffToffASIC_ZeroFlowOffset
' Version 9.17: <20>nderung in Function DiffToffASIC_ZeroFlowOffset
'********************************************************************************************
'********************************************************************************************
'
'
' Author: Dirk Pulwer
' Date: 07.01.02
' Description: Modul-Anpassung / Integration (Option Explicit gesetzt - > Variablendeklaration erzwungen !)
'
' Diese Version wurde in die Pr<50>fstationssoftware eingebunden
' Dazu mussten einige Elemtente, die direkt auf Excel-Zellen zugreifen entfernt werden
' Zus<75>tzlich wurden alle Variablen deklariert und wenn n<>tig auf "Private" gesetzt
' So sind nach au<61>en nur spezielle Funktionen 'sichtbar'
' Gar nicht verwendete Funktionen wurden der <20>bersichtlichkeit herausgenommen.
'
' Ben<65>tig werden nur der JustageParameter_Type, die Prozedur Justage_Execute mit dazugeh<65>rigen
' internen Funktionen, FloatMSP430_To_DEZ und DEZ_To_FloatMSP430.
'
' Statt einem String "Error: ..." wird bei Fehlern ein Err.Raise ausgef<65>hrt
'
'********************************************************************************************
' Author: Uwe Gro<72>
' Date: 06.08.01
' Description: Ablauf Justage.
' Die Bereichsumschaltung ist nur wirksam, wenn Unlinearit<69>t<>0% gesetzt.
' Bei Nutzung der Bereichsumschaltung mu<6D> .Sollfluss1_m3ph bzw. .Istfluss1_m3ph
' die kleinerern Durchfl<66>sse sein. Au<41>erdem ist der Input dieser beiden Werte nach
' Aufruf mit Nutzung der Bereichsjustage zerst<73>rt.
'
Public Type JustageParameter_Type
' Input:
Sollfluss1_m3ph As Double '---Solldurchflu<6C> unterer Bereich (m<>/h)
Sollfluss2_m3ph As Double '---Solldurchflu<6C> oberer Bereich (m<>/h)
Istfluss1_m3ph As Double '---Istdurchflu<6C> unterer Bereich (m<>/h)
Istfluss2_m3ph As Double '---Istdurchflu<6C> oberer Bereich (m<>/h)
Temperatur1_<EFBFBD>C As Double '---Wassertemperatur am Pr<50>fpunkt 1 (<28>C)
Temperatur2_<EFBFBD>C As Double '---Wassertemperatur am Pr<50>fpunkt 2 (<28>C)
Bereich_ns As Double '---Trennpunkt f<>r Bereich oben/unten [ns]
SteilheitGeber_nsp<EFBFBD>C As Double '---Steilheit Zeroflow [ns/<2F>C]
OffsetGeber_ns As Double '---Offset Zeroflow [ns] wie im <20>C
Unlinearitaet As Double '---weiterer additiver Unlinearit<69>tsfehler am Trennpunkt [%]
' 0% bedeutet damit alte Einstellung (z.B. 3%) bleibt unver<65>ndert
Geberkonstante1_IST_m As Double '---Geberkonstante im unteren Bereich[m]
Offset1_IST_m3ph As Double '---Offset im unteren Bereich [m<>/h]
Geberkonstante2_IST_m As Double '---Geberkonstante im oberen Bereich[m]
Offset2_IST_m3ph As Double '---Offset im oberen Bereich [m<>/h]
Offset_Qmin As Double '---Offset Qmin in %
Offset_QBereich As Double '---Offset QBereich in %
Offset_Qp As Double '---Offset Qp in %
SollFehlerDifferenz_Qmin As Double '---Soll-Fehler-Differenz bei Qmin (Spreizung der Heiss- und Kalt Kurven)
IstFehler_qmin_50<EFBFBD>C As Double ' wird ben<65>tigt in Qmin_Temperaturjustage
' Output:
Geberkonstante_Neu1_m As Double '---Neue Geberkonstante im unteren Bereich[m]
Offset_Neu1_m3ph As Double '---Neuer Offset im unteren Bereich [m<>/h]
Geberkonstante_Neu2_m As Double '---Neue Geberkonstante im oberen Bereich[m]
Offset_Neu2_m3ph As Double '---Neuer Offset im oberen Bereich [m<>/h]
' Zusatzinfo:
JustageArt As String '---Normal, Bereichsjustage, Nachjustage, Temperaturspreizungsjustage
DT1 As Double ' neu RH 5.3.2008
DT2 As Double ' zum analysieren
' neu 2012
OGeber_Roh_Neu_ns As Double 'f<>r das Logfile den neu berechneten O-Geber ohne Offset speichern
OGeber As Double
Fehler1 As Double
Fehler2 As Double
DiffTof1_ns As Double
DiffTof2_ns As Double
OffsetGeber_Neu_ns As Double
End Type
' History: 26.11.01 - Version 8.19 - Uwe Gro<72>: Korrektur bei der Justage mit Bereichsumschaltung
' 04.12.01 - Version 9.1 - Uwe Gro<72>: Korrektur bei der Berechnung BUist; FP_OGeber wird *-1 <20>bergeben
' 02.01.02 - Version 9.7 - Uwe Gro<72>: Korrektur bei der Berechnung BUist; FP_Bereich wird ZeroFlow befreit, wie <20>C
'*******************************************************************************************
Public gudtUSParameter As JustageParameter_Type
'********************************************************************************************
' Author: Uwe Dehne
' Date: 29.04.03
' Description: berechnet den neuen SteilheitGeber mit Hilfe des alten Wertes und
' einer Vorpr<70>fung bei 50<35>C
'
' Input: der Fehler bei einer Vormessung bei qmin und 50<35>C
' der Fehler bei qmin = Definitionsgem<65><6D> Sollfluss1
' die aktuellen Justagewerte aus der Datenbank
'
' Output: SteilheitGeber_nsp<73>C, der neue SteilheitGeber Wert
' Istfluss1_m3ph, der neue Durchflu<6C> wegen des neuen SteilheitGeber Wertes
'
Public Sub Qmin_Temperaturjustage()
' Zwischengr<67><72>en f<>r interne Zwecke
Dim dblStg As Double
Dim dblFst As Double
' Zuerst einmal muessen wir den tats<74>chlichen Versatz der Fehlerkurven bei
' qmin errechnen und um den Wunschversatz korrigieren
' dazu: erst einmal aus den 20<32>C Durchfluessen einen Fehler berechnen
dblStg = (gudtUSParameter.Istfluss1_m3ph - gudtUSParameter.Sollfluss1_m3ph) / gudtUSParameter.Sollfluss1_m3ph
' und nach %
dblStg = dblStg * 100#
DebugMsg "Fehler bei 20<32>C bei Qmin: " & dblStg & " %"
' nun die Differenz berechnen und korrigieren
dblStg = dblStg - gudtUSParameter.IstFehler_qmin_50<EFBFBD>C + gudtUSParameter.SollFehlerDifferenz_Qmin
DebugMsg "Fehlerdifferenz (FehlerQmin20<32>C - FehlerQmin50<35>C + SollSpreizung aus DB) = " & dblStg & " %"
' nun aus der %-Angabe einen echten Durchlfu<66> berechnen
' Bem.: Der ...flu<6C>1 ist per Definition qmin
dblStg = (dblStg / 100) * gudtUSParameter.Sollfluss1_m3ph
DebugMsg "entspricht Durchfluss = " & dblStg & " m<>/h"
' diesen nun in den Zwischenwert Fl<46>chenstrom m<>/h
dblStg = dblStg / gudtUSParameter.Geberkonstante1_IST_m
DebugMsg "Fl<46>chenstrom = " & dblStg & " m<>/h"
' und daraus nun Sekunden berechnen
'
' Bem.: Die Durchflu<6C>ermittelung geht so:
' Q_US_lph = (DiffTof_ns + OGeber_ns + Temperatur_<72>C * STGeber_ns) * 0.000001 _
' * US_Laufzeit(Temperatur_<72>C) ^ 2 * KGeber_m * 3600
' also ergibt sich dann daraus zur<75>ck gerechnet:
' dblFst = 0.000001 * 3600 * (US_Laufzeit(50) ^ 2 - US_Laufzeit(US.Temperatur1_<31>C) ^ 2)
' ACHTUNG: Die Formel oben ergibt ltr/h und wir brauchen m3/h
dblFst = 0.000001 * 3600# * 55# * US_Laufzeit(55) ^ 2
dblFst = dblFst - (0.000001 * 3600# * gudtUSParameter.Temperatur1_<EFBFBD>C * US_Laufzeit(gudtUSParameter.Temperatur1_<EFBFBD>C) ^ 2)
' nun aus dieser Zwischengr<67><72>e ltr/h <20>ber m3/h dann Delta ST_Geber in nSec
dblStg = dblStg * 1000# / dblFst
DebugMsg " Delta ST_Geber = " & dblStg & " nSec"
' und damit jetzt den alten aktuell eingestellten Wert korrigieren
gudtUSParameter.SteilheitGeber_nsp<EFBFBD>C = gudtUSParameter.SteilheitGeber_nsp<EFBFBD>C + dblStg
DebugMsg " neuer ST_Geber = " & gudtUSParameter.SteilheitGeber_nsp<EFBFBD>C & " nSec"
' und jetzt noch den gemessenen qmin-Wert korrigieren wegen des neuen SteiheitGeber
' dazu: das resultierende Delta berechnen
dblFst = dblStg * gudtUSParameter.Temperatur1_<EFBFBD>C * 0.000001 * US_Laufzeit(gudtUSParameter.Temperatur1_<EFBFBD>C) ^ 2 _
* gudtUSParameter.Geberkonstante1_IST_m * 3600#
' ACHTUNG: Das sind jetzt ltr/h, daraus also m3/h machen:
dblFst = dblFst / 1000
' ich hoffe es ist ab jetzt wieder alles in m3/h
' in dieser Version nicht notwendig
' dblFst = dblFst / gudtUSParameter.Sollfluss1_m3ph
' dblFst = dblFst / 1000 ' nach ltr/h
' dblFst = dblFst * 100 ' nach %
DebugMsg "Korrekturwert Qmin (kalt) = " & dblFst & " m<>/h"
' und damit jetzt noch den Istdurchfluss korrigieren
gudtUSParameter.Istfluss1_m3ph = gudtUSParameter.Istfluss1_m3ph + dblFst
DebugMsg "neuer Qmin (kalt) = " & gudtUSParameter.Istfluss1_m3ph & " m<>/h"
End Sub
'********************************************************************************************
Public Sub Justage_Execute()
If gudtUSParameter.Unlinearitaet = 0 Then '---keine Bereichsumschaltung
'---normale Justage berechnen
gudtUSParameter.Geberkonstante_Neu1_m = Geberkonstante_m(gudtUSParameter.Geberkonstante1_IST_m)
gudtUSParameter.Offset_Neu1_m3ph = Offset_m3ph(gudtUSParameter.Offset1_IST_m3ph)
gudtUSParameter.Geberkonstante_Neu2_m = Geberkonstante_m(gudtUSParameter.Geberkonstante2_IST_m)
gudtUSParameter.Offset_Neu2_m3ph = Offset_m3ph(gudtUSParameter.Offset2_IST_m3ph)
Else '---Berechnung der Bereichsumschaltung in m<>/h
Dim DiffTof As Double
Dim BUist As Double
Dim BUsoll As Double
Dim TempSoll As Double
Dim TempIst As Double
'---Berechnung DiffTof f<>r Bereichsumschaltung
DiffTof = gudtUSParameter.Bereich_ns + gudtUSParameter.OffsetGeber_ns - gudtUSParameter.SteilheitGeber_nsp<EFBFBD>C * gudtUSParameter.Temperatur1_<EFBFBD>C
'---BUsoll/ist mit Justageparameter unten und Temperatur unten
BUist = Q_US_lph(DiffTof, -gudtUSParameter.OffsetGeber_ns, gudtUSParameter.Temperatur1_<EFBFBD>C, gudtUSParameter.Geberkonstante1_IST_m, gudtUSParameter.SteilheitGeber_nsp<EFBFBD>C, gudtUSParameter.Offset1_IST_m3ph * 1000) / 1000
BUsoll = BUist + gudtUSParameter.Unlinearitaet * BUist
'Zwischenspeicherung
TempSoll = gudtUSParameter.Sollfluss2_m3ph
TempIst = gudtUSParameter.Istfluss2_m3ph
'Justage vom Bereichsumschaltpunkt bis Pr<50>fpkt. unten
gudtUSParameter.Sollfluss2_m3ph = BUsoll '---oberer Pr<50>fpkt. ist jetzt die Bereichsumschaltung
gudtUSParameter.Istfluss2_m3ph = BUist
gudtUSParameter.Geberkonstante_Neu1_m = Geberkonstante_m(gudtUSParameter.Geberkonstante1_IST_m)
gudtUSParameter.Offset_Neu1_m3ph = Offset_m3ph(gudtUSParameter.Offset1_IST_m3ph)
'---Zwischenspeicherung r<>ckg<6B>ngig
gudtUSParameter.Sollfluss2_m3ph = TempSoll
gudtUSParameter.Istfluss2_m3ph = TempIst
'Justage vom Trennpunkt bis Pr<50>fpkt. oben
'---Berechnung DiffTof f<>r Bereichsumschaltung
DiffTof = gudtUSParameter.Bereich_ns + gudtUSParameter.OffsetGeber_ns - gudtUSParameter.SteilheitGeber_nsp<EFBFBD>C * gudtUSParameter.Temperatur2_<EFBFBD>C
'---BUsoll mit Justageparameter oben und Temperatur oben
BUist = Q_US_lph(DiffTof, -gudtUSParameter.OffsetGeber_ns, gudtUSParameter.Temperatur2_<EFBFBD>C, gudtUSParameter.Geberkonstante2_IST_m, gudtUSParameter.SteilheitGeber_nsp<EFBFBD>C, gudtUSParameter.Offset2_IST_m3ph * 1000) / 1000
BUsoll = BUist + gudtUSParameter.Unlinearitaet * BUist
'---Zwischenspeicherung und Justage vom Trennpunkt bis Pr<50>fpkt. oben
TempSoll = gudtUSParameter.Sollfluss1_m3ph
TempIst = gudtUSParameter.Istfluss1_m3ph
gudtUSParameter.Sollfluss1_m3ph = BUsoll '---unterer Pr<50>fpkt. ist jetzt die Bereichsumschaltung
gudtUSParameter.Istfluss1_m3ph = BUist
gudtUSParameter.Geberkonstante_Neu2_m = Geberkonstante_m(gudtUSParameter.Geberkonstante2_IST_m)
gudtUSParameter.Offset_Neu2_m3ph = Offset_m3ph(gudtUSParameter.Offset2_IST_m3ph)
'---Zwischenspeicherung r<>ckg<6B>ngig
gudtUSParameter.Sollfluss1_m3ph = TempSoll
gudtUSParameter.Istfluss1_m3ph = TempIst
End If
End Sub
'*******************************************************************************************
' Author: Uwe Gro<72> (Invensys Metering Systems)
' Date: 31.07.2002
' Description: Algorithmus zur ZeroFlow Justage.
' ZU <20>BERPR<50>FEN: Wie wirkt sich FP_St_Geber ungleich 0 aus!!!!!!!!
' --------------
'
' Input: Definition der Justage Parameter und Pr<50>fpunkte im Global US:
' -------------------------------------------------------------
' .Sollfluss1_m3ph As Single '---Solldurchflu<6C> unterer Bereich (m<>/h)
' .Sollfluss2_m3ph As Single '---Solldurchflu<6C> oberer Bereich (m<>/h)
' .Istfluss1_m3ph As Single '---Istdurchflu<6C> unterer Bereich (m<>/h)
' .Istfluss2_m3ph As Single '---Istdurchflu<6C> oberer Bereich (m<>/h)
' .Temperatur1_<31>C As Single '---Wassertemperatur am Pr<50>fpunkt 1 (<28>C)
' .Temperatur2_<32>C As Single '---Wassertemperatur am Pr<50>fpunkt 2 (<28>C)
' .Geberkonstante1_IST_m As Double '---Geberkonstante im unteren Bereich[m]
' .Offset1_IST_m3ph As Double '---Offset im unteren Bereich [m<>/h]
' .Geberkonstante2_IST_m As Double '---Geberkonstante im oberen Bereich[m]
' .Offset2_IST_m3ph As Double '---Offset im oberen Bereich [m<>/h]
' .Bereich_ns As Double '---Trennpunkt f<>r Bereich oben/unten [ns] nach ZeroFlowJustage
' .SteilheitGeber_nsp<73>C As Double '---Steilheit Zeroflow [ns/<2F>C]
' .OffsetGeber_ns As Double '---Offset Zeroflow [ns] wie im <20>C
' .Unlinearitaet As Single '---weiterer additiver Unlinearit<69>tsfehler am Trennpunkt [%]
' 0% bedeutet damit alte Einstellung (z.B. 3%) bleibt unver<65>ndert
' Output:
' .Geberkonstante_Neu1_m As Double '---Neue Geberkonstante im unteren Bereich[m]
' .Offset_Neu1_m3ph As Double '---Neuer Offset im unteren Bereich [m<>/h]
' .Geberkonstante_Neu2_m As Double '---Neue Geberkonstante im oberen Bereich[m]
' .Offset_Neu2_m3ph As Double '---Neuer Offset im oberen Bereich [m<>/h]
' .SteilheitGeber_nsp<73>C '---Input ZeroFlowSteilheit auf 0 [ns/<2F>C]
' .OffsetGeber_ns '---Input ZeroFlowOffset neu berechnet [ns]
'
' History: 08.08.02: Fehler bei der Toleranzabfrage f<>r FP_O_Geber korregiert.
' 13.08.02: Input f<>r ZeroFlowOffset_ErmitteltAusEinerTemperatur um US.SteilheitGeber_nsp<73>C und mittlere Temperatur erweitert
'*****************************************************************************************
Public Sub Justage_mit_ZeroFlow()
Dim DT1 As Double
Dim DT2 As Double
With gudtUSParameter
'---DiffToff aus den alten Justageparametern f<>r die Pr<50>fpunkte bestimmen
DT1 = Diff_Tof(.Istfluss1_m3ph * 1000, .Temperatur1_<EFBFBD>C, .Geberkonstante2_IST_m, .Offset2_IST_m3ph * 1000, .Geberkonstante1_IST_m, .Offset1_IST_m3ph * 1000, -.OffsetGeber_ns, .SteilheitGeber_nsp<EFBFBD>C, .Bereich_ns)
DT2 = Diff_Tof(.Istfluss2_m3ph * 1000, .Temperatur2_<EFBFBD>C, .Geberkonstante2_IST_m, .Offset2_IST_m3ph * 1000, .Geberkonstante1_IST_m, .Offset1_IST_m3ph * 1000, -.OffsetGeber_ns, .SteilheitGeber_nsp<EFBFBD>C, .Bereich_ns)
.DT1 = DT1
.DT2 = DT2
'---Berechnung des ZeroFlowOffset aus den beiden Justagepunkten f<>r eine Temperatur
.OffsetGeber_ns = ZeroFlowOffset_ErmitteltAusEinerTemperatur(DT1, DT2, .Sollfluss1_m3ph, .Sollfluss2_m3ph, .SteilheitGeber_nsp<EFBFBD>C, (.Temperatur1_<EFBFBD>C + .Temperatur2_<EFBFBD>C) / 2)
'---Berechnung des Istdurchfluss1&2 bei Verwendung des neuen ZeroFlowOffset
.Istfluss1_m3ph = Q_US_Bereich_lph(DT1, -.OffsetGeber_ns, .Temperatur1_<EFBFBD>C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp<EFBFBD>C, .Offset1_IST_m3ph * 1000, .Offset2_IST_m3ph * 1000, .Bereich_ns) / 1000
.Istfluss2_m3ph = Q_US_Bereich_lph(DT2, -.OffsetGeber_ns, .Temperatur2_<EFBFBD>C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp<EFBFBD>C, .Offset1_IST_m3ph * 1000, .Offset2_IST_m3ph * 1000, .Bereich_ns) / 1000
End With
'---hydraulische Justage, damit mit dem neuen ZeroFlowOffset
'---die Pr<50>fpunkte1&2 zu 0% Fehler f<>hren.
End Sub
'********************************************************************************************
' Author: Uwe Gro<72>
' Date: 22.03.2001
' Description: Bestimmt Offset und Geberkonstante aus 2 Fehlermessungen
'
' Input: Sollfluss1_m3ph : Solldurchflu<6C> 1 (m<>/h)
' Sollfluss2_m3ph : Solldurchflu<6C> 2 (m<>/h)
' Istfluss1_m3ph : Istdurchflu<6C> 1 (m<>/h)
' Istfluss2_m3ph : Istdurchflu<6C> 2 (m<>/h)
' Geberkonstante_IST_m : Geberkonstante [m]
' Offset_IST_m3ph : Offset DiffToff bei Zeroflow [m<>/h]
' Output: Geberkonstante_m : neuer Geberkonstante [m]
' Offset_m3ph : neuer Offset DiffToff bei Zeroflow [m<>/h]
'
' History: 10.05.01 - Version 4.9 - Uwe Gro<72>: Anpassung auf Temperaturkompensation der US-Laufzeit
' 14.05.01 - Version 4.10 -Uwe Gro<72>: Berechnungsfehler beseitigt
' 14.05.01 - Version 8.0 -Uwe Gro<72>: Neue Justage mit Offset_m3ph, dadurch sind die Temperaturen
' als Input nicht mehr n<>tig
' 06.08.01 - Version 8.5 - Uwe Gro<72>: Die meisten Inputs durch Globals ersetzt
'*******************************************************************************************
Function Geberkonstante_m(Geberkonstante_IST_m As Double) As Double
' OK wie bei Deplhi, kontrolliert von RH am 5.3.2008
Geberkonstante_m = Geberkonstante_IST_m * (gudtUSParameter.Sollfluss1_m3ph - gudtUSParameter.Sollfluss2_m3ph) / (gudtUSParameter.Istfluss1_m3ph - gudtUSParameter.Istfluss2_m3ph)
End Function
Function Offset_m3ph(Offset_IST_m3ph As Double) As Double
' OK wie bei Deplhi, kontrolliert von RH am 5.3.2008
Offset_m3ph = (gudtUSParameter.Sollfluss2_m3ph * (gudtUSParameter.Istfluss1_m3ph - Offset_IST_m3ph) - gudtUSParameter.Sollfluss1_m3ph * (gudtUSParameter.Istfluss2_m3ph - Offset_IST_m3ph)) / (gudtUSParameter.Istfluss1_m3ph - gudtUSParameter.Istfluss2_m3ph)
End Function
'********************************************************************************************
' Author: Uwe Gro<72>
' Date: 22.02.2001
' Description: Bestimmt den die Laufzeit US in Wasser in Abh<62>ngigkeit der Temperatur
'
' Input: Temperatur: Temperatur des Wassers in <20>C
' Output: Schalllaufzeit in m/s
'
'*******************************************************************************************
Function US_Laufzeit(Temperatur)
' OK wie bei Deplhi, kontrolliert von RH am 5.3.2008
Const k0 = 1402.38754
Const k1 = 5.03711129
Const k2 = -0.0580852166
Const k3 = 0.000334198834
Const k4 = -0.00000147800417
Const k5 = 3.14643091E-09
US_Laufzeit = k0 + k1 * Temperatur + k2 * Temperatur ^ 2 + k3 * Temperatur ^ 3 + k4 * Temperatur ^ 4 + k5 * Temperatur ^ 5
End Function
'********************************************************************************************
' Author: Uwe Gro<72>
' Date: 31.01.2001
' Description: Bestimmt den Durchflu<6C> f<>r US2000
'
' Input: DiffTof_ns : Laufzeitdifferenz in ns
' OGeber_ns : Offset Geber in ns (Achtung im <20>C ist dieser Wert * -1)
' Temperatur_<72>C: Wassertemperatur in <20>C
' KGeber_m : Geberkonsante in m aus Querschnitt/2/Wandlerabstand
' STGeber_ns : temperaturabh<62>ngige Steilheit f<>r DiffTof_ns
' OFlow_lph : temperaturunabh<62>nige Offsetkorrektur in l/h
'
' Output: Ergebnis in l/h
'
' History: 15.05.01 neue Berechnungsformel mit US-Laufzeit aus Temperatur ermittelt
' 19.06.01 temperaturunabh<62>ngiger Offset und Unlinearit<69>tsausgleich hinzugef<65>gt
' 06.08.01 temperaturabh<62>ngige Steilheit f<>r DiffTof_ns hinzugef<65>gt
' UnLinAbgl entfernt
'*******************************************************************************************
Function Q_US_lph(DiffTof_ns As Double, OGeber_ns As Double, Temperatur_<EFBFBD>C As Double, KGeber_m As Double, STGeber_ns As Double, OFlow_lph As Double) As Double
'--Durchflu<6C>ermittelung nach konventioneller Art
Q_US_lph = (DiffTof_ns + OGeber_ns + Temperatur_<EFBFBD>C * STGeber_ns) * 0.000001 _
* US_Laufzeit(Temperatur_<EFBFBD>C) ^ 2 * KGeber_m * 3600
'--temperaturunabh<62>ngiger Offset
Q_US_lph = OFlow_lph + Q_US_lph
End Function
'********************************************************************************************
' Author: Uwe Gro<72>
' Date: 02.01.2002
' Description: Bestimmt den Durchflu<6C> f<>r US2000 mit Bereichsumschaltung
'
' Input: DiffTof_ns : Laufzeitdifferenz in ns
' OGeber_ns : Offset Geber in ns (Achtung im <20>C ist dieser Wert * -1)
' Temperatur_<72>C: Wassertemperatur in <20>C
' KGeberUNTEN_m : Geberkonstante in m f<>r unteren Bereich
' KGeberOBEN_m : Geberkonstante in m f<>r oberen Bereich
' STGeber_ns : temperaturabh<62>ngige Steilheit f<>r DiffTof_ns
' OFlowUNTEN_lph : temperaturunabh<62>nige Offsetkorrektur in l/h f<>r unteren Bereich
' OFlowOBEN_lph : temperaturunabh<62>nige Offsetkorrektur in l/h f<>r oberen Bereich
' Bereich_ns : Bereichsumschaltung in ns
' k0 bis k5 Koeffizienten 5. Ordnung f<>r US-Laufzeitkompensation
'
' Output: Ergebnis in l/h
'
' History: 12.06.02 US-LZ Koeffizienten als Input entfernt
' 09.08.02 Definition des Inputs als Single bzw. Double sonst Absturz bei undefiniertem Input
'*******************************************************************************************
Function Q_US_Bereich_lph(DiffTof_ns As Double, OGeber_ns As Double, Temperatur_<EFBFBD>C As Double, KGeberUNTEN_m As Double, KGeberOBEN_m As Double, STGeber_ns As Double, OFlowUNTEN_lph As Double, OFlowOBEN_lph As Double, Bereich_ns As Double) As Double
Dim DT As Double
'---DiffTof in ns nach ZeroFlow Korrektur
DT = (DiffTof_ns + OGeber_ns + Temperatur_<EFBFBD>C * STGeber_ns)
'--Durchflu<6C>ermittelung
If DT < Bereich_ns Then
Q_US_Bereich_lph = DT * 0.000001 * US_Laufzeit(Temperatur_<EFBFBD>C) ^ 2 * KGeberUNTEN_m * 3600 + OFlowUNTEN_lph
Else
Q_US_Bereich_lph = DT * 0.000001 * US_Laufzeit(Temperatur_<EFBFBD>C) ^ 2 * KGeberOBEN_m * 3600 + OFlowOBEN_lph
End If
End Function
'********************************************************************************************
' Author: Uwe Gro<72>
' Date: 25.09.2001
' Description: Bestimmt aus dem Durchflu<6C> ein mittleres Diff_Tof
'
' Input: Durchflu<6C>_lph: Laufzeitdifferenz in ns
' Temperatur_<72>C: Wassertemperatur in <20>C
' KGeber_m : Geberkonsante in m aus Querschnitt/2/Wandlerabstand
' OFlow_lph : temperaturunabh<62>nige Offsetkorrektur in l/h
' O_Geber_ns : temperaturabh<62>ngige Offsetkorrektur in ns (Achtung im <20>C ist dieser Wert * -1)
' ST_Geber_nsPerGradC: temperaturabh<62>ngige Steilheitskorrektur in ns/<2F>C
' Output: Ergebnis in ns
'
' History: 16.11.01 O_Geber_ns und ST_Geber_nsPerGradC als zus<75>tzlicher Input
' 22.11.01 Bereichumschaltung eingef<65>gt und Input entsprechend erweitert
' 11.01.02 US-LZ Koeffizienten als Input aufgenommen
' 12.06.02 US-LZ Koeffizienten als Input wieder entfernt
' 09.08.02 Definition des Inputs als Single bzw. Double sonst Absturz bei undefiniertem Input
'*******************************************************************************************
Private Function Diff_Tof(Durchflu<EFBFBD>_lph As Double, _
Temperatur_<EFBFBD>C As Double, _
KGeberOBEN_m As Double, _
OFlowOBEN_lph As Double, _
KGeberUNTEN_m As Double, _
OFlowUNTEN_lph As Double, _
O_Geber_ns As Double, _
ST_Geber_nsPerGradC As Double, _
Bereich_ns As Double) As Double
Dim Diff_TofOben As Double
Dim Diff_TofUnten As Double
Diff_TofOben = ((Durchflu<EFBFBD>_lph - OFlowOBEN_lph) / 3600000 / KGeberOBEN_m / US_Laufzeit(Temperatur_<EFBFBD>C) ^ 2 * 1000000000#)
Diff_TofUnten = ((Durchflu<EFBFBD>_lph - OFlowUNTEN_lph) / 3600000 / KGeberUNTEN_m / US_Laufzeit(Temperatur_<EFBFBD>C) ^ 2 * 1000000000#)
If Diff_TofUnten < Bereich_ns Then
Diff_Tof = Diff_TofUnten - O_Geber_ns - ST_Geber_nsPerGradC * Temperatur_<EFBFBD>C
Else
Diff_Tof = Diff_TofOben - O_Geber_ns - ST_Geber_nsPerGradC * Temperatur_<EFBFBD>C
End If
End Function
'********************************************************************************************
' Author: Uwe Gro<72>
' Date: 31.07.2002
' Description: Bestimmt den ZeroFlow Offset aus dem Input bei gleicher Temperatur.
' Die Temperatur f<>r Sollfluss1_m3ph und Sollfluss2_m3ph mu<6D> ungef<65>hr
' (ca. +-5<>C) gleich sein.
' Input: DiffTof1_ns : DiffTof bei Sollfluss1_m3ph [ns]
' DiffTof2_ns : DiffTof bei Sollfluss2_m3ph [ns]
' Sollfluss1_m3ph : Solldurchflu<6C> unterer Bereich (m<>/h)
' Sollfluss2_m3ph : Solldurchflu<6C> oberer Bereich (m<>/h)
' SteilheitGeber_nsp<73>C: ZeroFlow Steilheit [ns/<2F>C]
' Temperatur_<72>C : mittlere Temperatur der Pr<50>fpkt. Sollfluss1_m3ph und Sollfluss2_m3ph
' Output:
' History: 13.08.2002 Version 9.16: Fehler im Quotienten Sollfluss2 mit Sollfluss1 vertauscht.
' Input um SteilheitGeber_nsp<73>C und Temperatur_<72>C erweitert und
' im Algorithmus ber<65>cksichtigt.
'*******************************************************************************************
Private Function ZeroFlowOffset_ErmitteltAusEinerTemperatur(DiffTof1_ns As Double, _
DiffTof2_ns As Double, _
Sollfluss1_m3ph As Double, _
Sollfluss2_m3ph As Double, _
SteilheitGeber_nsp<EFBFBD>C As Double, _
Temperatur_<EFBFBD>C As Double)
ZeroFlowOffset_ErmitteltAusEinerTemperatur = (Sollfluss2_m3ph * DiffTof1_ns - Sollfluss1_m3ph * DiffTof2_ns) / _
(Sollfluss2_m3ph - Sollfluss1_m3ph) + Temperatur_<EFBFBD>C * SteilheitGeber_nsp<EFBFBD>C
End Function
'********************************************************************************************
' Author: Uwe Gro<72>
' Date: 19.02.2001
' Description: Wandelt eine positive Dezimalzahl in eine Hexdezimale Zahl
'
' Input: Dezimalzahl >0
' Stellen_Anzahl > 1 der Hexadezimalen Zahl
' Output: Hexadezimale Zahl
'
' History:
'*******************************************************************************************
Public Function Positive_HexWandelung(Dezimalzahl As Long, Stellen_Anzahl As Long) As String
'Checken des Input-Bereiches
If Dezimalzahl >= 16 ^ Stellen_Anzahl Then
'Positive_HexWandelung = "OVERFLOW"
Err.Raise 0, "Positive_HexWandelung", "OVERFLOW"
Exit Function
End If
Stellen_Anzahl = Int(Stellen_Anzahl) - 1
If (Dezimalzahl < 0 Or Stellen_Anzahl < 0) Then
'Positive_HexWandelung = "ERROR"
Err.Raise 0, "Positive_HexWandelung", "ERROR"
Exit Function
End If
Dim i As Integer
Dim A As Long
If Positive_HexWandelung = "" Then '---Weiter wenn kein Input Fehler vorliegt
For i = Stellen_Anzahl To 0 Step -1
A = 0
Do While Dezimalzahl - 16 ^ i >= 0
Dezimalzahl = Dezimalzahl - 16 ^ i
A = A + 1
Loop
Positive_HexWandelung = Positive_HexWandelung + Hex(A)
Next i
End If
End Function
'********************************************************************************************
' Author: Uwe Gro<72>
' Date: 21.02.2001
' Description: Wandelt eine Hexdezimale Zahl in eine Dezimalzahl mit Beachtung des Vorzeichens
' Ist das MSB=1 wird die HexZahl als negative Zahl im 2er Komplement betrachtet
' Input: Hexzahl
' Output: Dezimalzahl vorzeichenbehaftet
'
' History:
'*******************************************************************************************
Private Function Vorzeichen_DezWandelung(strHexZahl As String) As Long
Dim lngReturn As Long
'8. Bit von rechts auf 1 - bzw. hier 4. Bit von rechts in einem Nibbel
lngReturn = CLng("&H" & strHexZahl)
If (CLng("&h" + Left$(strHexZahl, 1)) And 8) = 8 Then
'Hexzahl ist negativ - entsprechend der L<>nge der HexZahl FFFFF+1 abziehen
lngReturn = lngReturn - (CLng("&H" & (String$(Len(strHexZahl), "F"))) + 1)
End If
Vorzeichen_DezWandelung = lngReturn
End Function
'********************************************************************************************
' Author: Uwe Gro<72>
' Date: 18.04.2001
' Description: Wandelt eine Float-Zahl MSP430 Format in eine
' gebrochene Dezimalzahl
' Input: FloatMSP430: Hexadezimale Zahl im Format "XXXXXXXX" als String mit:
' e ,sn, m
' 31...24,23,22....0
' Output: FloatMSP430_To_DEZ=-1^sn*(1+M/2^23)*2^(e-128)
' mit sn=-1^s entspricht -1 und sn=0 entspricht +1
' History: 18.09.01 - Uwe Gro<72> - FloatMSP430 = "00000000" f<>hrt zu 0,00
'*******************************************************************************************
Public Function FloatMSP430_To_DEZ(FloatMSP430 As String) As Double
Dim sn As Integer
Dim m As Double
Dim e As Double
If Len(FloatMSP430) <> 8 Then
'FloatMSP430_To_DEZ = "Error: Length<>8"
Err.Raise "0", "FloatMSP430_To_DEZ", "Length<>8"
Else
If FloatMSP430 = "00000000" Then
FloatMSP430_To_DEZ = 0
Else
'--Bestimmung des Vorzeichens
sn = Int("&h" + Mid$(FloatMSP430, 3, 1)) And 8
If sn = 0 Then
sn = 1
Else
sn = -1
End If
'--Berechnung des Exponenten von 2
e = (Int("&h" + Mid$(FloatMSP430, 1, 2))) - 128
'--Berechnung der Mantisse
m = (Int("&h" + Mid$(FloatMSP430, 3, 6)) And &H7FFFFF) / (2 ^ 23) + 1
'--Berechnung der gebrochenen Dezimalzahl
FloatMSP430_To_DEZ = sn * m * (2 ^ e)
End If
End If
End Function
'********************************************************************************************
' Author: Uwe Gro<72>
' Date: 18.04.2001
' Description: Wandelt eine gebrochene Dezimalzahl in eine
' Float-Zahl MSP430 Format
' Input: Dezimal: gebrochene Dezimalzahl
' Output: DEZ_To_FloatMSP430 im Format "XXXXX" als String mit:
' e ,sn, m
' 40...24,23,22....0
' mit sn=1 entspricht -1 und sn=0 entspricht +1
' History: 12.06.01 (Uwe Gro<72>) Abfrage auf m >=; zus<75>tzlich kommentiert in Source
'*******************************************************************************************
Public Function DEZ_To_FloatMSP430(Dezimal As Double) As String
Dim sn As Long
Dim e As Long
Dim m As Double
'--Bestimmung des Vorzeichens
If Dezimal < 0 Then
sn = 2 ^ 23
Dezimal = Dezimal * -1
Else
sn = 0
End If
'--Bestimmung des Exponenten von 2 und der Mantisse
If Dezimal <> 0 Then
e = 0
m = Dezimal * 2 ^ 151
'---<2D>nderung 12.06.01/Uwe Gro<72> Abfrage auf m >=
Do While (m >= 2 ^ 24) '---max. Mantisse + 2^23
m = m / 2
e = e + 1
Loop
m = Dezimal * 2 ^ (151 - e) - 2 ^ 23
m = sn + m '---Vorzeichen verheiraten
Else
e = 0
End If
'--Bestimmung des hexadezimalen String f<>r MSP430 float format
If e > 255 Then
'DEZ_To_FloatMSP430 = "Error: Overflow"
Err.Raise 0, "DEZ_To_FloatMSP430", "Overflow"
Else
DEZ_To_FloatMSP430 = Right$("0" + Hex$(e), 2) + _
Right$("000000" + Hex$(m), 6)
' a = Hex$(m)
End If
End Function
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' neu RH 6.1.2011
'{*******************************************************************************
'Author: Frank Leidel
'Datum: 12.11.2011
'Beschreibung: Rechnet den Offset zum neuen O-Geber hinzu
'Input: Offset_m3ph : Offset in m<>/h
'KGeber_m : Geberkonstante in m
'OGeber_ns : O-Geber in ns
'Temperatur : Wassertemperatur in <20>C
'Output: Ergebnis in ns
'*******************************************************************************}
Public Function OffsetZumOGeber_ns(Offset_m3ph As Double, KGeber_m As Double, OGeber_ns, Temperatur As Double) As Double
Dim Laufzeit As Double
Laufzeit = US_Laufzeit(Temperatur)
OffsetZumOGeber_ns = (Offset_m3ph / ((Laufzeit * Laufzeit) * KGeber_m * 3600) * (-1)) * 1000000000 + OGeber_ns
End Function
' hinzugef<65>gt am 6.1.2012 von R.Henning:
'{*******************************************************************************
'Author: Uwe Gro<72>
'Datum: 22.03.2001
'Beschreibung: Berechnung Geberkonstanten und Offsets
'Input: EPS : Einzelpr<70>fstandsnummer
'*******************************************************************************}
Public Sub Justage_Execute_FW2()
With gudtUSParameter
'//---normale Justage berechnen
'Geberkonstante_Neu1_m := Geberkonstante_m(EPS, Geberkonstante1_IST_m);
.Geberkonstante_Neu1_m = Geberkonstante_m(.Geberkonstante1_IST_m)
'Geberkonstante_Neu2_m := Geberkonstante_m(EPS, Geberkonstante2_IST_m);
.Geberkonstante_Neu2_m = Geberkonstante_m(.Geberkonstante2_IST_m)
' Offset1_Neu_m3ph := Offset_m3ph(EPS, Offset1_IST_m3ph);
.Offset_Neu1_m3ph = Offset_m3ph(.Offset1_IST_m3ph)
' Offset2_Neu_m3ph := Offset_m3ph(EPS, Offset2_IST_m3ph);
.Offset_Neu2_m3ph = Offset_m3ph(.Offset2_IST_m3ph)
' // ---- ab hier neue Justage ----------------------------------------
' // f<>r das Logfile den neu berechneten O-Geber ohne Offset speichern
' OGeber_Roh_Neu_ns := OffsetGeber_Neu_ns;
''' .OGeber_Roh_Neu_ns = .OffsetGeber_ns
.OGeber_Roh_Neu_ns = .OffsetGeber_Neu_ns
' Korrektur RH 18.9.2013 mit F.Leidel:
.OffsetGeber_Neu_ns = 0
' Korrektur RH 18.9.2013 mit F.Leidel:
' ' // Offset zum O-Geber hinzu rechnen
' ' OffsetGeber_Neu_ns := OffsetZumOGeber_ns(Offset1_Neu_m3ph, Geberkonstante1_IST_m,OffsetGeber_Neu_ns, Temperatur1);
' ' .OffsetGeber_Neu_ns = OffsetZumOGeber_ns(.Offset_Neu1_m3ph, .Geberkonstante1_IST_m, .OffsetGeber_Neu_ns, .Temperatur1_<31>C)
' RH: wieso eigentlich nur Temperatur1?
'// Offset nullen
'Offset1_Neu_m3ph := 0;
.Offset_Neu1_m3ph = 0
'Offset2_Neu_m3ph := 0;
.Offset_Neu2_m3ph = 0
.OffsetGeber_ns = .OffsetGeber_Neu_ns
End With
End Sub
'{*******************************************************************************
'Author: Uwe Gro<72>
'Datum: 15.08.2002
'Beschreibung: Berechnung Zeroflow
'Input: EPS : Einzelpr<70>fstandsnummer
'*******************************************************************************}
Public Sub Justage_mit_Zeroflow_FW2()
Dim DT_1 As Double
Dim DT_2 As Double
Dim OGeber As Double
With gudtUSParameter
If (.DiffTof1_ns < 0.01) And (.DiffTof2_ns < 0.01) Then
' // DiffToff aus den alten Justageparametern f<>r die Pr<50>fpunkte bestimmen
'DT1 := Diff_Tof(IstFluss1_m3ph * 1000, Temperatur1, GeberKonstante2_Ist_m,Offset2_Ist_m3ph * 1000, GeberKonstante1_Ist_m, Offset1_Ist_m3ph * 1000,-OffsetGeber_ns, SteilheitGeber_nspC, Bereich_ns);
.DT1 = Diff_Tof(.Istfluss1_m3ph * 1000, .Temperatur1_<EFBFBD>C, .Geberkonstante2_IST_m, .Offset2_IST_m3ph * 1000, .Geberkonstante1_IST_m, .Offset1_IST_m3ph * 1000, -.OffsetGeber_ns, .SteilheitGeber_nsp<EFBFBD>C, .Bereich_ns)
'DT2 := Diff_Tof(IstFluss2_m3ph * 1000, Temperatur2, GeberKonstante2_Ist_m,Offset2_Ist_m3ph * 1000, GeberKonstante1_Ist_m, Offset1_Ist_m3ph * 1000,-OffsetGeber_ns, SteilheitGeber_nspC, Bereich_ns);
.DT2 = Diff_Tof(.Istfluss2_m3ph * 1000, .Temperatur2_<EFBFBD>C, .Geberkonstante2_IST_m, .Offset2_IST_m3ph * 1000, .Geberkonstante1_IST_m, .Offset1_IST_m3ph * 1000, -.OffsetGeber_ns, .SteilheitGeber_nsp<EFBFBD>C, .Bereich_ns)
'// neu !!! DiffTof um der Fehler ver<65>ndern
'DT_1 := DT1 * (100 - Fehler1) / 100;
DT_1 = .DT1 * (100 - .Fehler1) / 100
'DT_2 := DT2 * (100 - Fehler2) / 100;
DT_2 = .DT2 * (100 - .Fehler2) / 100
'// f<>r das Logfile die berenteten DiffTofs als negativen Wert speichern
'DiffTof1_ns := DT1 * (-1);
.DiffTof1_ns = .DT1 * (-1)
'DiffTof2_ns := DT2 * (-1);
.DiffTof2_ns = .DT2 * (-1)
Else
'// gemessene DiffTof <20>bernehmen
.DT1 = .DiffTof1_ns
.DT2 = .DiffTof2_ns
End If
'// Berechnung des ZeroFlowOffset aus den beiden Justagepunkten f<>r einer
'// Temperatur
'// OffsetGeber_Neu_ns := ZeroFlowOffset_ErmittelnAusEinerTemperatur(DT1, DT2, Sollfluss1_m3ph, Sollfluss2_m3ph, SteilheitGeber_nspC,(Temperatur1 + Temperatur2) / 2); Diese Funktion bitte entfernen! FL
'// .OffsetGeber_Neu_ns = ZeroFlowOffset_ErmitteltAusEinerTemperatur(.DT1, .DT2, .Sollfluss1_m3ph, .Sollfluss2_m3ph, .SteilheitGeber_nsp<73>C, (.Temperatur1_<31>C + .Temperatur2_<32>C) / 2)
' ' Geraden-Abgleich
' 'OGeber := ZeroFlowOffset_ErmittelnAusEinerTemperatur(DT_1, DT_2, Sollfluss1_m3ph, Sollfluss2_m3ph, SteilheitGeber_nspC,(Temperatur1 + Temperatur2) / 2);
' .OGeber = ZeroFlowOffset_ErmitteltAusEinerTemperatur(DT_1, DT_2, .Sollfluss1_m3ph, .Sollfluss2_m3ph, .SteilheitGeber_nsp<73>C, (.Temperatur1_<31>C + .Temperatur2_<32>C) / 2)
' Korrektur RH mit F.Leidel am 18.9.2013
' o_geber_roh in Nano sekunden
.OffsetGeber_Neu_ns = ZeroFlowOffset_ErmitteltAusEinerTemperatur(.DT1, .DT2, .Sollfluss1_m3ph, .Sollfluss2_m3ph, .SteilheitGeber_nsp<EFBFBD>C, (.Temperatur1_<EFBFBD>C + .Temperatur2_<EFBFBD>C) / 2)
' Korrektur RH mit F.Leidel am 18.9.2013
''OffsetGeber_Neu_ns := DT1 - DT_1 + OffsetGeber_ns + OGeber '' Hier stand ein falscher Variabelname;
''.OffsetGeber_Neu_ns = .DT1 - DT_1 + .OffsetGeber_ns + .OGeber
'// Berechnung des Istdurchfluss1&2 bei Verwendung des neuen ZeroFlowOffset
'IstFluss1_m3ph := Q_US_Bereich_lph(DT1, -OffsetGeber_Neu_ns, Temperatur1, GeberKonstante1_Ist_m,GeberKonstante2_Ist_m, SteilheitGeber_nspC, Offset1_Ist_m3ph * 1000,Offset2_Ist_m3ph * 1000, Bereich_ns) / 1000;
.Istfluss1_m3ph = Q_US_Bereich_lph(.DT1, -.OffsetGeber_Neu_ns, .Temperatur1_<EFBFBD>C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp<EFBFBD>C, .Offset1_IST_m3ph * 1000, .Offset2_IST_m3ph * 1000, .Bereich_ns) / 1000
'IstFluss2_m3ph := Q_US_Bereich_lph(DT2, -OffsetGeber_Neu_ns, Temperatur2, GeberKonstante1_Ist_m,GeberKonstante2_Ist_m, SteilheitGeber_nspC, Offset1_Ist_m3ph * 1000,Offset2_Ist_m3ph * 1000, Bereich_ns) / 1000;
.Istfluss2_m3ph = Q_US_Bereich_lph(.DT2, -.OffsetGeber_Neu_ns, .Temperatur2_<EFBFBD>C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp<EFBFBD>C, .Offset1_IST_m3ph * 1000, .Offset2_IST_m3ph * 1000, .Bereich_ns) / 1000
End With
End Sub
'========================================================================================================================
'Justage in 2 Schritten(F.L. 16.10.13)
'Der Ablauf der Justage in 2 Schritten:
'Zuerst den Pr<50>fpunkt Qp justieren durch neuen K_Geber1+2 mit Offset_Geber_ist(O_Gerber_roh aus dem Ger<65>t))
'Im zweiten Schritt den Pr<50>fpunkt Qi justieren durch Offset_Geber_neu(O_Gerber_roh neu)
'Ziel ist die Berechnung vom Offset_Geber ohne Beeinflussung der Korrektur des K_Gebers
' neuer Name!
Public Sub Justage1_Execute_FW2(SollwertQi As Double)
'1. Schritt
'Beschreibung: Berechnung Geberkonstanten nur aus Pr<50>fpunkt Qp der Justage
'Input=Sollfluss2; Istfluss2; Sollfluss1(feste Vorgabe), Istfluss1(feste Vorgabe)
'Vorgabe Sollfluss1 und Istfluss1: qp25=0,25m<35>/h;qp40=0,4m<34>/h;qp60=0,6m<36>/h
'An dieser Stelle die Vorgabewerte an die Variablen Sollfluss1 und Istfluss1 <20>bergeben
'Variable Sollwertqi soll den Pr<50>fwert f<>r Qisoll bekommen
With gudtUSParameter
.Sollfluss1_m3ph = SollwertQi
.Istfluss1_m3ph = SollwertQi
'Berechnung Geberkonstante neu aus Qp Pr<50>fung und feste Vorgabewerte f<>r Sollfluss1 und Istfluss1
'Geberkonstante_Neu1_m := Geberkonstante_m(EPS, Geberkonstante1_IST_m);
.Geberkonstante_Neu1_m = Geberkonstante_m(.Geberkonstante1_IST_m)
'Geberkonstante_Neu2_m := Geberkonstante_m(EPS, Geberkonstante2_IST_m);
.Geberkonstante_Neu2_m = Geberkonstante_m(.Geberkonstante2_IST_m)
End With
End Sub
'''''2.Schritt
'''''Beschreibung: Berechnung der restlichen Geberkonstanten au<61>er K_Geber1+2 nach Pr<50>fpunkt Qi bei der Justage)
'''''{*******************************************************************************
'''''Author: Uwe Gro<72>
'''''Datum: 22.03.2001
'''''Beschreibung: Berechnung Geberkonstanten und Offsets
'''''Input: EPS : Einzelpr<70>fstandsnummer
'''''*******************************************************************************}
''''' neuer Name!
''''Public Sub Justage2_Execute_FW2()
'''' With gudtUSParameter
'''' '//---normale Justage berechnen
''''
''''' Offset1_Neu_m3ph := Offset_m3ph(EPS, Offset1_IST_m3ph);
'''' .Offset_Neu1_m3ph = Offset_m3ph(.Offset1_IST_m3ph)
''''' Offset2_Neu_m3ph := Offset_m3ph(EPS, Offset2_IST_m3ph);
'''' .Offset_Neu2_m3ph = Offset_m3ph(.Offset2_IST_m3ph)
''''
'''' ' // ---- ab hier neue Justage ----------------------------------------
'''' ' // f<>r das Logfile den neu berechneten O-Geber ohne Offset speichern
''''
'''' .OGeber_Roh_Neu_ns = .OffsetGeber_Neu_ns
''''
'''' ' Korrektur RH 18.9.2013 mit F.Leidel:
'''' .OffsetGeber_Neu_ns = 0
''''
'''' '// Offset nullen
'''' 'Offset1_Neu_m3ph := 0;
'''' .Offset_Neu1_m3ph = 0
''''
'''' 'Offset2_Neu_m3ph := 0;
'''' .Offset_Neu2_m3ph = 0
''''
'''' .OffsetGeber_ns = .OffsetGeber_Neu_ns
'''' End With
''''End Sub
'{*******************************************************************************
'Author: Uwe Gro<72>
'Datum: 15.08.2002
'Beschreibung: Berechnung Zeroflow
'Input: EPS : Einzelpr<70>fstandsnummer
'*******************************************************************************}
' neuer Name!
Public Sub Justage3_mit_Zeroflow_FW2()
Dim DT_1 As Double
Dim DT_2 As Double
Dim OGeber As Double
With gudtUSParameter
.Fehler1 = 100 * (.Istfluss1_m3ph - .Sollfluss1_m3ph) / .Sollfluss1_m3ph
''' .Istfluss1_m3ph = Q_US_Bereich_lph(.DT1, -.OffsetGeber_Neu_ns, .Temperatur1_<31>C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp<73>C, .Offset1_IST_m3ph * 1000, .Offset2_IST_m3ph * 1000, .Bereich_ns) / 1000
' If (.DiffTof1_ns < 0.01) And (.DiffTof2_ns < 0.01) Then
' // DiffToff aus den alten Justageparametern f<>r die Pr<50>fpunkte bestimmen
'.Istfluss2_m3ph = Q_US_Bereich_lph(.DT2, -.OffsetGeber_ns, .Temperatur2_<32>C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp<73>C, .Offset1_IST_m3ph * 1000, .Offset2_IST_m3ph * 1000, .Bereich_ns) / 1000
'DT1 := Diff_Tof(IstFluss1_m3ph * 1000, Temperatur1, GeberKonstante2_Ist_m,Offset2_Ist_m3ph * 1000, GeberKonstante1_Ist_m, Offset1_Ist_m3ph * 1000,-OffsetGeber_ns, SteilheitGeber_nspC, Bereich_ns);
.DT1 = Diff_Tof(.Istfluss1_m3ph * 1000, .Temperatur1_<EFBFBD>C, .Geberkonstante2_IST_m, .Offset2_IST_m3ph * 1000, .Geberkonstante1_IST_m, .Offset1_IST_m3ph * 1000, -.OffsetGeber_ns, .SteilheitGeber_nsp<EFBFBD>C, .Bereich_ns)
'DT2 := Diff_Tof(IstFluss2_m3ph * 1000, Temperatur2, GeberKonstante2_Ist_m,Offset2_Ist_m3ph * 1000, GeberKonstante1_Ist_m, Offset1_Ist_m3ph * 1000,-OffsetGeber_ns, SteilheitGeber_nspC, Bereich_ns);
.DT2 = Diff_Tof(.Istfluss2_m3ph * 1000, .Temperatur2_<EFBFBD>C, .Geberkonstante2_IST_m, .Offset2_IST_m3ph * 1000, .Geberkonstante1_IST_m, .Offset1_IST_m3ph * 1000, -.OffsetGeber_ns, .SteilheitGeber_nsp<EFBFBD>C, .Bereich_ns)
' Korrektur RH mit F.Leidel am 18.9.2013
' o_geber_roh in Nano sekunden
'.OffsetGeber_Neu_ns = ZeroFlowOffset_ErmitteltAusEinerTemperatur(.DT1, .DT2, .Sollfluss1_m3ph, .Sollfluss2_m3ph, .SteilheitGeber_nsp<73>C, (.Temperatur1_<31>C + .Temperatur2_<32>C) / 2)
.OGeber_Roh_Neu_ns = ZeroFlowOffset_ErmitteltAusEinerTemperatur(.DT1, .DT2, .Sollfluss1_m3ph, .Sollfluss2_m3ph, .SteilheitGeber_nsp<EFBFBD>C, (.Temperatur1_<EFBFBD>C + .Temperatur2_<EFBFBD>C) / 2)
'// Berechnung des Istdurchfluss1&2 bei Verwendung des neuen ZeroFlowOffset
'IstFluss1_m3ph := Q_US_Bereich_lph(DT1, -OffsetGeber_Neu_ns, Temperatur1, GeberKonstante1_Ist_m,GeberKonstante2_Ist_m, SteilheitGeber_nspC, Offset1_Ist_m3ph * 1000,Offset2_Ist_m3ph * 1000, Bereich_ns) / 1000;
'Berechnung des Istfluss2 entf<74>llt weil schon im Schritt1 ermittelt, kleine Abweichung weil ohne Offsetgeber neu ist egal
'IstFluss2_m3ph := Q_US_Bereich_lph(DT2, -OffsetGeber_Neu_ns, Temperatur2, GeberKonstante1_Ist_m,GeberKonstante2_Ist_m, SteilheitGeber_nspC, Offset1_Ist_m3ph * 1000,Offset2_Ist_m3ph * 1000, Bereich_ns) / 1000;
'entf<74>llt .Istfluss2_m3ph = Q_US_Bereich_lph(.DT2, -.OffsetGeber_Neu_ns, .Temperatur2_<32>C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp<73>C, .Offset1_IST_m3ph * 1000, .Offset2_IST_m3ph * 1000, .Bereich_ns) / 1000
End With
End Sub
Public Sub Justage_o_geber_roh()
' Extrahiert am 6.11.2013 aus dem Excel Blatt "Kopie von Test 40 Justage in 2 Schritten Qp25 33365171 05 11 13.xls"
Dim Q_Offset_1 As Double
Dim Q_Offset_2 As Double
Dim Q_in_Difftof_1 As Double
Dim Q_in_Difftof_2 As Double
Dim Difftof_1_roh_in_s As Double
Dim Difftof_2_roh_in_s As Double
Dim Difftof1 As Double
Dim Difftof2 As Double
Dim temp As Double
Dim Temp1 As Double
Dim Temp2 As Double
Dim fp_k_geber_roh As Double
Dim fp_st_geber_roh As Double
Dim OffsetGeber_ns As Double
fp_st_geber_roh = 0
fp_k_geber_roh = 1
OffsetGeber_ns = 0
With gudtUSParameter
'J41 = I41-E9
Q_Offset_1 = .Istfluss1_m3ph - .Offset1_IST_m3ph
'J37 = I37-E9
Q_Offset_2 = .Istfluss2_m3ph - .Offset2_IST_m3ph
'K41 = J41/((Q12*Q12)*H25*3600)
Q_in_Difftof_1 = Q_Offset_1 / ((US_Laufzeit(.Temperatur1_<EFBFBD>C) ^ 2) * .Geberkonstante1_IST_m * 3600)
'K37 = J37 /((Q12*Q12)*E8*3600)
Q_in_Difftof_2 = Q_Offset_2 / ((US_Laufzeit(.Temperatur2_<EFBFBD>C) ^ 2) * .Geberkonstante2_IST_m * 3600)
' L41 = K41 + E10 - (J2 * E12)
' Difftof_1_roh_in_s = Q_in_Difftof_1 + O_Geber - (Temp1 * fp_st_Geber)
Difftof_1_roh_in_s = Q_in_Difftof_1 + OffsetGeber_ns - (.Temperatur1_<EFBFBD>C * (.SteilheitGeber_nsp<EFBFBD>C / 10 ^ 9))
'L37 = K37 + E10 + (G2 * E12)
'Difftof_2_roh_in_s = Q_in_Difftof_2 + O_Geber + (Temp2 * fp_st_Geber)
Difftof_2_roh_in_s = Q_in_Difftof_2 + OffsetGeber_ns - (.Temperatur2_<EFBFBD>C * (.SteilheitGeber_nsp<EFBFBD>C / 10 ^ 9))
'Difftof1 = G45 = M41 = (L41 + E11 - (J2 * L11)) * L12
'Difftof1 = (Difftof_1_roh_in_s + O_Geber_roh - (Temp1 * fp_st_geber_roh)) * fp_k_geber_roh
Difftof1 = (Difftof_1_roh_in_s + (.OffsetGeber_ns / 10 ^ 9) - (.Temperatur1_<EFBFBD>C * fp_st_geber_roh)) * fp_k_geber_roh
'H45 = I56 = M37 = (L37 + E11 - (G2 * L11)) * L12
'Difftof2 = (Difftof_2_roh_in_s + O_Geber_roh - (Temp2 * fp_st_geber_roh)) * fp_k_geber_roh
Difftof2 = (Difftof_2_roh_in_s + (.OffsetGeber_ns / 10 ^ 9) - (.Temperatur2_<EFBFBD>C * fp_st_geber_roh)) * fp_k_geber_roh
' gemittelte Temperatur
temp = (.Temperatur1_<EFBFBD>C + .Temperatur2_<EFBFBD>C) / 2
'I45 = (F45 * G45 - E45 * H45) / (F45 - E45) + C45 * E12
'fp_o_Geber_roh_neu = (Sollfluss2 * Difftof1 - Sollfluss1 * Difftof2) / (Sollfluss2 - Sollfluss1) + Temp * fp_st_Geber
Dim OGeber_Roh_Neu_sec As Double
OGeber_Roh_Neu_sec = (.Sollfluss2_m3ph * Difftof1 - .Sollfluss1_m3ph * Difftof2) / (.Sollfluss2_m3ph - .Sollfluss1_m3ph) + temp * (.SteilheitGeber_nsp<EFBFBD>C / 10 ^ 9)
.OGeber_Roh_Neu_ns = OGeber_Roh_Neu_sec * 10 ^ 9
End With
End Sub
Reference in New Issue Copy Permalink