marekf/laatzen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
d653e0e6e6
laatzen/Pruef2000/source/modUS2000_Algorithmen.bas
Rowlander 70e2645059 Initial commit 3
2021-10-01 11:11:04 +02:00

1065 lines
51 KiB
QBasic
Raw Blame History

Attribute VB_Name = "modUS2000_Algorithmen"
Option Explicit
'---Freigabe für Produktion: 04.12.01 - Version 9.1 - Uwe Groß
'---Freigabe für Produktion: 14.12.01 - Version 9.3 - Uwe Groß
'********************************************************************************************
' History: Version 4.0: Startup für Meßreferenzsystem
' Version 4.3: Subroutine Justage und Functions Geberkonstante bzw. Offset
' hinzugefügt
' Version 4.7: Function PLZausTemperatur hinzugefügt
' Version 4.8: PLZausTemperatur und Q_H2OausDT entfällt.
' Version 4.9: Änderung Geberkonstante_m3 auf Geberkonstante_m
' Version 4.10: Änderung Geberkonstante_m und Offset_s
' Version 6.0: Function MSP430FloatToDez und DezToFloatMSP430 aus Algorithmus zur Vollständigkeit aufgenommen.
' Version 7.0: wie 6.0
' Version 8.0: Q_US_lph zur Bestimmung des Durchfluß erweitert auf
' temperaturabängigen Offset und Unlinearitätsausgleich
' Neuer Abgleich mit Geberkonstante_m und Offset_s
' Version 8.5: temperaturabhängige Steilheit für DiffTof_ns hinzugefü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ändert
' Version 8.17: Function Diff_Tof hinzugefügt incl. Änderung
' Function GibtEinenWertAus(Zeile, Spalte, Blatt_Nr) eingefügt
' Version 8.19: Function Diff_Tof geändert. Sub Justage_Execute geändert.
' Version 9.1: Function Justage_Execute geändert.
' Version 9.7: Neue Function Q_US_Bereich_lph, Function Justage_Execute geändert.
' Version 9.8: Function Diff_Tof geä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 Änderung Function Checksumme_Master
' 12.06.2002: Function DEZ_To_FloatMSP430, Q_US_Bereich_lph und Diff_Tof geändert
' 26.06.2002: neue Function ZeroFlowOffset
' 31.07.2002: neue Function ZeroFlowOffset_ErmitteltAusEinerTemperatur
' Version 9.14: Änderung in Function Diff_Tof und Q_US_Bereich_lph
' Version 9.16: Änderung in Function ZeroFlowOffset_ErmitteltAusEinerTemperatur
' Neue Function DiffToffASIC_ZeroFlowOffset
' Version 9.17: Ä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üfstationssoftware eingebunden
' Dazu mussten einige Elemtente, die direkt auf Excel-Zellen zugreifen entfernt werden
' Zusätzlich wurden alle Variablen deklariert und wenn nötig auf "Private" gesetzt
' So sind nach außen nur spezielle Funktionen 'sichtbar'
' Gar nicht verwendete Funktionen wurden der übersichtlichkeit herausgenommen.
'
' Benötig werden nur der JustageParameter_Type, die Prozedur Justage_Execute mit dazugehörigen
' internen Funktionen, FloatMSP430_To_DEZ und DEZ_To_FloatMSP430.
'
' Statt einem String "Error: ..." wird bei Fehlern ein Err.Raise ausgeführt
'
'********************************************************************************************
' Author: Uwe Groß
' Date: 06.08.01
' Description: Ablauf Justage.
' Die Bereichsumschaltung ist nur wirksam, wenn Unlinearität<>0% gesetzt.
' Bei Nutzung der Bereichsumschaltung muß .Sollfluss1_m3ph bzw. .Istfluss1_m3ph
' die kleinerern Durchflüsse sein. Außerdem ist der Input dieser beiden Werte nach
' Aufruf mit Nutzung der Bereichsjustage zerstört.
'
Public Type JustageParameter_Type
' Input:
Sollfluss1_m3ph As Double '---Solldurchfluß unterer Bereich (m³/h)
Sollfluss2_m3ph As Double '---Solldurchfluß oberer Bereich (m³/h)
Istfluss1_m3ph As Double '---Istdurchfluß unterer Bereich (m³/h)
Istfluss2_m3ph As Double '---Istdurchfluß oberer Bereich (m³/h)
Temperatur1_°C As Double '---Wassertemperatur am Prüfpunkt 1 (°C)
Temperatur2_°C As Double '---Wassertemperatur am Prüfpunkt 2 (°C)
Bereich_ns As Double '---Trennpunkt für Bereich oben/unten [ns]
SteilheitGeber_nsp°C As Double '---Steilheit Zeroflow [ns/°C]
OffsetGeber_ns As Double '---Offset Zeroflow [ns] wie im µC
Unlinearitaet As Double '---weiterer additiver Unlinearitätsfehler am Trennpunkt [%]
' 0% bedeutet damit alte Einstellung (z.B. 3%) bleibt unverä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°C As Double ' wird benö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ß: Korrektur bei der Justage mit Bereichsumschaltung
' 04.12.01 - Version 9.1 - Uwe Groß: Korrektur bei der Berechnung BUist; FP_OGeber wird *-1 übergeben
' 02.01.02 - Version 9.7 - Uwe Groß: Korrektur bei der Berechnung BUist; FP_Bereich wird ZeroFlow befreit, wie µ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üfung bei 50°C
'
' Input: der Fehler bei einer Vormessung bei qmin und 50°C
' der Fehler bei qmin = Definitionsgemäß Sollfluss1
' die aktuellen Justagewerte aus der Datenbank
'
' Output: SteilheitGeber_nsp°C, der neue SteilheitGeber Wert
' Istfluss1_m3ph, der neue Durchfluß wegen des neuen SteilheitGeber Wertes
'
Public Sub Qmin_Temperaturjustage()
' Zwischengrößen für interne Zwecke
Dim dblStg As Double
Dim dblFst As Double
' Zuerst einmal muessen wir den tatsächlichen Versatz der Fehlerkurven bei
' qmin errechnen und um den Wunschversatz korrigieren
' dazu: erst einmal aus den 20°C Durchfluessen einen Fehler berechnen
dblStg = (gudtUSParameter.Istfluss1_m3ph - gudtUSParameter.Sollfluss1_m3ph) / gudtUSParameter.Sollfluss1_m3ph
' und nach %
dblStg = dblStg * 100#
DebugMsg "Fehler bei 20°C bei Qmin: " & dblStg & " %"
' nun die Differenz berechnen und korrigieren
dblStg = dblStg - gudtUSParameter.IstFehler_qmin_50°C + gudtUSParameter.SollFehlerDifferenz_Qmin
DebugMsg "Fehlerdifferenz (FehlerQmin20°C - FehlerQmin50°C + SollSpreizung aus DB) = " & dblStg & " %"
' nun aus der %-Angabe einen echten Durchlfuß berechnen
' Bem.: Der ...fluß1 ist per Definition qmin
dblStg = (dblStg / 100) * gudtUSParameter.Sollfluss1_m3ph
DebugMsg "entspricht Durchfluss = " & dblStg & " m³/h"
' diesen nun in den Zwischenwert Flächenstrom m²/h
dblStg = dblStg / gudtUSParameter.Geberkonstante1_IST_m
DebugMsg "Flächenstrom = " & dblStg & " m²/h"
' und daraus nun Sekunden berechnen
'
' Bem.: Die Durchflußermittelung geht so:
' Q_US_lph = (DiffTof_ns + OGeber_ns + Temperatur_°C * STGeber_ns) * 0.000001 _
' * US_Laufzeit(Temperatur_°C) ^ 2 * KGeber_m * 3600
' also ergibt sich dann daraus zurück gerechnet:
' dblFst = 0.000001 * 3600 * (US_Laufzeit(50) ^ 2 - US_Laufzeit(US.Temperatur1_°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_°C * US_Laufzeit(gudtUSParameter.Temperatur1_°C) ^ 2)
' nun aus dieser Zwischengröße ltr/h ü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°C = gudtUSParameter.SteilheitGeber_nsp°C + dblStg
DebugMsg " neuer ST_Geber = " & gudtUSParameter.SteilheitGeber_nsp°C & " nSec"
' und jetzt noch den gemessenen qmin-Wert korrigieren wegen des neuen SteiheitGeber
' dazu: das resultierende Delta berechnen
dblFst = dblStg * gudtUSParameter.Temperatur1_°C * 0.000001 * US_Laufzeit(gudtUSParameter.Temperatur1_°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°C * gudtUSParameter.Temperatur1_°C
'---BUsoll/ist mit Justageparameter unten und Temperatur unten
BUist = Q_US_lph(DiffTof, -gudtUSParameter.OffsetGeber_ns, gudtUSParameter.Temperatur1_°C, gudtUSParameter.Geberkonstante1_IST_m, gudtUSParameter.SteilheitGeber_nsp°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üfpkt. unten
gudtUSParameter.Sollfluss2_m3ph = BUsoll '---oberer Prü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ängig
gudtUSParameter.Sollfluss2_m3ph = TempSoll
gudtUSParameter.Istfluss2_m3ph = TempIst
'Justage vom Trennpunkt bis Prüfpkt. oben
'---Berechnung DiffTof für Bereichsumschaltung
DiffTof = gudtUSParameter.Bereich_ns + gudtUSParameter.OffsetGeber_ns - gudtUSParameter.SteilheitGeber_nsp°C * gudtUSParameter.Temperatur2_°C
'---BUsoll mit Justageparameter oben und Temperatur oben
BUist = Q_US_lph(DiffTof, -gudtUSParameter.OffsetGeber_ns, gudtUSParameter.Temperatur2_°C, gudtUSParameter.Geberkonstante2_IST_m, gudtUSParameter.SteilheitGeber_nsp°C, gudtUSParameter.Offset2_IST_m3ph * 1000) / 1000
BUsoll = BUist + gudtUSParameter.Unlinearitaet * BUist
'---Zwischenspeicherung und Justage vom Trennpunkt bis Prüfpkt. oben
TempSoll = gudtUSParameter.Sollfluss1_m3ph
TempIst = gudtUSParameter.Istfluss1_m3ph
gudtUSParameter.Sollfluss1_m3ph = BUsoll '---unterer Prü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ängig
gudtUSParameter.Sollfluss1_m3ph = TempSoll
gudtUSParameter.Istfluss1_m3ph = TempIst
End If
End Sub
'*******************************************************************************************
' Author: Uwe Groß (Invensys Metering Systems)
' Date: 31.07.2002
' Description: Algorithmus zur ZeroFlow Justage.
' ZU ÜBERPRÜFEN: Wie wirkt sich FP_St_Geber ungleich 0 aus!!!!!!!!
' --------------
'
' Input: Definition der Justage Parameter und Prüfpunkte im Global US:
' -------------------------------------------------------------
' .Sollfluss1_m3ph As Single '---Solldurchfluß unterer Bereich (m³/h)
' .Sollfluss2_m3ph As Single '---Solldurchfluß oberer Bereich (m³/h)
' .Istfluss1_m3ph As Single '---Istdurchfluß unterer Bereich (m³/h)
' .Istfluss2_m3ph As Single '---Istdurchfluß oberer Bereich (m³/h)
' .Temperatur1_°C As Single '---Wassertemperatur am Prüfpunkt 1 (°C)
' .Temperatur2_°C As Single '---Wassertemperatur am Prüfpunkt 2 (°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°C As Double '---Steilheit Zeroflow [ns/°C]
' .OffsetGeber_ns As Double '---Offset Zeroflow [ns] wie im µC
' .Unlinearitaet As Single '---weiterer additiver Unlinearitätsfehler am Trennpunkt [%]
' 0% bedeutet damit alte Einstellung (z.B. 3%) bleibt unverä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°C '---Input ZeroFlowSteilheit auf 0 [ns/°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°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üfpunkte bestimmen
DT1 = Diff_Tof(.Istfluss1_m3ph * 1000, .Temperatur1_°C, .Geberkonstante2_IST_m, .Offset2_IST_m3ph * 1000, .Geberkonstante1_IST_m, .Offset1_IST_m3ph * 1000, -.OffsetGeber_ns, .SteilheitGeber_nsp°C, .Bereich_ns)
DT2 = Diff_Tof(.Istfluss2_m3ph * 1000, .Temperatur2_°C, .Geberkonstante2_IST_m, .Offset2_IST_m3ph * 1000, .Geberkonstante1_IST_m, .Offset1_IST_m3ph * 1000, -.OffsetGeber_ns, .SteilheitGeber_nsp°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°C, (.Temperatur1_°C + .Temperatur2_°C) / 2)
'---Berechnung des Istdurchfluss1&2 bei Verwendung des neuen ZeroFlowOffset
.Istfluss1_m3ph = Q_US_Bereich_lph(DT1, -.OffsetGeber_ns, .Temperatur1_°C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp°C, .Offset1_IST_m3ph * 1000, .Offset2_IST_m3ph * 1000, .Bereich_ns) / 1000
.Istfluss2_m3ph = Q_US_Bereich_lph(DT2, -.OffsetGeber_ns, .Temperatur2_°C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp°C, .Offset1_IST_m3ph * 1000, .Offset2_IST_m3ph * 1000, .Bereich_ns) / 1000
End With
'---hydraulische Justage, damit mit dem neuen ZeroFlowOffset
'---die Prüfpunkte1&2 zu 0% Fehler führen.
End Sub
'********************************************************************************************
' Author: Uwe Groß
' Date: 22.03.2001
' Description: Bestimmt Offset und Geberkonstante aus 2 Fehlermessungen
'
' Input: Sollfluss1_m3ph : Solldurchfluß 1 (m³/h)
' Sollfluss2_m3ph : Solldurchfluß 2 (m³/h)
' Istfluss1_m3ph : Istdurchfluß 1 (m³/h)
' Istfluss2_m3ph : Istdurchfluß 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ß: Anpassung auf Temperaturkompensation der US-Laufzeit
' 14.05.01 - Version 4.10 -Uwe Groß: Berechnungsfehler beseitigt
' 14.05.01 - Version 8.0 -Uwe Groß: Neue Justage mit Offset_m3ph, dadurch sind die Temperaturen
' als Input nicht mehr nötig
' 06.08.01 - Version 8.5 - Uwe Groß: 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ß
' Date: 22.02.2001
' Description: Bestimmt den die Laufzeit US in Wasser in Abhängigkeit der Temperatur
'
' Input: Temperatur: Temperatur des Wassers in °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ß
' Date: 31.01.2001
' Description: Bestimmt den Durchfluß für US2000
'
' Input: DiffTof_ns : Laufzeitdifferenz in ns
' OGeber_ns : Offset Geber in ns (Achtung im µC ist dieser Wert * -1)
' Temperatur_°C: Wassertemperatur in °C
' KGeber_m : Geberkonsante in m aus Querschnitt/2/Wandlerabstand
' STGeber_ns : temperaturabhängige Steilheit für DiffTof_ns
' OFlow_lph : temperaturunabhä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ängiger Offset und Unlinearitätsausgleich hinzugefügt
' 06.08.01 temperaturabhängige Steilheit für DiffTof_ns hinzugefügt
' UnLinAbgl entfernt
'*******************************************************************************************
Function Q_US_lph(DiffTof_ns As Double, OGeber_ns As Double, Temperatur_°C As Double, KGeber_m As Double, STGeber_ns As Double, OFlow_lph As Double) As Double
'--Durchflußermittelung nach konventioneller Art
Q_US_lph = (DiffTof_ns + OGeber_ns + Temperatur_°C * STGeber_ns) * 0.000001 _
* US_Laufzeit(Temperatur_°C) ^ 2 * KGeber_m * 3600
'--temperaturunabhängiger Offset
Q_US_lph = OFlow_lph + Q_US_lph
End Function
'********************************************************************************************
' Author: Uwe Groß
' Date: 02.01.2002
' Description: Bestimmt den Durchfluß für US2000 mit Bereichsumschaltung
'
' Input: DiffTof_ns : Laufzeitdifferenz in ns
' OGeber_ns : Offset Geber in ns (Achtung im µC ist dieser Wert * -1)
' Temperatur_°C: Wassertemperatur in °C
' KGeberUNTEN_m : Geberkonstante in m für unteren Bereich
' KGeberOBEN_m : Geberkonstante in m für oberen Bereich
' STGeber_ns : temperaturabhängige Steilheit für DiffTof_ns
' OFlowUNTEN_lph : temperaturunabhänige Offsetkorrektur in l/h für unteren Bereich
' OFlowOBEN_lph : temperaturunabhä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_°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_°C * STGeber_ns)
'--Durchflußermittelung
If DT < Bereich_ns Then
Q_US_Bereich_lph = DT * 0.000001 * US_Laufzeit(Temperatur_°C) ^ 2 * KGeberUNTEN_m * 3600 + OFlowUNTEN_lph
Else
Q_US_Bereich_lph = DT * 0.000001 * US_Laufzeit(Temperatur_°C) ^ 2 * KGeberOBEN_m * 3600 + OFlowOBEN_lph
End If
End Function
'********************************************************************************************
' Author: Uwe Groß
' Date: 25.09.2001
' Description: Bestimmt aus dem Durchfluß ein mittleres Diff_Tof
'
' Input: Durchfluß_lph: Laufzeitdifferenz in ns
' Temperatur_°C: Wassertemperatur in °C
' KGeber_m : Geberkonsante in m aus Querschnitt/2/Wandlerabstand
' OFlow_lph : temperaturunabhänige Offsetkorrektur in l/h
' O_Geber_ns : temperaturabhängige Offsetkorrektur in ns (Achtung im µC ist dieser Wert * -1)
' ST_Geber_nsPerGradC: temperaturabhängige Steilheitskorrektur in ns/°C
' Output: Ergebnis in ns
'
' History: 16.11.01 O_Geber_ns und ST_Geber_nsPerGradC als zusätzlicher Input
' 22.11.01 Bereichumschaltung eingefü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ß_lph As Double, _
Temperatur_°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ß_lph - OFlowOBEN_lph) / 3600000 / KGeberOBEN_m / US_Laufzeit(Temperatur_°C) ^ 2 * 1000000000#)
Diff_TofUnten = ((Durchfluß_lph - OFlowUNTEN_lph) / 3600000 / KGeberUNTEN_m / US_Laufzeit(Temperatur_°C) ^ 2 * 1000000000#)
If Diff_TofUnten < Bereich_ns Then
Diff_Tof = Diff_TofUnten - O_Geber_ns - ST_Geber_nsPerGradC * Temperatur_°C
Else
Diff_Tof = Diff_TofOben - O_Geber_ns - ST_Geber_nsPerGradC * Temperatur_°C
End If
End Function
'********************************************************************************************
' Author: Uwe Groß
' 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ß ungefähr
' (ca. +-5°C) gleich sein.
' Input: DiffTof1_ns : DiffTof bei Sollfluss1_m3ph [ns]
' DiffTof2_ns : DiffTof bei Sollfluss2_m3ph [ns]
' Sollfluss1_m3ph : Solldurchfluß unterer Bereich (m³/h)
' Sollfluss2_m3ph : Solldurchfluß oberer Bereich (m³/h)
' SteilheitGeber_nsp°C: ZeroFlow Steilheit [ns/°C]
' Temperatur_°C : mittlere Temperatur der Prü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°C und Temperatur_°C erweitert und
' im Algorithmus berücksichtigt.
'*******************************************************************************************
Private Function ZeroFlowOffset_ErmitteltAusEinerTemperatur(DiffTof1_ns As Double, _
DiffTof2_ns As Double, _
Sollfluss1_m3ph As Double, _
Sollfluss2_m3ph As Double, _
SteilheitGeber_nsp°C As Double, _
Temperatur_°C As Double)
ZeroFlowOffset_ErmitteltAusEinerTemperatur = (Sollfluss2_m3ph * DiffTof1_ns - Sollfluss1_m3ph * DiffTof2_ns) / _
(Sollfluss2_m3ph - Sollfluss1_m3ph) + Temperatur_°C * SteilheitGeber_nsp°C
End Function
'********************************************************************************************
' Author: Uwe Groß
' 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ß
' 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ß
' 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ß - 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ß
' 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ß) Abfrage auf m >=; zusä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
'---Änderung 12.06.01/Uwe Groß 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 °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ügt am 6.1.2012 von R.Henning:
'{*******************************************************************************
'Author: Uwe Groß
'Datum: 22.03.2001
'Beschreibung: Berechnung Geberkonstanten und Offsets
'Input: EPS : Einzelprü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_°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ß
'Datum: 15.08.2002
'Beschreibung: Berechnung Zeroflow
'Input: EPS : Einzelprü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ü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_°C, .Geberkonstante2_IST_m, .Offset2_IST_m3ph * 1000, .Geberkonstante1_IST_m, .Offset1_IST_m3ph * 1000, -.OffsetGeber_ns, .SteilheitGeber_nsp°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_°C, .Geberkonstante2_IST_m, .Offset2_IST_m3ph * 1000, .Geberkonstante1_IST_m, .Offset1_IST_m3ph * 1000, -.OffsetGeber_ns, .SteilheitGeber_nsp°C, .Bereich_ns)
'// neu !!! DiffTof um der Fehler verä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 ü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°C, (.Temperatur1_°C + .Temperatur2_°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°C, (.Temperatur1_°C + .Temperatur2_°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°C, (.Temperatur1_°C + .Temperatur2_°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_°C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp°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_°C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp°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üfpunkt Qp justieren durch neuen K_Geber1+2 mit Offset_Geber_ist(O_Gerber_roh aus dem Gerät))
'Im zweiten Schritt den Prü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üfpunkt Qp der Justage
'Input=Sollfluss2; Istfluss2; Sollfluss1(feste Vorgabe), Istfluss1(feste Vorgabe)
'Vorgabe Sollfluss1 und Istfluss1: qp25=0,25m³/h;qp40=0,4m³/h;qp60=0,6m€/h
'An dieser Stelle die Vorgabewerte an die Variablen Sollfluss1 und Istfluss1 übergeben
'Variable Sollwertqi soll den Prüfwert für Qisoll bekommen
With gudtUSParameter
.Sollfluss1_m3ph = SollwertQi
.Istfluss1_m3ph = SollwertQi
'Berechnung Geberkonstante neu aus Qp Prü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ßer K_Geber1+2 nach Prüfpunkt Qi bei der Justage)
'''''{*******************************************************************************
'''''Author: Uwe Groß
'''''Datum: 22.03.2001
'''''Beschreibung: Berechnung Geberkonstanten und Offsets
'''''Input: EPS : Einzelprü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ß
'Datum: 15.08.2002
'Beschreibung: Berechnung Zeroflow
'Input: EPS : Einzelprü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_°C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp°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üfpunkte bestimmen
'.Istfluss2_m3ph = Q_US_Bereich_lph(.DT2, -.OffsetGeber_ns, .Temperatur2_°C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp°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_°C, .Geberkonstante2_IST_m, .Offset2_IST_m3ph * 1000, .Geberkonstante1_IST_m, .Offset1_IST_m3ph * 1000, -.OffsetGeber_ns, .SteilheitGeber_nsp°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_°C, .Geberkonstante2_IST_m, .Offset2_IST_m3ph * 1000, .Geberkonstante1_IST_m, .Offset1_IST_m3ph * 1000, -.OffsetGeber_ns, .SteilheitGeber_nsp°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°C, (.Temperatur1_°C + .Temperatur2_°C) / 2)
.OGeber_Roh_Neu_ns = ZeroFlowOffset_ErmitteltAusEinerTemperatur(.DT1, .DT2, .Sollfluss1_m3ph, .Sollfluss2_m3ph, .SteilheitGeber_nsp°C, (.Temperatur1_°C + .Temperatur2_°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ä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ällt .Istfluss2_m3ph = Q_US_Bereich_lph(.DT2, -.OffsetGeber_Neu_ns, .Temperatur2_°C, .Geberkonstante1_IST_m, .Geberkonstante2_IST_m, .SteilheitGeber_nsp°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_°C) ^ 2) * .Geberkonstante1_IST_m * 3600)
'K37 = J37 /((Q12*Q12)*E8*3600)
Q_in_Difftof_2 = Q_Offset_2 / ((US_Laufzeit(.Temperatur2_°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_°C * (.SteilheitGeber_nsp°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_°C * (.SteilheitGeber_nsp°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_°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_°C * fp_st_geber_roh)) * fp_k_geber_roh
' gemittelte Temperatur
temp = (.Temperatur1_°C + .Temperatur2_°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°C / 10 ^ 9)
.OGeber_Roh_Neu_ns = OGeber_Roh_Neu_sec * 10 ^ 9
End With
End Sub
Reference in New Issue View Git Blame Copy Permalink