laatzen/Pruef2000/source/TEST_PFEIFFER_frmUSHauptprf.frm

Option Explicit

' von aufrufender Form zu setzende Member
' ---------------------------------------
' Für Regulierung und Prüfzaehler Prüfung
Public m_colUniquePP As CPruefpunktCol
Public m_colUniqueVorPP As CVorpruefpunktCol

Public m_bKontinuierlich As Boolean

Public m_colEinbauplatz As Collection
Public m_ParentForm As Form
' Für Regulierung
Public m_Regulierdaten As CRegulierdaten
Public m_RegulierPruefpunkt As CPruefpunkt

Public m_bAutomatik As Boolean
' Public m_bKeineRegulierung  As Boolean

Public m_AnzahlPZ As Integer

' Für Prüfzaehlerprüfung
Public m_ImpulswertigkeitPZ As Long

Public m_bDauerpruefung As Boolean

Public m_DauerpruefungAnzahl As Integer

Public m_PruefungsArtWaage As Boolean
Public m_VorPruefungsArtWaage As Boolean

Public m_bPruefgangLang As Boolean
        
Public m_Regelart As String  ' FU, Servo
Public m_NurMesseinsaetze As Boolean
Public m_Pruefgang As CPruefgang
Public m_RegulierungVerwenden As Boolean

Public mbln_Vorpruefung As Boolean
Public mbln_Hauptpruefung As Boolean
Public mbln_Bereichsjustage As Boolean
Public mbln_nachjustage As Boolean
Public mbln_Funktionspruefung As Boolean
Public mbln_ZeroFlowMessung As Boolean
Public mbln_HeissKaltSpreizungBerechnen As Boolean



' Private Member
' --------------
Private m_PPDauerpruefung As Double

Private Dummy As Variant
Private mblnAbbruch As Boolean

Private m_nRet As Integer

Private m_SPS As CSPS
Private m_FMBus As CFMBus

Private m_ColPumpen As Collection
Private m_Pruefpunkt As CPruefpunkt

Private m_vorPruefpunkt As CVorpruefpunkt

Private FormActivated As Boolean
Private m_ZaehlerPP As Integer

Private m_DurchflussSoll As Double
Private m_DurchflussSollManuell As Double

Private m_Pumpe As CPumpe

Private m_Referenzzaehler As CRefzaehler
Private m_ReferenzzaehlerA As CRefzaehler
Private m_ReferenzzaehlerB As CRefzaehler

Private m_PruefpunktFertig As Boolean

Private m_DauerStop As Boolean
Private m_laeuft As Boolean 'Status Prüfung läuft
Private m_QBehalten As Boolean

Private m_Startzeit As Long

Private m_Pruefzeit As Integer
Private m_DauerpruefungZaehler As Integer

Private m_GesZeitZaehler As Long

Private PP_Ist_Zeit As Long
Private AuftragPositionSerienNr As CAuftragPositionSerienNr

Private m_VolumenSoll As Double

Private FehlerInPruefgangLang(3, 10) As Double
Private ZaehlerPruefgangLang As Integer
Private PruefgangLangPruefpunktWiederholen As Boolean
Private m_ersterPruefzaehler As CPruefzaehler
Private m_ersterPruefzaehlerNr As Integer

Private m_ArrayBehaelter(2) As CBehaelter
Private m_Behaelter As CBehaelter
Private m_BehaelterNr As Integer
Private m_Waage As CWaage

Private m_DruckMsg As String

Private m_Tstart As Long 'Bezugszeitpunkt: Start der Prüfung
Private m_Tpruef As Long ' Sollprüfzeit aller US Zähler

Private m_Zeitrahmenzaehler As Long 'Index des aktuellen Zeitrahmens
Private ResultFilePath As String

Private m_AnwahlLetzterBehaelter As Long

Private mudtMessDaten(10) As TYPE_MessDaten

Private strFunktionsPruefungMsg As String

Private Type TypUSPruefdaten
' Enthält alle Daten, die für eine Ultraschallzähler-Prüfung relevant sind
' für einen bestimmten Zähler in einem bestimmten Prüfpunkt

    ' Solldurchfluß Q des Prüfpunktes
    SollDurchfluss As Double ' in M^3/h
    ' Sollprüfzeit des Prüfpunktes in s
    SollPruefzeit_s As Long
    
    ' Temperatur zur halben Prüfzeit
    dblTemperatur As Double
    
    ' Ermitteltes Volumen aus den RZ/FM85 und US Zählern
    VolumenRZ As Double
    VolumenUS As Double
    VolumenWaage As Double
    
    ' echte Prüfzeit zwischen USZaehler Start und Stop in ms
    US_IstPruefzeit_ms As Long
    ' echte Prüfzeit zwischen Referenzzaehler Start und Stop in ms
    RZ_IstPruefzeit_ms As Long '
    
    NOWA_START_Rueckkehrzeitpunkt As Long
    NOWA_STOP_Rueckkehrzeitpunkt As Long
    RZ_START_Rueckkehrzeitpunkt As Long
    RZ_STOP_Rueckkehrzeitpunkt As Long
    
    StartzeitpunktRZ As Long
    StartzeitpunktUS As Long
    
    Stopzeitpunkt As Long
    Fehlerinfo As String
    
    Fehler As Double
    
    ' zukünftig:
    dtmIstPruefzeit As Double
    dtmStartZeit As Double
    dtmMittelzeit As Double
    dtmStoppzeit As Double
    
    blnPruefungsfehler As Boolean
    
    JustageParameter As JustageParameter_Type
End Type

' neu RH! 19.7.2002
Private Type US_ZusatzParameter_Typ
       FP_Impulswertigkeit     As Double   '---Impulswertigkeit normale Ausgabe
       FP_Impulswertigkeit_Pruef  As Double   '---Impulswertigkeit normale Ausgabe
       PulseMode               As Byte     '---PulseMode (PolluFlow=1,PolluStat=2)
       FP_Flow_Min             As Double   '---Minimaler Durchfluß
       FP_Flow_Max             As Double
End Type

Const dtmZEITRAHMENDAUER As Date = 1 / 24 / 60 / 60 / 1000 * 1000 'ms
Const ZEITRAHMENDAUER As Long = 2000 ' Dauer des Zeitrahmens in msec
Const DELTA_START As Long = 1000 'Zeitlicher Versatz in msec zwischen dem Start des Referenzzählers und des US Zählers
Const DELTA_FM As Long = 0 'Korrekturkonstante: Zeit in msec, um die die tatsächliche Prüfzeit des FM85 größer ist als die Sollprüfzeit, verursacht durch die längere Stopzeit
Const DELTA_US As Long = 0 'Korrekturkonstante: Zeit in msec, um die die tatsächliche Prüfzeit des US-Zählers größer ist als die Sollprüfzeit, verursacht durch die längere Stopzeit

Const FEHLER_ZUSPAET As Long = -15
Const KEIN_FEHLER As Long = 0
Const KEINE_ANTWORT_FEHLER As Long = -16

'--------------------------------------------------------------------
' @return Code, mit dem endDialog aufgerufen wurde
'
Public Function getExitCode() As Integer
    getExitCode = m_nRet
End Function

' Dialog beenden
'
' @param nRet   Returncode des Dialogs
'
Private Sub endDialog(nRet As Integer)
    m_nRet = nRet
    Unload Me
End Sub


Private Sub cmdAbbruch_Click()
    g_Abbruch = True
End Sub


Private Sub cmdCancel_Click()
If m_laeuft Then
    ErrorMsg ("Sie müssen die Prüfung zuerst stoppen")
Else
    endDialog (IDCANCEL)
End If
End Sub

Private Sub cmdDauerEnde_Click()
    PrintStatus "Dauerprüfung wird nach diesem Prüfgang beendet"
    cmdDauerEnde.Caption = "Dauer-P endet !"
    cmdDauerEnde.Enabled = False
    m_DauerStop = True
End Sub



'Private Sub cmdOK_Click()
'    If m_laeuft Then
'        ErrorMsg ("Sie müssen die Prüfung zuerst stoppen")
'    Else
'        endDialog (IDOK)
'    End If
'End Sub

Private Sub cmdQSollMinus_Click()
    m_DurchflussSollManuell = CDbl(Format(m_DurchflussSollManuell * 0.99, "0.000"))
    m_SPS.SetQSoll m_DurchflussSollManuell
    PrintStatus "Nächster Durchfluss: " & m_DurchflussSollManuell
    lblQSoll.Caption = m_DurchflussSollManuell
End Sub

Private Sub cmdQSollPlus_Click()
    m_DurchflussSollManuell = CDbl(Format(m_DurchflussSollManuell * 1.01, "0.000"))
    m_SPS.SetQSoll m_DurchflussSollManuell
    PrintStatus "Nächster Durchfluss: " & m_DurchflussSollManuell
    lblQSoll.Caption = m_DurchflussSollManuell
End Sub

Private Sub cmdSPSInfo_Click()
    Call g_App.getSPS().ActivateProTool
End Sub

Private Sub Abbruch(Optional strGrund As String = "")
    Dim dlg As frmAbbruch
    Set dlg = New frmAbbruch
    
    ' Abbruch-Button deaktivieren
    cmdStop.Enabled = False
    ' Flags setzen
    g_Abbruch = True
    m_laeuft = False
        
    ' SPS zurücksetzen
    m_SPS.setBetrieb 0
    m_SPS.AbwahlPumpe 1
    m_SPS.AbwahlPumpe 2
    m_SPS.AbwahlPumpe 3
    m_SPS.AbwahlPumpe 5
    m_SPS.SetNurMesseinsaetze False
    m_SPS.WassserAblassen 0
    
    Call ResetPruefung
    lblQIst.Caption = ""
    dlg.m_strGrund = strGrund
    dlg.Show vbModal

    m_Pruefgang.Bemerkung = dlg.m_strGrund
    m_Pruefgang.save
        
    endDialog IDCANCEL
End Sub





Private Sub cmdStop_Click()
    g_Abbruch = True
    Call Abbruch("")
End Sub

Private Sub ResetPruefung()
    cmdDauerEnde.Caption = "Dauer-P beenden"
    cmdQSollPlus.Enabled = False
    cmdQSollMinus.Enabled = False
    m_laeuft = False
End Sub







Private Sub Form_Load()
    Dim PPNr As Integer
    
   Me.Width = Screen.Width
   Me.Height = Screen.Height
   Call centerFormInScreen(Me)
    
    Set m_SPS = g_App.getSPS
    Set m_FMBus = g_App.getFMBus
    Set m_ColPumpen = g_App.Settings.getPumpen
    
    m_ZaehlerPP = 0
    
    'cmdOK.Enabled = False
    cmdCancel.Enabled = True
    
    Set m_ArrayBehaelter(1) = New CBehaelter
    Set m_ArrayBehaelter(2) = New CBehaelter
    
    If m_VorPruefungsArtWaage = True Or m_PruefungsArtWaage = True Then
        Set m_Waage = g_App.getWaage
    End If
    
    m_ArrayBehaelter(1).LoadFromIni (1)
    m_ArrayBehaelter(2).LoadFromIni (2)
    
    m_SPS.SetQSoll 0
    
    m_SPS.setBetrieb 8   ' Bits zurücksetzen
    sleep 100, True
    m_SPS.setBetrieb 0   ' kein Start, kein Stop, kein Programmende
    
    MSFlexGrid1.Clear
    MSFlexGrid1.Cols = 1 + m_colUniqueVorPP.Count
    
    If MSFlexGrid1.Cols < 2 Then MSFlexGrid1.Cols = 2
    MSFlexGrid1.Row = 0
    MSFlexGrid1.Col = 0
    MSFlexGrid1.Text = "SNr.\ Q "
    
    ' Listbox mit allen Durchflüssen füllen
    lstPruefpunkte.Clear
    
    PPNr = 0
    For Each m_vorPruefpunkt In m_colUniqueVorPP.getCollection
        PPNr = PPNr + 1
        MSFlexGrid1.Row = 0
        MSFlexGrid1.Col = PPNr
        MSFlexGrid1.Text = m_vorPruefpunkt.getQ
        lstPruefpunkte.AddItem (CStr(m_vorPruefpunkt.getQ))
    Next m_vorPruefpunkt
   
    If m_bKontinuierlich Then
       frameKontinuierlich.Visible = True
    Else
       frameKontinuierlich.Visible = False
    End If
    
    m_AnwahlLetzterBehaelter = 0
End Sub

Private Sub Form_Activate()
g_Abbruch = False

If Not FormActivated Then
    FormActivated = True
    DoEvents
    Call Hauptpruefung
End If
FormActivated = True
End Sub


Private Sub DurchflussLstAktualisieren()
    Dim i As Integer
    ' Balkenanzeige in der Liste der Durchflüsse aktualisieren
    For i = 0 To lstPruefpunkte.ListCount - 1
        If Format(lstPruefpunkte.List(i), "0.000") = Format(m_DurchflussSoll, "0.000") Then
            lstPruefpunkte.Selected(i) = True
        Else
            lstPruefpunkte.Selected(i) = False
        End If
    Next
End Sub



' Hauptprüfung mit Referenzzaehler
Private Sub Hauptpruefung()

Dim Dummy As Variant
Dim Einbauplatz As CEinbauplatz
Dim Pruefzaehler As CPruefzaehler
Dim bFehlerermittelt As Boolean

Dim Impulse As Long
Dim blnPruefungFertig As Boolean

Dim PeriodendauerPZ  As Long
Dim PeriodendauerRZ As Long

Dim PeriodendauerRefZ1 As Long
Dim PeriodendauerRefZ2 As Long

Dim k As Double
Dim Fehler As Double
Dim FehlerRefZ As Double
Dim FehlerRefZA As Double
Dim FehlerRefZB As Double

Dim QIst As Double
Dim PPNr As Integer
Dim tmpPPNr As Integer

Dim PPZeit As Date
Dim StartZeit As Date
Dim PPSollZeit As Long

Dim Temperatur As Double
Dim PZCount As Integer
Dim bImpulsTest As Boolean
Dim bPPQIstSaved As Boolean

Dim i As Integer
Dim lngRet  As Long
Dim lngStartzeit As Long

Dim EinbauplatzNr As Integer
Dim Gewicht As Double
Dim BehaelterVolumen As Double
Dim Waagengrenzwert As Double
Dim GesZeit As Double
Dim tmpPruefpunkt As CPruefpunkt
Dim tmpVorpruefpunkt As CVorpruefpunkt
Dim dblVolumenRZ As Double
Dim dblVolumenUS As Double

Dim dblDurchflussRZ As Double
Dim dblDurchflussUS As Double

Dim US_COMport As Integer
Dim udtPruefdaten_imPP_mitEBP(10) As TypUSPruefdaten


' SPS Parameter zurücksetzen
' Durchlauf
'm_SPS.setBehaelter 1
g_Abbruch = False

m_SPS.setBetrieb 8
sleep 300
m_SPS.setBetrieb 0





lblPruefgangNr.Caption = m_Pruefgang.PruefgangNr

' Einstellung für Vergleichsprüfung-Modus in der SPS testen
TestReferenzPrf:
If Not g_testModus Then
    If m_SPS.IstRefZPrf Then
        Dummy = MsgBox("Bitte SPS auf Hauptzähler Vergleichs-Prüfung stellen", vbOKCancel)
        If Dummy = vbCancel Then
            endDialog (IDCANCEL)
            Exit Sub
        End If
        GoTo TestReferenzPrf
    End If
End If

TestAutomatik:
If Not m_SPS.IstAutomatik Then
    Dummy = MsgBox("Bitte SPS auf Automatik stellen", vbOKCancel)
    If Dummy = vbCancel Then
        endDialog (IDCANCEL)
        Exit Sub
    End If
    GoTo TestAutomatik
End If


For i = 1 To 2
    Set m_Behaelter = New CBehaelter
    m_Behaelter.LoadFromIni (i)
Next
If m_PruefungsArtWaage Then
    Call WaageZuruecksetzen
End If

m_SPS.setBehaelter 2

PrintStatus "Beide Behälter leeren bis Prüfmenge nicht mehr erreicht..."
If Not g_testModus Then
    m_SPS.WassserAblassen 0
    ' beide Behälter leeren bis Prüfmenge nicht mehr erreicht
    sleep 500
    m_SPS.WassserAblassen 3
    sleep 2000
    If m_SPS.GrenzwertWaageErreicht Then
        sleep 5000
        Do While m_SPS.GrenzwertWaageErreicht
            sleep 1000, True
            If g_Abbruch = True Then
                Exit Sub
            End If
        Loop
    End If
    m_SPS.WassserAblassen 0
End If ' Testmodus
m_SPS.setBehaelter 1

' Formular und Flags zurücksetzen
cmdStop.Enabled = True
m_laeuft = True

' Pruefgang Daten setzen mit Eigenschaften des ersten Zählers
For Each Einbauplatz In m_colEinbauplatz
    Set Pruefzaehler = Einbauplatz.getPruefzaehler
    If Not Pruefzaehler Is Nothing Then
        Set m_ersterPruefzaehler = Pruefzaehler
        m_ersterPruefzaehlerNr = Einbauplatz.getNr

        m_Pruefgang.Typ = Pruefzaehler.getIdentNrObj.getTyp
        m_Pruefgang.Nennweite = Pruefzaehler.getIdentNrObj.getNennweite
        m_Pruefgang.Nenntemperatur = Pruefzaehler.getIdentNrObj.getTemperatur
        
        PrintStatus "Neue Hauptpruefung"
        PrintStatus "------------------"
        PrintStatus "Pruefgang Daten:"
        PrintStatus "Typ: " & m_Pruefgang.Typ
        PrintStatus "Nennweite: " & m_Pruefgang.Nennweite
        PrintStatus "Nenntemperatur: " & m_Pruefgang.Nenntemperatur
        PrintStatus "Waage statt Referenzzaehler: " & CStr(m_PruefungsArtWaage)
        Exit For
    End If
Next Einbauplatz


'If Not SindPruefzeitenOK() Then
'    Call Abbruch("falsche Prüfzeiten für Behälter")
'    Exit Sub
'End If


' Flag für PruefgangLang im Pruefgang-Objekt für Tabelle Pruefgang setzen:
m_Pruefgang.PruefgangLang = m_bPruefgangLang
PrintStatus "Pruefgang Lang: " & CStr(m_bPruefgangLang)

' Pruefpunkte absteigend sortieren nach Durchfluessen
m_colUniquePP.sortQ

If Not g_testModus Then
    ' Einstellung für Automatik-Modus in der SPS testen

    m_SPS.setBetrieb 8   ' Bits zurücksetzen
    sleep 300
    m_SPS.setBetrieb 0   ' kein Start, kein Stop, kein Programmende
    PrintStatus "Teste auf Prüfbereitschaft"
    sleep 3000, True
    If Not m_SPS.IstStreckePruefbereit Then
        ' Betrieb Vorbereiten
        If MsgBox("Soll die Strecke automatsich gefüllt werden?", vbYesNo Or vbDefaultButton2, "Strecke ist nicht prüfbereit") = vbYes Then
            m_SPS.setBetrieb 1
            PrintStatus "Betrieb vorbereiten: Spannen und Füllen..."
        End If

        Do While Not m_SPS.IstStreckeGefuellt
            sleep 1000, True
            If g_Abbruch = True Then
                Exit Sub
            End If
        Loop
        ' nach dem Füllen: Betrieb auf 0
        sleep 500
        m_SPS.setBetrieb 0
        
    
       '------------------------------------------------------------------------
    
        PrintStatus "Warte auf Pruefbereitschaft der SPS..."
        Do While Not m_SPS.IstStreckePruefbereit
            sleep 1000, True
            If g_Abbruch = True Then
                Exit Sub
            End If
        Loop
    End If
End If

PrintStatus "Strecke ist Prüfbereit !"
    
'---------------------------------------------------------------
' vorraussichtliche Pruefzeit ausrechnen
tmpPPNr = 0
GesZeit = 0
For Each tmpPruefpunkt In m_colUniquePP.getCollection
    tmpPPNr = tmpPPNr + 1
    If m_bPruefgangLang And tmpPPNr = m_colUniquePP.Count Then
        GesZeit = GesZeit + tmpPruefpunkt.GetTime * 3
    Else
        GesZeit = GesZeit + tmpPruefpunkt.GetTime
    End If
Next
GesZeit = GesZeit * m_DauerpruefungAnzahl / 60

m_GesZeitZaehler = 0
lblGesZeit.Caption = Format(m_GesZeitZaehler, "#0.0") & "/" & Format(GesZeit, "#0.0")

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'               Vorprüfung / Justage
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

If mbln_Vorpruefung Then
    lblTitle.Caption = "Ultraschall-Zähler Vorprüfung (Justage)"
    If Vorpruefung() < 0 Then
        
        g_Abbruch = True
    End If
    Call sleep(2000, True)
End If
If g_Abbruch Then
    Call Abbruch("Es ist ein Fehler in der Vorprüfung aufgetreten.")
    Exit Sub
End If

If m_bKontinuierlich Then
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    '               Kontinuierliche
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

    Call KontinuierrlichePruefungInit
    Exit Sub
End If

If Not mbln_Hauptpruefung Then
    GoTo EndeDerHauppruefung
Else
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    '               Hauptprüfung
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    lblTitle.Caption = "Ultraschall-Zähler Hauptprüfung"
End If

If g_Abbruch Then Exit Sub
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'               Schleifenbeginn Hauptprüfung / Dauerprüfung
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
StartZeit = Now()


m_DauerStop = False
If m_DauerpruefungAnzahl > 1 Then
    cmdDauerEnde.Enabled = True
End If

For m_DauerpruefungZaehler = 1 To m_DauerpruefungAnzahl

m_DruckMsg = ""

' Pruefgang wird komplett, aber ohne Regulierung wiederholt
PrintStatus "Dauerprf.: " & m_DauerpruefungZaehler & " / " & m_DauerpruefungAnzahl
lblDauer.Caption = m_DauerpruefungZaehler & " / " & m_DauerpruefungAnzahl

PPNr = 0 ' Zaehler für Pruefpunkte , 1 = Qmax,

If m_DauerpruefungZaehler > 1 Then
    ' Neuer Pruefgang-Eintrag in der Datenbank
    m_Pruefgang.save
    Set m_Pruefgang = Nothing
    Set m_Pruefgang = New CPruefgang

    m_Pruefgang.Typ = m_ersterPruefzaehler.getIdentNrObj.getTyp
    m_Pruefgang.Nennweite = m_ersterPruefzaehler.getIdentNrObj.getNennweite
    m_Pruefgang.Nenntemperatur = m_ersterPruefzaehler.getIdentNrObj.getTemperatur
    PrintStatus "neuer Prüfgang gestarted"
    lblPruefgangNr.Caption = m_Pruefgang.PruefgangNr
End If

' Pruefgang abspeichern und neue Prüfgangnummer erzeugen
m_Pruefgang.save
lblPruefgangNr.Caption = m_Pruefgang.PruefgangNr

' Listbox mit allen Durchflüssen füllen
lstPruefpunkte.Clear
For Each tmpPruefpunkt In m_colUniquePP.getCollection
    lstPruefpunkte.AddItem Format(tmpPruefpunkt.getQ, "0.000")
Next

' Anzahl der Pruefzähler zählen, wird in Pruefgang Tabelle eingetragen
' FlexGrid dimensionieren
MSFlexGrid1.Clear

PZCount = 0
MSFlexGrid1.Cols = 1 + m_colUniquePP.Count

MSFlexGrid1.Row = 0
MSFlexGrid1.Col = 0
MSFlexGrid1.Text = "SNr.\ Q "

For Each Einbauplatz In m_colEinbauplatz
    Set Pruefzaehler = Einbauplatz.getPruefzaehler
    MSFlexGrid1.Row = Einbauplatz.getNr
    MSFlexGrid1.Col = 0
    If Not Pruefzaehler Is Nothing Then
        Einbauplatz.setAktiv True
        MSFlexGrid1.Text = Pruefzaehler.getSerienNr
        PZCount = PZCount + 1
        
         ' Änderung am 22.8.2002 Reinhard Henning:
        Pruefzaehler.getAuftragPositionSerienNr.setPruefgangNr m_Pruefgang.PruefgangNr
        Pruefzaehler.getAuftragPositionSerienNr.setEinbauplatzNr Einbauplatz.getNr
        Pruefzaehler.getAuftragPositionSerienNr.setPruefgangDatum m_Pruefgang.Datum
        ' erst mal zurücksetzen
        Pruefzaehler.getAuftragPositionSerienNr.setStatusFertigung 22
        
        ' Hochzählen des Wiederholungszählers (-1 = Original Datensatz, 0 = 1. Pruefung, 1 = 1.Wdh, 2 = 2.Wdh , usw.
        Pruefzaehler.getAuftragPositionSerienNr.setWiederholungen Pruefzaehler.getAuftragPositionSerienNr.getWiederholungen + 1
        ' Bemerkungen brauchen nicht vererbt werden ??? Todo: klären
        ' Pruefzaehler.getAuftragPositionSerienNr.setBemerkung ""
        ' alle anderen Angaben in AuftragPositionSeriennr werden von der vorherigen Wiederholung vererbt
        Pruefzaehler.getAuftragPositionSerienNr.setAnlageDatum Now()
        Pruefzaehler.getAuftragPositionSerienNr.setAnlageMitarbeiterNr g_App.Mitarbeiter.getNr
        'Angaben für Änderung löschen
        Pruefzaehler.getAuftragPositionSerienNr.setAenderungDatum Empty
        Pruefzaehler.getAuftragPositionSerienNr.setAenderungMitarbeiterNr Empty
        ' Metrologische Klasse unter der diese Prüfung durchgeführt wurde
        Pruefzaehler.getAuftragPositionSerienNr.setMetrolog Pruefzaehler.getPruefklasseKZ
                
        ' AuftragPositionsobjekt als neuen Datensatz speichern
        PrintStatus "neuer Datensatz in AuftragPosSerNr mit Pruefgang=" & m_Pruefgang.PruefgangNr & ", SerNr=" & Pruefzaehler.getSerienNr & ", Wdh=" & Pruefzaehler.getAuftragPositionSerienNr.getWiederholungen
        Pruefzaehler.getAuftragPositionSerienNr.save True

    End If
Next Einbauplatz

For i = 1 To m_colUniquePP.Count
    MSFlexGrid1.Row = 0
    MSFlexGrid1.Col = i
    MSFlexGrid1.Text = Format(m_colUniquePP.Item(i).getQ, "0.###") & " m³ [%]"
Next

m_Pruefgang.Anzahl = PZCount
PrintStatus "Anzahl eingebaute Pruefzähler: " & CStr(PZCount)

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'               Schleife für alle Pruefpunkte
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

For Each m_Pruefpunkt In m_colUniquePP.getCollection
    For i = 1 To g_App.Settings.EinbauplaetzeJeStrang
       lblVerbleib(i).Caption = ""
       lblPZImpulse(i).Caption = ""
    Next

    DoEvents
    If g_Abbruch Then
        Exit Sub
    End If

    PrintStatus "--------------------------------------"
    ' Für diesen PP wurde noch kein QIst gespeichert
    bPPQIstSaved = False

    ' Zähler für PP in PP Collection: PPNr = 1 bei Qmax
    PPNr = PPNr + 1

    PrintStatus "nächster Pruefpunkt (" & PPNr & " / " & m_colUniquePP.Count & "): " & m_Pruefpunkt.getQ

    ' Dauer dieses Pruefpunktes
    m_Pruefzeit = m_Pruefpunkt.GetTime
    PrintStatus "Soll-Pruefzeit für diesen PP: " & m_Pruefzeit & " sec"

    m_DurchflussSoll = m_Pruefpunkt.getQ

    lblQSoll.Caption = m_DurchflussSoll

    ' Durchfluß ist nun änderbar
    cmdQSollPlus.Enabled = True
    cmdQSollMinus.Enabled = True
    m_DurchflussSollManuell = m_DurchflussSoll

    ' Balkenanzeige in der Liste der Durchflüsse aktualisieren
    Call DurchflussLstAktualisieren

    ' Referenzzähler wechseln
    ' ----------------------
    ' für den Referenzzaehler-Vergleich herangezogene Referenzzaehler
    Set m_ReferenzzaehlerA = New CRefzaehler
    
    ' Referenzzaehler in Abbhängigkeit vom Durchfluß und INI Datei bestimmen
    m_ReferenzzaehlerA.loadForDurchfluss m_DurchflussSoll, 1
    FehlerRefZA = m_ReferenzzaehlerA.letzterFehler(m_DurchflussSoll)
    PrintStatus "Letzter Fehler des Referenzzählers A(interpoliert): " & Format(FehlerRefZA, "0.00") & "%"

    If g_App.Settings.getAnzahlMIDGruppen > 1 Then
       Set m_ReferenzzaehlerB = New CRefzaehler
       m_ReferenzzaehlerB.loadForDurchfluss m_DurchflussSoll, 2
       FehlerRefZB = m_ReferenzzaehlerB.letzterFehler(m_DurchflussSoll)
       PrintStatus "Letzter Fehler des Referenzzählers B(interpoliert): " & Format(FehlerRefZB, "0.00") & "%"
      
      ' Aktiven Referenzzähler auswählen
      Select Case g_App.Settings.getMIDGruppe
          Case 1
              Set m_Referenzzaehler = m_ReferenzzaehlerA
              PrintStatus "Aktive RefZ-Gruppe ist A"
              FehlerRefZ = FehlerRefZA
          Case 2
              Set m_Referenzzaehler = m_ReferenzzaehlerB
              PrintStatus "Aktive RefZ-Gruppe ist B"
              FehlerRefZ = FehlerRefZB
          Case Else
              ErrorMsg ("MID-Gruppe in INI Datei ungültig: MidGr. A gewählt")
              Set m_Referenzzaehler = m_ReferenzzaehlerA
              FehlerRefZ = FehlerRefZA
      End Select
   Else
      Set m_Referenzzaehler = m_ReferenzzaehlerA
      PrintStatus "Aktive RefZ-Gruppe ist A"
      FehlerRefZ = FehlerRefZA
   End If
   
   lblFehlerRZ.Caption = Format(FehlerRefZ, "0.00") & "%"

    ' Referenzzaehler Daten für Pruefpunkt speichern
    m_Pruefgang.PP_RefZSerienNr(PPNr) = m_Referenzzaehler.SerienNr


    If m_DurchflussSoll = 0 Then
        PrintStatus "Durchfluß ist 0, wird übersprungen"
    Else
        ' Schleife PruefgangLang initialisieren
        ZaehlerPruefgangLang = 0
        PruefgangLangPruefpunktWiederholen = False

SchleifenanfangPruefgangLang:
        ' SchleifenanfangPruefgangLang:
        ' PPNr und Q bleibt
        ' -----------------------------
        PrintStatus "Schleifenbeginn Prüfgang Lang, Zaehler=" & ZaehlerPruefgangLang
        lblLang.Caption = ZaehlerPruefgangLang

        ' Startzeit für diesen Pruefpunkt festhalten
        PPZeit = Now

        For Each Einbauplatz In m_colEinbauplatz
            If Not Einbauplatz.getPruefzaehler Is Nothing Then
                        
                If Einbauplatz.getPruefzaehler.getPruefpunkte.hasQ(m_DurchflussSoll) Then
                    udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollDurchfluss = m_DurchflussSoll
                    udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollPruefzeit_s = m_Pruefzeit
                Else
                    ' Dieser Zähler wird in diesem PP nicht geprüft
                    udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollDurchfluss = 0
                    udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollPruefzeit_s = 0
                End If

            End If
        Next

        If Not m_PruefungsArtWaage Then
            ' Vergleichsprüfung gegen RefZ: erst Pumpen starten, dann messen mit FM85

            ' SPS für diesen Prüfpunkt initialisieren:
            ' FM85 für Periodendauermessung für diesen Prüfpunkt initialisieren

            ' Da neuer Pruefpunkt, Pruefpunkt neu initialisieren
            If Not g_testModus Then
                Call initSPSfuerPP
                Call initSPSfuerDurchlauf

                ' WarteAufStartfreigabe
                PrintStatus "checke Pruefbereitschaft der SPS "
                Do While Not m_SPS.IstStreckePruefbereit
                    sleep 1000, True
                    If g_Abbruch = True Then
                        Exit Sub
                    End If
                Loop
            End If ' testModus

            PrintStatus "Warten auf Solldurchfluß erreicht..."
            If Not g_testModus Then
                ' Vergleichsprüfung gegen RefZ
                ' Pruefung starten
                m_SPS.setBetrieb 2
                Do While Not m_SPS.SolldurchflussErreicht
                    lblQIst.Caption = Format(m_SPS.getQIst, "0.000")
                    sleep 500, True
                    If g_Abbruch = True Then
                        Exit Sub
                    End If
                Loop

                ' Durchflußanzeige RefIstWert korrigiert
                QIst = m_SPS.getQIst

                PrintStatus "Solldurchfluss erreicht bei Q=" & Format(QIst, "0.000")
                lblQIst.Caption = Format(QIst, "0.000")
                ' FM85 für Periodendauermessung für diesen Pruefpunkt initialisieren
                Call initFM85fuerPP
            End If ' G_testModus
        Else
            'PruefungsArt ist Waage

            ' ZeitSoll, Durchfluß -> SollVolumen
            ' -> Behälter
            ' -> Waage
            ' Behälter leeren

            '       erst Messung mit FM85 ,
            '       dann Pumpen starten

            ' Todo: Behälter Zuleitung füllen

            ' Messung gegen Waage/Behälter in der SPS vorbereiten
            ' ---------------------------------------------------
            ' Betrieb stoppen und Pumpen Abwählen
            ' Durchfluß vorgabe
            ' Pumpe auswählen und anwählen
            ' Regelart und Regel-Position setzen
            ' MID Strang setzen


            
            ' Pruefung mit Waage
            ' --------------------
            ' geschätzes Volumen in Litern
            ' Behälterauswahl
            ' Waagenauswahl
            ' Behälter leeren oder füllen
            ' Tara
            ' Waagengrenzwert setzen
            
            If WaageVorbereitenFuerPP() < 0 Then
                Call Abbruch("Waage konnte nicht vorbereitet werden (falsches SollVolumen)")
                Exit Sub
            End If

            If g_Abbruch Then
                Exit Sub
            End If



            Call initSPSfuerPP

            If g_Abbruch Then
                Exit Sub
            End If

            ' Anzeige Füllmenge
            lblGewicht.Caption = ""

            ' Sollvolumen für Waagengrenzwert:
            ' m_VolumenSoll = (m_Pruefzeit / 3600) * m_DurchflussSoll
            ' lblSollV.Caption = Format(m_VolumenSoll * 1000, "0")

            ' Waagengrenzwert in Litern entspricht kg
            ' Waagengrenzwert = m_VolumenSoll * 1000 - m_DurchflussSoll * m_Behaelter.m_nUeberlaufFaktor
            ' PrintStatus "setze Waagengrenzwert: " & Waagengrenzwert & " kg"
            ' lblGrenzwert.Caption = Format(Waagengrenzwert, "0")
            ' Grenzwert an Waage übergeben
            ' m_Waage.SetNettoGrenzwert1 Waagengrenzwert, m_Behaelter.m_Genauigkeit

            ' Warte auf Startfreigabe
            PrintStatus "Warte auf Startfreigabe"

            Do While Not m_SPS.IstStreckePruefbereit
                sleep 1000, True
                If g_Abbruch = True Then
                    Exit Sub
                End If
            Loop

            ' Impulszählung programmieren
            ' Call initFM85fuerPP_Waage
            
            If g_Abbruch Then
                Exit Sub
            End If
        End If

        ' wieder beide Prüfungsarten (Waage und Vergleich)

        ' Anzeige diverser SPS Parameter:
            ' Betriebsanzeige Pumpen,
            ' Pumpendrehzahl,
            ' Leistungsanzeige FU,

        ' Pruefgang Daten aktualisieren
        m_Pruefgang.PP_Soll(PPNr) = m_DurchflussSoll

        ' Prüfgang Daten in DB synchronisieren
        m_Pruefgang.save

'        ' Zeit in s in der der erste Impuls erwartet wird
'        ImpulsTestZeit = (3600 / (m_DurchflussSoll * m_ImpulswertigkeitPZ)) * 2
'        PrintStatus "Pulsabstand: " & Format(ImpulsTestZeit / 2, "0.0") & " s min."
'        ImpulsTestZeit = ImpulsTestZeit
'        PrintStatus "Wartezeit auf 1. Impuls = " & Format(ImpulsTestZeit, "0.0") & " s"
'        AnzahlZaehlerOhneImpulse = 0
'        bImpulsTest = False



'''''''''''''''''''''''''''''''''''''
'           M E S S U N G
'''''''''''''''''''''''''''''''''''''

    m_Startzeit = GetTickCount()

    If g_testModus Then
        Temperatur = 21.99
    Else
        Temperatur = m_SPS.GetEinlaufTemperatur
        PrintStatus "Einlauftemperatur für diesen PP: " & Format(Temperatur, "0.00") & "°C"
    End If

    For Each Einbauplatz In m_colEinbauplatz
       udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).dblTemperatur = Temperatur
    Next

    If m_PruefungsArtWaage Then
    
        ''''''''''''''''''''''' mit Waage ''''''''''''''
        For Each Einbauplatz In m_colEinbauplatz
            EinbauplatzNr = Einbauplatz.getNr
            Set Pruefzaehler = Einbauplatz.getPruefzaehler
            If (Not Pruefzaehler Is Nothing) And Einbauplatz.getAktiv Then
                ' dieser Zähler soll geprüft werden
            
                lngRet = USSetTemperatur(EinbauplatzNr, Temperatur)
                If lngRet = 0 Then
                    PrintStatus "USSetTemperatur OK"
                Else
                    PrintStatus "USSetTemperatur Fehler" & lngRet
                End If
                
                lngRet = StarteUSundRZZaehler(EinbauplatzNr)
                If lngRet = 0 Then
                    PrintStatus "RZ-START und NOVA_START OK"
                Else
                    PrintStatus "RZ-START und NOVA_START Fehler:" & lngRet
                End If
            End If ' PZ is nothing and GetActive
        Next Einbauplatz
        
        ' Prüfung starten
        m_SPS.setBetrieb 2
        m_Tstart = GetTickCount
        PrintStatus "Pumpe gestartet"
        
        Do While Not ((m_Pumpe.GetStatus And 4) = 4)
            If m_SPS.GrenzwertWaageErreicht Then
                PrintStatus "Grenzwert erreicht bevor Pumpe läuft"
                Exit Do
            End If
            sleep 500, True
            If g_Abbruch Then
                Exit Sub
            End If
        Loop
        PrintStatus "Pumpe läuft"
        
        
        blnPruefungFertig = False
        Do While Not blnPruefungFertig
            If m_SPS.GrenzwertWaageErreicht Then
                PrintStatus "Grenzwert Waage erreicht"
                blnPruefungFertig = True
            End If
            lblGewicht = Format(m_Waage.GetGewicht, "0.00")
            AnzeigeAktualisieren
            
            ' Temperatur in den Zähler schreiben
            UpdateTemperaturInZaehler
            
            If g_Abbruch Then
                Exit Sub
            End If
            sleep 100
            DoEvents
        Loop
        
        Call m_Waage.WarteAufRuhe
            
        For Each Einbauplatz In m_colEinbauplatz
            EinbauplatzNr = Einbauplatz.getNr
            Set Pruefzaehler = Einbauplatz.getPruefzaehler
            If (Not Pruefzaehler Is Nothing) And Einbauplatz.getAktiv Then
            
                lngRet = StoppeUSundRZZaehler(EinbauplatzNr)
                If lngRet = 0 Then
                    PrintStatus "RZ-STOP und NOVA_STOP OK"
                Else
                    PrintStatus "RZ-STOP und NOVA_STOP Fehler:" & lngRet
                End If
            End If ' PZ is nothing and GetActive
        Next Einbauplatz
    Else
        Call UltraschallPruefung(udtPruefdaten_imPP_mitEBP())
    End If
    
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''
'    PrintStatus "Warten, bis der Referenzzaehler alle Impulse gezählt hat..."
'    AlleImpulseFertig = True
'    Do
'        ' Verbleibende Referenzzaehlerimpulse in FM85 für RefZ-Vergleich auslesen
'        m_FMBus.send "**" & Hex(g_FM85RefZAdresse) & "@"
'        m_FMBus.receive (500)
'
'        m_FMBus.send "J"
'        Impulse = Val("&H0000" & m_FMBus.receive(500))
'        lblVerbleibRZA.Caption = Str(Impulse)
'        If Impulse > 0 Then
'            AlleImpulseFertig = False
'        End If
'
'        m_FMBus.send "I"
'        Impulse = Val("&H0000" & m_FMBus.receive(500))
'        lblVerbleibRZB.Caption = Str(Impulse)
'        If Impulse > 0 Then
'            AlleImpulseFertig = False
'        End If
'    Loop While Not AlleImpulseFertig

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
     PP_Ist_Zeit = m_Tpruef
     m_GesZeitZaehler = m_GesZeitZaehler + PP_Ist_Zeit
     lblGesZeit.Caption = Format(m_GesZeitZaehler, "#0.0") & "/" & Format(GesZeit, "#0.0")
     
Stopphase:
        m_Pruefgang.PP_Zeit(PPNr) = m_Pruefpunkt.GetTime

        m_Pruefgang.save

        ' Betrieb stop: es ist hier ungewiss, ob Pruefpunkt wiederholt wird wenn Prüefgang Lang
        If m_bPruefgangLang And PPNr = m_colUniquePP.Count And Not m_PruefungsArtWaage Then
            ' Betrieb wird später gestoppt
        Else
            m_SPS.setBetrieb 8
            sleep 500
            m_SPS.setBetrieb 0
            lblQIst.Caption = ""
            PrintStatus "Wasser gestoppt"
        End If

        ' nach dem Qmax soll Wassertemperatur für Prüfgang ermittelt und gespeichert werden
        If PPNr = 1 Then
            If Not g_testModus Then
                Temperatur = m_SPS.GetEinlaufTemperatur
            Else
                Temperatur = 21
            End If

            m_Pruefgang.Vorlauftemperatur = Temperatur
            PrintStatus "Temperatur: " & Format(Temperatur, "0.00") & " °C"
            m_Pruefgang.save
        End If
        '----------------------------------------------------------------
        '                       Fehlerermittung
        '----------------------------------------------------------------
        PrintStatus "Fehlerermittlung:"
        PrintStatus "-----------------"

        If m_PruefungsArtWaage Then
            'PrintStatus "Beruhigungsphase..."
            'sleep 3000, True

            'm_Waage.WarteAufRuhe
            If g_Abbruch Then
                Call Abbruch("")
                Exit Sub
            End If

            Gewicht = m_Waage.GetGewicht
            lblGewicht.Caption = Format(Gewicht, "0.000")
            PrintStatus "Gewicht: " & Format(Gewicht, "0.000")

            ' Volumen in der Waage ermitteln
            BehaelterVolumen = Volumen(Gewicht, Temperatur)
            
            m_Pruefgang.PP_Waage(PPNr) = m_Behaelter.m_Nr
            m_Pruefgang.save
   
            PrintStatus "Volumen in der Waage " & m_BehaelterNr & " : " & BehaelterVolumen & " m³"
        End If

        For Each Einbauplatz In m_colEinbauplatz
            Set Pruefzaehler = Einbauplatz.getPruefzaehler
            If (Not Pruefzaehler Is Nothing) And (Einbauplatz.getAktiv = True) Then
                If (Not Pruefzaehler.getPruefpunkte Is Nothing) Then
                    If (Pruefzaehler.getPruefpunkte.hasQ(m_DurchflussSoll) = True) Then
                        MSFlexGrid1.Col = PPNr
                        MSFlexGrid1.Row = Einbauplatz.getNr

'                        ' FM85P mit entspr. Adresse ansprechen
'                        m_FMBus.send "**" & Hex(Einbauplatz.getNr) & "@"
'                        m_FMBus.receive (500)
'                        m_FMBus.send "L"
'                        Impulse = CLng("&H0" & m_FMBus.receive(500))
'                        ' Prüfzählermpulse Anzeige aktualisieren
'                        lblPZImpulse(Einbauplatz.getNr).Caption = Str(Impulse)
'                        dblVolumenRZ = Impulse / m_Referenzzaehler.ImpulseQM ' in m^3


                        Dummy = GetUSVolumen(Einbauplatz.getNr, dblVolumenUS, Einbauplatz.getPruefzaehler.getSerienNr)
                        If Dummy = 0 Then
                            PrintStatus "Volumen des US [m³]: " & dblVolumenUS
                            
                            
                        Else
                            dblVolumenUS = 0
                            PrintStatus "GetUSVolumen Fehler: " & Dummy
                        End If

                        If m_PruefungsArtWaage Then
                            ' Fehlerermittlung
                            ' Fehler = (Impulse / Pruefzaehler.GetImpulseQM - BehaelterVolumen) * 100 / BehaelterVolumen
                            ' PrintStatus " PZ" & Einbauplatz.getNr & " Fehler=" & Format(Fehler, "0.00") & " %"
                            Fehler = ((dblVolumenUS - BehaelterVolumen) / BehaelterVolumen) * 100
                            m_Pruefgang.PP_Ist_V(PPNr) = BehaelterVolumen * 1000
                            m_Pruefgang.save
                            
                        Else ' (not m_PruefungsArtWaage )
                            Call GetRZVolumen(Einbauplatz.getNr, m_Referenzzaehler, dblVolumenRZ)
                            ' Korrektur
                            DebugMsg "ermitteltes Volumen des RZ: " & dblVolumenRZ & " m³"
                            
                            dblVolumenRZ = dblVolumenRZ / (1 + m_Referenzzaehler.letzterFehler(m_DurchflussSoll) / 100)
                            m_Pruefgang.PP_Ist_V(PPNr) = dblVolumenRZ * 1000
                            m_Pruefgang.save
                            
                            DebugMsg "korrigiertes Volumen des RZ: " & dblVolumenRZ & " m³"

                            If Not dblVolumenRZ = 0 Then
                                'PrintStatus "Letzter Fehler des Referenzzählers : " & Format(FehlerRefZ, "0.00") & " %"

                                ' Fehler-Formel hergeleitet aus
                                ' Q = ( Impulswertigkeit  * Impulse) / Periodendauer
                                ' FPz = (QPz - QRz)/QRz
                                ' Fehler in % (* 100)


                                'Änderung Andreas Pfeiffer 07.04.00 #0007
                                'Wenn keine Impulse eingegangen sind soll kein Fehler berechnet werden Fehlwert = 99%
                                'Fehler Division durch 0 vermeiden und Hinweis in Datenbank auf nicht Funktion
                                If Not dblVolumenUS = 0 Then
                                    ' die Unterschiedlichen Zeiten eliminieren
                                    dblDurchflussRZ = dblVolumenRZ / udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).RZ_IstPruefzeit_ms
                                    
                                    If udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).US_IstPruefzeit_ms = 0 Then
                                        PrintStatus "Fehler des US-Zählers konnte nicht ermittelt werden, da Stop-Zeitpunkt verpasst"
                                        Fehler = 98 'Merker für "STOP Zeitpunkt verpasst"
                                    Else
                                        dblDurchflussUS = dblVolumenUS / udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).US_IstPruefzeit_ms
                                        
                                        PrintStatus "Durchfluss RZ:" & Format(dblDurchflussRZ, "0.000")
                                        PrintStatus "Durchfluss US:" & Format(dblDurchflussUS, "0.000")
                                        
                                        Fehler = ((dblDurchflussUS - dblDurchflussRZ) / dblDurchflussRZ) * 100
    
                                        PrintStatus "Fehler des PZ: " & Fehler & " %"
    
                                        ' Korrektur des Fehlers mit dem Fehler des Referenzzählers
                                        
                                        '####### geändert am 21.08.02 Pfeiffer ##########
                                        'Fehler = Fehler + FehlerRefZ
                                        'PrintStatus "Summe der Fehler: " & Format(Fehler, "0.00") & " %"
                                    End If
                                Else
                                    Fehler = 99 'Merker für "Keine Impulse"
                                    PrintStatus "Fehler: Das Volumen des US Zählers konnte nicht bestimmt werden für Einbauplatz " & Einbauplatz.getNr
                                End If

                            Else 'VolumenRZ = 0
                                PrintStatus ("Fehler: Das Volumen des Referenz-Zählers konnte aus den FM85 nicht ermittelt werden (=0)")
                            End If
                        End If ' (not m_PruefungsArtWaage )


                        PrintStatus "ermittelter Fehler: " & Format(Fehler, "0.00") & " %"
                        ' Fehler dieses Prüfpunktes für diesen Einbauplatz steht fest,
                        ' es ist aber noch nicht berücksichtigt, ob Langmessung nötig ist
                        bFehlerermittelt = False

                        If m_bPruefgangLang And PPNr = m_colUniquePP.Count Then
                            ' ------------------------------------------
                            ' Behandlung bei Pruefgang Lang,
                            ' letzter Prüfpunkt mit kleinstem Durchfluss
                            ' ------------------------------------------
                            ' Pruefgang-Lang und Pruefpunkt = Qmin.
                            FehlerInPruefgangLang(ZaehlerPruefgangLang, Einbauplatz.getNr) = Fehler

                            MSFlexGrid1.Text = Format(Fehler, "0.00") & "/" & ZaehlerPruefgangLang + 1

                            Select Case ZaehlerPruefgangLang
                                Case 0
                                    PrintStatus "PruefgangLang: 1.Fehler: wurde zwischengespeichert"
                                    PruefgangLangPruefpunktWiederholen = True
                                Case 1
                                    PrintStatus "PruefgangLang: 2.Fehler: Vergleich mit 1.Fehler"
                                    ' Abweichung aus Ini Datei in %
                                    PrintStatus "Testen ob die gemessenen Fehler abweichen um weiniger als " & g_App.Settings.getPruefgangLangAbweichung() & " % ..."
                                    PrintStatus "Einbauplatz: " & Einbauplatz.getNr
                                    PrintStatus "Fehler Lang 1: " & FehlerInPruefgangLang(1, Einbauplatz.getNr)
                                    PrintStatus "Fehler Lang 0: " & FehlerInPruefgangLang(0, Einbauplatz.getNr)
                                    PrintStatus "Abweichung: " & FehlerInPruefgangLang(1, Einbauplatz.getNr) - FehlerInPruefgangLang(0, Einbauplatz.getNr)
                                    PrintStatus " Abs() ist größer als " & g_App.Settings.getPruefgangLangAbweichung() & " ?"

                                    If Abs(FehlerInPruefgangLang(1, Einbauplatz.getNr) - FehlerInPruefgangLang(0, Einbauplatz.getNr)) > g_App.Settings.getPruefgangLangAbweichung() Then
                                        PruefgangLangPruefpunktWiederholen = True
                                        PrintStatus " ja, also Prüfung wiederholen."
                                    Else
                                        PrintStatus " nein, also Mittelwert bestimmen."
                                        ' Wiederholen, wenn mind 1 mal Abweichung überschritten
                                        ' Mittelwert aus den letzen beiden Fehlern für diesen PP bestimmen
                                        Fehler = (FehlerInPruefgangLang(1, Einbauplatz.getNr) + FehlerInPruefgangLang(0, Einbauplatz.getNr)) / 2
                                        ' Fehler steht fest
                                        bFehlerermittelt = True
                                        PruefgangLangPruefpunktWiederholen = False
                                    End If
                                Case 2
                                    PrintStatus "PruefgangLang: 3.Fehler..."
                                    ' Bestimmen der dicht beieinander liegenden Punkte
                                    Fehler = MittelwertDerFehlerOhneAusreisser(FehlerInPruefgangLang(0, Einbauplatz.getNr), FehlerInPruefgangLang(1, Einbauplatz.getNr), FehlerInPruefgangLang(2, Einbauplatz.getNr))
                                    ' Fehler steht fest
                                    bFehlerermittelt = True
                                    PruefgangLangPruefpunktWiederholen = False
                            End Select
                        Else 'm_bPruefgangLang And PPNr = m_colUniquePP.Count
                            ' ------------------------------------------
                            ' Behandlung sonst, wenn kein Pruefgang Lang
                            ' ------------------------------------------
                            bFehlerermittelt = True
                        End If ' Prüfgang lang

                        ' -------------------------------
                        ' Behandlung aller Pruefungen
                        ' -------------------------------
                        If bFehlerermittelt = True Then
                            ' Fehler steht fest:
                            ' speichern
                            Call FehlerSpeichern(Fehler, Pruefzaehler, m_Pruefgang, m_Pruefpunkt, m_colUniquePP)

                            MSFlexGrid1.Text = Format(Fehler, "0.00")
                            ' Fehler speichern für Druck
                            For i = 1 To Pruefzaehler.getPruefpunkte.getPruefpunkteCount
                                If Pruefzaehler.getPruefpunkte.getPruefpunkt(i).getQ = m_DurchflussSoll Then
                                    Pruefzaehler.getPruefpunkte.getPruefpunkt(i).setFehler Fehler
                                End If
                            Next

                            ' Bei Grenzwertüberschreitung
                            Set AuftragPositionSerienNr = Pruefzaehler.getAuftragPositionSerienNr
                            If GrenzwertUeberschritten(m_Pruefpunkt.getFGo, Fehler, m_Pruefpunkt.getFGu) Then
                                AuftragPositionSerienNr.setStatusFertigung 25
                                PrintStatus "Grenzwert überschritten. " & m_Pruefpunkt.getFGu & " < " & Fehler & " < " & m_Pruefpunkt.getFGu & " ?"
                                MSFlexGrid1.CellBackColor = &HC0C0FF
                            End If

                        End If ' bFehlerermittelt
                        PrintStatus " ermittelter Fehler = " & Format(Fehler, "0.00") & "%"
                    End If ' Prüfzähler hat diesen Prüfpunkt
                End If ' Prüfpunkte vorhanden
            End If 'Pruefzaehler vorhanden
        Next Einbauplatz 'In m_colEinbauplatz

        If m_bPruefgangLang And PPNr = m_colUniquePP.Count Then
            ZaehlerPruefgangLang = ZaehlerPruefgangLang + 1
            lblLang.Caption = (ZaehlerPruefgangLang + 1) & " ."
            DebugMsg "Zähler PGang Lang: " & ZaehlerPruefgangLang
        End If

        If Not m_PruefungsArtWaage Then
            If g_App.Settings.getAnzahlMIDGruppen > 1 Then
                ' Abweichung zwischen den Referenzzaehlern ermitteln
                m_FMBus.send "**" & Hex(g_FM85RefZAdresse) & "@"
                m_FMBus.receive (500)
                m_FMBus.send "X"
                PeriodendauerRefZ1 = Val("&H0000" & m_FMBus.receive(500))
                m_FMBus.send "Y"
                PeriodendauerRefZ2 = Val("&H0000" & m_FMBus.receive(500))
                
                PrintStatus "Referenzzaehler1 Periodendauer = " & PeriodendauerRefZ1
               PrintStatus "Referenzzaehler2 Periodendauer = " & PeriodendauerRefZ2
   
               ' Referenzzähler Vergleich
               If PeriodendauerRefZ1 = 0 Or PeriodendauerRefZ2 = 0 Then
                    PrintStatus ("Periodendauer eines RefZ (FM85P-13)liegt noch nicht vor.")
               Else
                   PrintStatus "Fehler des RefZählers A: " & FehlerRefZA & " %"
                   PrintStatus "Fehler des RefZählers B: " & FehlerRefZB & " %"
   
   '                ' Korrigierter Wert
                   PeriodendauerRefZ1 = PeriodendauerRefZ1 * (1 - FehlerRefZA / 100)
                   PeriodendauerRefZ2 = PeriodendauerRefZ2 * (1 - FehlerRefZB / 100)
   
                   PrintStatus "Referenzzaehler1 Periodendauer (korrigiert)= " & PeriodendauerRefZ1
                   PrintStatus "Referenzzaehler2 Periodendauer (korrigiert)= " & PeriodendauerRefZ2
   
                   Fehler = 100 * (PeriodendauerRefZ1 - PeriodendauerRefZ2) / (PeriodendauerRefZ1)
                   
                   ' Warnung, wenn Fehler zwischen den Referenzzählern > MaxDiff
                   If Abs(Fehler) > g_App.Settings.getMaxDiffRZ() Then
                       m_DruckMsg = m_DruckMsg & "Warnung: der Fehler zwischen Referenzzaehlern " & Format(Fehler, "0.000") & "% " & vbCrLf & "ist größer als " & g_App.Settings.getMaxDiffRZ() & " % bei Q=" & Format(m_DurchflussSoll, "0.000") & "m³/h" & vbCrLf
                       PrintStatus "Warnung: der Fehler zwischen Referenzzaehlern " & Format(Fehler, "0.000") & "% ist größer als " & g_App.Settings.getMaxDiffRZ() & " % bei Q=" & Format(m_DurchflussSoll, "0.000") & "m³/h"
                   End If ' Fehler > MaxDiff
               End If ' Periodendauer (nicht) liegt vor
            End If ' 2 Referenzzähler zum Vergleichen
        Else
            Call WaageZuruecksetzen
        End If ' Prüfungsart Vergleichsprüfung, not Waage

        lblZeit.Caption = ""

        PrintStatus "Schleifenende Pruefgang Lang: Zähler=" & ZaehlerPruefgangLang
        ' Schleifenende für Pruefgang Lang
        If PruefgangLangPruefpunktWiederholen Then
            PrintStatus "Wg. Pruefgang Lang: Pruefpunkt wiederholen..."
            m_QBehalten = True
            GoTo SchleifenanfangPruefgangLang
        End If

        m_SPS.setBetrieb 8
        sleep 500
        m_SPS.setBetrieb 0
        lblQIst.Caption = ""
        PrintStatus "Wasser gestoppt"

        lblFehlerRZ.Caption = ""

        ' Alle Einbauplätze wieder aktivieren
        For Each Einbauplatz In m_colEinbauplatz
            lblPZImpulse(Einbauplatz.getNr).BackColor = &H8000000F
            lblVerbleib(Einbauplatz.getNr).BackColor = &H8000000F
            Einbauplatz.setAktiv True
        Next

    End If ' m_DurchflussSoll > 0 ' und RZ-Vergleichs-Prüfung erfolgt
        
' Schleifenende Pruefpukte: nächster Pruefpunkt
Next m_Pruefpunkt

' Kompletter Pruefgang bendet
' ----------------------------
' Für jeden geprüften Pruefzähler:
For Each Einbauplatz In m_colEinbauplatz
    Set Pruefzaehler = Einbauplatz.getPruefzaehler
    If Not Pruefzaehler Is Nothing Then
        Set AuftragPositionSerienNr = Pruefzaehler.getAuftragPositionSerienNr
                Select Case AuftragPositionSerienNr.getStatusFertigung
            Case 25
                ' Grenzwertüberschreitung in einem Prüfpunkt
            Case 23
                ' Ausfall in einem Prüfpunkt
            Case Else
                ' Geprüft in allen Prüfpunkten ohne Ausfall und Grenzwertüberschreitung
                AuftragPositionSerienNr.setStatusFertigung 30
                ' Todo:
                ' AuftragPosition.FertigemeldeTermin FertigmeldeMitarbeiter
                ' FertMeld_Pterm_MA = Mitarbeiter.GetNr
                ' P_IstTerm = now()
                ' Fertmeld_Pterm_Dat = now()
        End Select
        AuftragPositionSerienNr.save
    End If
Next Einbauplatz



' Todo: wann neuer Prüfgang für AuftragpositionSeriennummer ?

PrintStatus "Schleifenende Dauerprüfung. " & m_DauerpruefungZaehler
If m_DauerStop = True Then
    PrintStatus "Dauerprüfung wurde vorzeitig gestopt"
    Exit For
End If
                    
Next m_DauerpruefungZaehler  ' Schleifenende Dauerprüfung

PrintStatus "Prüfergebnisse werden gespeichert..."
DoEvents
' Speichern der PruefgangDaten
m_Pruefgang.save


' SPS Betrieb Programmende
PrintStatus "Ende der Hauppruefung"

EndeDerHauppruefung:
DoEvents
' Stoppen
m_SPS.setBetrieb 0
sleep 1000


If mbln_Funktionspruefung = True Then
   lblTitle.Caption = "Funktionsprüfung"
   Call Funktionspruefung
   m_DruckMsg = m_DruckMsg & vbCrLf & "Ergebnisse der Funktionsprüfung: " & vbCrLf & strFunktionsPruefungMsg
End If

PrintStatus "Prüfergebnisse werden gedruckt..."
DoEvents
Call PruefgangDruck(m_Pruefgang, Temperatur, m_colEinbauplatz, PZCount, m_DruckMsg)


lblTitle.Caption = "Ultraschall-Zähler Prüfung"

' Programmende einleiten
If MsgBox("Automatisch beenden ?", vbYesNo) = vbNo Then
        GoTo Fertig ' nicht öffnen
Else
    ' lösen
    m_SPS.setBetrieb 4
    sleep 1000
End If

If m_NurMesseinsaetze = False Then
    ' warten bis Lösen begonnen wurde
    PrintStatus "Warten bis Lösen beginnt..."
    Do While m_SPS.IstStreckeGespannt
        sleep 1000, True
        If g_Abbruch = True Then
            Exit Sub
        End If
    Loop
    PrintStatus "Lösen..."
End If

Fertig:

' Jetzt kann Betrieb = 0 gesetzt werden
m_SPS.SetQSoll 0
sleep 1000
m_SPS.setBetrieb 0
sleep 1000

Call ResetPruefung
If m_PruefungsArtWaage = True Then
    Call m_Waage.releaseMScomm
End If
endDialog IDOK
End Sub

Private Sub initSPSfuerDurchlauf()
        ' Durchlauf auswählen
        m_SPS.setBehaelter 1
        lblGewichtLabel.Enabled = False
        lblGewicht.Enabled = False
End Sub


Private Function initSPSfuerPP()
' SPS für diesen Prüfpunkt initialisieren, unabhängig von Waage/Behälter oder Durchlauf
' -------------------------------------------------------------------------------------
' Betrieb stoppen und Pumpen Abwählen
' Durchfluß vorgabe
' Pumpe auswählen und anwählen
' Regelart und Regel-Position setzen
' MID Strang setzen

    Dim Einbauplatz As CEinbauplatz
    Dim i As Integer
    Dim iStellwert As Integer
    
    'Dim Waagengrenzwert As Double
        
    
        
    ' Betrieb Start zurücksetzen
    m_SPS.setBetrieb 8
    sleep 500
    m_SPS.setBetrieb 0
        
        
    m_SPS.SetQSoll m_DurchflussSoll
    PrintStatus "Nächster Durchfluss: " & m_DurchflussSoll
            
    ' Pumpenauswahl
    ' Hochbehälter Auswahl wenn Q < 1 m ^3 -> Pumpe.Nr = 4
    ' siehe modPumpe
    m_SPS.AllePumpenAbwaehlen
        
    Set m_Pumpe = Pumpenwahl(m_DurchflussSoll, m_ColPumpen)
    PrintStatus "zu startende Pumpe: " & m_Pumpe.GetSPSVarname
    m_Pumpe.Anwahl
            
    Select Case m_Pumpe.GetRegelart
    Case "Servo"
        ' Servo vorgeschrieben
        m_SPS.SetRegelart ("Servo")
        ' Formel für ServoPosition zur Feinregulierung des Durchflusses
        iStellwert = CInt(lookupFUServoStellwert(m_DurchflussSoll, "Servo"))
        If iStellwert > 100 Then iStellwert = 100
        PrintStatus "Stellwert: " & iStellwert
        
        m_SPS.SetServoStellung iStellwert
    Case "FU"
        ' Frequenzumrichter vorgeschrieben
        m_SPS.SetRegelart ("FU")
        ' Formel für ServoPosition zur Feinregulierung des Durchflusses
        
        If m_DurchflussSoll = m_ersterPruefzaehler.getPruefpunkte.getPruefpunkt(1).getQ Then
            iStellwert = GetUSVoreinstellwert(m_DurchflussSoll)
        Else
            iStellwert = 50
        End If
        
        'If iStellwert = 0 Then
        '    PrintStatus "GetUSVoreinstellwert= 0, deshalb Voreinstellwert aus RZPP"
        '    iStellwert = lookupFUServoStellwert(m_DurchflussSoll, "FU")
        'End If
        ' iStellwert = iStellwert * (1 + (m_AnzahlPZ * (100 - m_ersterPruefzaehler.getIdentNrObj.GetNennweite) * 0.001))
        
        If iStellwert > 100 Then iStellwert = 100
        PrintStatus "Stellwert: " & iStellwert
        m_SPS.SetServoStellung iStellwert
    Case Else
        ErrorMsg "Es ist keine Regelart für die Pumpe " & m_Pumpe.getNr & " in der ini-Datei definiert."
        Call Abbruch
        Exit Function
    End Select
    
    ' Vorwahl Referenzzaehler
    m_SPS.SetMID m_Referenzzaehler.EinbauplatzNr
    m_SPS.SetQDiff 0
End Function


Private Function initSPSfuerWaage()
Dim i As Integer
Dim Waagengrenzwert As Double

' initialisierung der SPS und Waage für Pruefung mit Waage
'---------------------------------------------------------
' Behälterauswahl
' Waagenanwahl
' Waagengrenzwert auf oberen Wert
' Behälter leeren
' Waage tarieren
' letzter Fehler auf 0

    ' geschätzes Volumen in Litern als Sollvolumen für Waagengrenzwert:
    m_VolumenSoll = m_Pruefzeit * m_DurchflussSoll / 3.6
    PrintStatus "geschätztes Soll-Volumen in Litern: " & m_VolumenSoll
    lblSollV.Caption = Format(m_VolumenSoll, "0")
        
    ' Behälterauswahl
    For i = 1 To 2
        If m_ArrayBehaelter(i).IstOkFuerVolumen(m_VolumenSoll) Then
            Set m_Behaelter = m_ArrayBehaelter(i)
            m_BehaelterNr = i
            Exit For
        End If
    Next
        
    ' Waagenanwahl
    If Not m_Behaelter Is Nothing Then
        PrintStatus "-> Gewählte Waage: " & m_Behaelter.m_WaageAnwahl
        PrintStatus "-> Gewählte m_Behaelter: " & m_Behaelter.m_BehaelterAnwahl
        Set m_Waage = g_App.getWaage
        
        Do While m_Waage.Anwahl(m_Behaelter.m_WaageAnwahl) = False
            If MsgBox("Waage (Anwahl=" & m_Behaelter.m_WaageAnwahl & ") konnte nicht angewählt werden." & vbCrLf & "Bitte Waagen-Reset (C-Taste) durchführen." & vbCrLf & "Möchten Sie die Waagenanwahl wiederholen ?" & vbCrLf & "Cancel bricht die Prüfung ab", vbOKCancel, "Waagen Fehler ?") = vbCancel Then
                Call Abbruch
                Exit Do
            End If
        Loop

        
        ' 2= klein, 4= groß
        m_SPS.setBehaelter m_Behaelter.m_BehaelterAnwahl
    Else
        ErrorMsg ("Es konnte keine Waage und kein Behälter für Volumen " & m_VolumenSoll & " bestimmt werden")
        ' Prüfung abbrechen
        g_Abbruch = True
        Call Abbruch
        Exit Function
    End If
    
    m_Waage.SetNettoGrenzwert1 m_Behaelter.m_WaageGrenzwert, m_Behaelter.m_Genauigkeit
    lblGrenzwert.Caption = ""
    
    m_SPS.WassserAblassen 0
    ' Vor jedem Prüfpunkt beide Behälter leeren bis Prüfmenge nicht mehr erreicht
    m_SPS.WassserAblassen 3
    PrintStatus "Beide Behälter leeren bis Prüfmenge nicht mehr erreicht..."
    sleep 5000
    Do While m_SPS.GrenzwertWaageErreicht
        sleep 1000, True
        If g_Abbruch = True Then
            Exit Function
        End If
    Loop
    
    PrintStatus "gewählten Behälter " & m_BehaelterNr & " leeren..."
    ' Vor jedem Prüfpunkt gewählten Behälter leeren
    ' ---------------------------------------------
    m_SPS.WassserAblassen m_Behaelter.m_AblassAnwahl
                    
    sleep 5000
    
    ' auf Ruhe testen
    m_Waage.WarteAufRuhe
    If g_Abbruch = True Then
        Call Abbruch
        Exit Function
    End If
    
    ' Waage ist nun in Ruhe, Ablassen kann beendet werden
    PrintStatus "Behälter ist nun leer.!"
    
    ' Wasser ablassen beenden
    m_SPS.WassserAblassen 0
    
    ' Waage tarieren
    PrintStatus "Waage Tarieren"
    m_Waage.Tara
            
    Set m_Pumpe = Pumpenwahl(m_DurchflussSoll, m_ColPumpen)
    PrintStatus "zu startende Pumpe: " & m_Pumpe.GetSPSVarname
    m_Pumpe.Anwahl
                
    ' Waagengrenzwert bestimmen
    Waagengrenzwert = m_VolumenSoll - m_DurchflussSoll * m_Behaelter.m_nUeberlaufFaktor
    PrintStatus "Waagengrenzwert: " & Waagengrenzwert
    lblGrenzwert.Caption = Format(Waagengrenzwert, "0")
    ' Grenzwert an Waage übergeben
    m_Waage.SetNettoGrenzwert1 Waagengrenzwert, m_Behaelter.m_Genauigkeit
    
    ' Der Durchfluß Wert soll unbereinigt angezeigt werden
    m_SPS.SetQDiff 0
    
    lblGewichtLabel.Enabled = True
    lblGewicht.Enabled = True

End Function

Private Function WaageVorbereitenFuerPP()
    Dim StartVolumen As Double
    Dim Gewicht As Double
    Dim letztesGewicht As Double
    
    Dim Referenzzaehler As CRefzaehler
    Dim Pumpe As CPumpe
    Dim Fuelldurchfluss As Double
    Dim Fuellvolumen As Double
    
    Dim Waagengrenzwert As Double

    PrintStatus "Waage vorbereiten für diesen Prüfpunkt:"
    lblQIst.Caption = "0"
    m_SPS.setBetrieb 0
    
    m_SPS.WassserAblassen 3
    sleep 1000, True
    m_SPS.WassserAblassen 0
    
    m_Waage.TaraReset
    m_Waage.SoftTaraReset
    
    m_VolumenSoll = m_Pruefzeit * m_DurchflussSoll / 3.6
    PrintStatus "Sollvolumen:" & Format(m_VolumenSoll, "0.000") & " l"
    '-----------------------------------------
    Set m_Behaelter = New CBehaelter
    If m_Behaelter.LoadForVolumen(m_VolumenSoll) = False Then
        MsgBox ("Es exisitiert kein Behälter für Volumen=" & m_VolumenSoll & vbCrLf & "Abbruch empfohlen!")
        WaageVorbereitenFuerPP = -1
        Exit Function
    End If
    PrintStatus "gewählter Behälter: OVolumen=" & m_Behaelter.m_OVolumen
    m_SPS.setBehaelter m_Behaelter.m_BehaelterAnwahl
    
    
    Do While m_Waage.Anwahl(m_Behaelter.m_WaageAnwahl) = False
        If MsgBox("Waage (Anwahl=" & m_Behaelter.m_WaageAnwahl & ") konnte nicht angewählt werden." & vbCrLf & "Bitte Waagen-Reset (C-Taste) durchführen." & vbCrLf & "Möchten Sie die Waagenanwahl wiederholen ?" & vbCrLf & "Cancel bricht die Prüfung ab", vbOKCancel, "Waagen Fehler ?") = vbCancel Then
            Call Abbruch
            Exit Do
        End If
    Loop
    
    '-----------------------------------------
    If m_AnwahlLetzterBehaelter <> m_Behaelter.m_BehaelterAnwahl Then
    ' Behälter wurde gewechselt oder das erste mal benutzt
        PrintStatus "Behälter wurde gewechselt oder das erste mal benutzt: (Anwahl von " & m_AnwahlLetzterBehaelter & " nach " & m_Behaelter.m_BehaelterAnwahl & ")"
        m_AnwahlLetzterBehaelter = m_Behaelter.m_BehaelterAnwahl
    
    
            PrintStatus "Wasser ganz ablassen"
            '-----------------------------------------
            ' Wasser ganz ablassen
            StartVolumen = 0
            letztesGewicht = 0
            m_SPS.WassserAblassen m_Behaelter.m_AblassAnwahl
            sleep 2000, True
            Do
                  sleep 1000, True
                  Gewicht = m_Waage.GetGewicht
                  lblGewicht = Format(Gewicht, "0.00")
                  If Gewicht = -9999 Then
                      DebugMsg ("Fehler: Gewicht konnte nicht gelesen werden")
                      sleep 200, True
                  End If
                  If letztesGewicht = Gewicht Then Exit Do
                  letztesGewicht = Gewicht
                  If g_Abbruch = True Then
                        Exit Function
                  End If
            Loop While Gewicht > StartVolumen
            m_SPS.WassserAblassen 0
            
                
            '---------------------------------------
            ' Rohr füllen
            Fuelldurchfluss = m_ersterPruefzaehler.getPruefpunkte.getPruefpunkt(1).getQ
            If Fuelldurchfluss > m_Behaelter.m_Fuelldurchfluss Then
                ' Bestimme den kleineren Durchfluß von Qmax-Zähler und Behälter
                Fuelldurchfluss = m_Behaelter.m_Fuelldurchfluss
            End If
            
            Fuellvolumen = m_Behaelter.m_Fuellvolumen
            If Fuellvolumen = 0 Then
                Fuellvolumen = m_Behaelter.m_OVolumen * 0.1
                PrintStatus "Füllvolumen auf 10% gesetzt. Bitte Fuellvolumen in ini Datei pflegen!"
            End If
                        
            ' Setze MID und MIDGruppe
            Set Referenzzaehler = New CRefzaehler
            Call Referenzzaehler.loadForDurchfluss(Fuelldurchfluss, g_App.Settings.getMIDGruppe)
            m_SPS.SetMID Referenzzaehler.EinbauplatzNr
            m_SPS.SetQDiff 0
            
            m_SPS.AllePumpenAbwaehlen
            Set Pumpe = Pumpenwahl(m_Behaelter.m_Fuelldurchfluss, m_ColPumpen)
            Pumpe.Anwahl
            PrintStatus "gewählte Pumpe: " & Pumpe.GetSPSVarname
            '----------------------------------------------------------
            ' Füllen bis 10% des Behältervolumens
            PrintStatus "Rohr füllen mit Fülldurchfluß " & Fuelldurchfluss & " auf Fuellvolumen " & Fuellvolumen & " l in " & m_Behaelter.m_OVolumen & " l Behälter"
            
            m_SPS.SetServoStellung lookupFUServoStellwert(Fuelldurchfluss)
            m_SPS.SetQSoll Fuelldurchfluss
            
            lblSollV = Format(Fuellvolumen, "0.0")
            lblQSoll.Caption = Fuelldurchfluss
            m_SPS.setBetrieb 2
            Do
                
                sleep 1000, True
                Gewicht = m_Waage.GetGewicht
                lblGewicht = Gewicht
                If Gewicht = -9999 Then
                    DebugMsg ("Fehler: Gewicht konnte nicht gelesen werden")
                    sleep 200, True
                End If
                If g_Abbruch = True Then
                    Exit Function
                End If
            Loop While Gewicht < Fuellvolumen
            m_SPS.setBetrieb 0
            lblQSoll.Caption = 0
        '-----------------------------------------
         
         PrintStatus "Wasser ganz ablassen"
         '-----------------------------------------
         ' Wasser ganz ablassen
         StartVolumen = 0
         letztesGewicht = 0
         lblSollV.Caption = "0"
         m_SPS.WassserAblassen m_Behaelter.m_AblassAnwahl
         sleep 2000, True
         Do
               sleep 1000, True
               Gewicht = m_Waage.GetGewicht
               lblGewicht = Format(Gewicht, "0.00")
               If Gewicht = -9999 Then
                   DebugMsg ("Fehler: Gewicht konnte nicht gelesen werden")
                   sleep 200, True
               End If
               If letztesGewicht = Gewicht Then Exit Do
               letztesGewicht = Gewicht
               If g_Abbruch = True Then
                  Exit Function
               End If
         Loop While Gewicht > StartVolumen
         m_SPS.WassserAblassen 0
         '---------------------------------------

    End If 'Behälterwechsel
    '-----------------------------------------
            
    Gewicht = m_Waage.GetGewicht
    lblGewicht = Format(Gewicht, "0.00")
    
    ' geschätzes Volumen in Litern als Sollvolumen für Waagengrenzwert:
    m_VolumenSoll = m_Pruefzeit * m_DurchflussSoll / 3.6
    PrintStatus "geschätztes Soll-Volumen in Litern: " & Format(m_VolumenSoll, "0")
    lblSollV.Caption = Format(m_VolumenSoll, "0")
    
    If m_VolumenSoll + Volumen(Gewicht, m_SPS.GetEinlaufTemperatur) * 1000 > m_Behaelter.m_WaageGrenzwert Then
        ' Zuviel Wasser drin, also ablassen
        '-----------------------------------------
        ' Wasser ganz ablassen
        StartVolumen = 0
        m_SPS.WassserAblassen m_Behaelter.m_AblassAnwahl
        sleep 2000, True
        Do
              sleep 200, True
              Gewicht = m_Waage.GetGewicht
              lblGewicht = Gewicht
              If Gewicht = -9999 Then
                  DebugMsg ("Fehler: Gewicht konnte nicht gelesen werden")
                  sleep 200, True
              End If
              If g_Abbruch = True Then
                  Exit Function
              End If
              If letztesGewicht = Gewicht Then Exit Do
              letztesGewicht = Gewicht
        Loop While Gewicht > StartVolumen
        m_SPS.WassserAblassen 0
        '-----------------------------------------
    End If
    ' hier ist sichergestellt dass mind. noch das Sollvolumen hinein passt
    
    ' neuen Grenzwert für das Sollvolumen setzen
    Gewicht = m_Waage.GetGewicht
    lblGewicht = Format(Gewicht, "0.00")
        
    PrintStatus "Warten auf Waagen Ruhe"
    m_Waage.WarteAufRuhe
    
    Gewicht = m_Waage.GetGewicht
    lblGewicht = Format(Gewicht, "0.00")
    
    PrintStatus " neuer Grenzwert :" & Format(Volumen(Gewicht, m_SPS.GetEinlaufTemperatur) * 1000, "0.000") & " + " & Format(m_VolumenSoll, "0.000") & " = " & Format(m_VolumenSoll + Volumen(Gewicht, m_SPS.GetEinlaufTemperatur) * 1000, "0.000")
    Waagengrenzwert = m_VolumenSoll + Volumen(Gewicht, m_SPS.GetEinlaufTemperatur) * 1000
    lblGrenzwert.Caption = Format(Waagengrenzwert, "0.00")
    
    m_Waage.SetNettoGrenzwert1 Waagengrenzwert
        
    ' dieses Gewicht gilt
    m_Waage.SoftTara
    lblGewicht = "0"
    
End Function


Private Sub initFM85fuerPP_Waage()
    ' FM85 für Impulszählung für diesen Pruefpunkt initialisieren
    sendonly "**0@"
    sendonly "R"
    
    sleep 1000, True
    
    ' PZ Impulse zählen
    sendonly "Q"
    
    ' RZ Impulse zählen
    sendonly "O"
    
    m_FMBus.dialog "**" & Hex(m_ersterPruefzaehlerNr) & "@", "FM85"
    
    m_FMBus.send "42 "
    Dummy = Mid(m_FMBus.receive(500), 6, 2)
    If Dummy <> "00" And Dummy <> "03" Then
        If MsgBox("FM85 Fehlerbyte ist weder '00' noch '03'" & vbCrLf & "Möchten Sie weitermachen", vbYesNo) = vbYes Then
        Else
            ' Todo: Allgemeine Abbruchfunktion
            ' Prüfung abbrechen
            g_Abbruch = True
            Call Abbruch
            Exit Sub
        End If
    End If
End Sub




'-------------------------------------------------------------------------
'' FM85 für diesen Prüfpunkt initialisieren:
Private Sub initFM85fuerPP()

    Dim AnzahlPeriodenPZ As Double
    Dim AnzahlPeriodenRZ As Double

    Dim AnzahlPeriodenPZNeu As Long

    Dim AnzahlPeriodenRZA As Long
    Dim AnzahlPeriodenRZB As Long

    Dim ImpulswertigkeitRZ As Long

    Dim Korrekturwert As Double

    Dim Fehler As Double

    Dim Pruefzaehler As CPruefzaehler
    Dim Einbauplatz As CEinbauplatz
    PrintStatus "**********************************************"
    PrintStatus "Initialisierung der FM85 für Vergleichsprüfung"
    
    ' Dummy Werte
    sendonly "**0@"
    sendonly "R"

    sleep 1000, True

    sendonly "**0@"
    ' Multiplikator
    sendonly "1s"

    ' keine Doppelimpulssperre
    sendonly "G"

    ' Doppelimpuls-Zeit
    sendonly "0000S"

    ' Dämpfung
    sendonly "3T"

    ' K Wert
    sendonly Trim("1000K+1") ' entspricht k* 0.1000 * 10 ^1 = K

    ' ----------------------------------------------------------------------------------
    ' Periodenzahl errechnen

    ImpulswertigkeitRZ = m_Referenzzaehler.ImpulseQM

'    PrintStatus "ImpulswertigkeitPZ: " & m_ImpulswertigkeitPZ
    PrintStatus "ImpulswertigkeitRZ: " & ImpulswertigkeitRZ

    If m_Pruefzeit < 60 Then
        PrintStatus "Prüfzeit dieses PP (" & m_Pruefzeit & "s) auf 60 s korrigiert."
        m_Pruefzeit = 60
    End If

 '   AnzahlPeriodenPZ = (m_Pruefzeit / 3600) * m_DurchflussSoll * m_ImpulswertigkeitPZ
 '   PrintStatus "unkorrigierter AnzahlPeriodenPZ: " & AnzahlPeriodenPZ

 '   AnzahlPeriodenPZNeu = Int(AnzahlPeriodenPZ / 10 + 0.9) * 10

'    If AnzahlPeriodenPZNeu < 20 Then
'        DebugMsg "Anzahl der Perioden (" & AnzahlPeriodenPZNeu & ") auf 20 Pulse korrigiert."
'        AnzahlPeriodenPZNeu = 20
'    End If

'    PrintStatus "AnzahlPeriodenPZNeu: " & AnzahlPeriodenPZNeu
    
'    Korrekturwert = AnzahlPeriodenPZNeu / AnzahlPeriodenPZ
'    PrintStatus "AnzahlPeriodenPZNeu / AnzahlPeriodenPZ = Korrekturwert= " & Korrekturwert

'    AnzahlPeriodenRZ = (m_Pruefzeit / 3600) * m_DurchflussSoll * ImpulswertigkeitRZ '* Korrekturwert
'    AnzahlPeriodenPZ = AnzahlPeriodenPZNeu

'    PrintStatus "Perioden RZ: " & AnzahlPeriodenRZ
'    PrintStatus "AnzahlPeriodenRZ an FM85: " & Hex(AnzahlPeriodenRZ) & "M"

'    m_FMBus.send Hex(AnzahlPeriodenRZ) & "M"
'    If m_FMBus.receive(500) <> "" Then
'        PrintStatus "Warnung: Periodenzahl RZ " & AnzahlPeriodenRZ & " für FM85 ausserhalb des zulässigen Bereiches"
'    End If

'    PrintStatus "Perioden PZ: " & AnzahlPeriodenPZ
'    PrintStatus "AnzahlPeriodenPZ an FM85: " & Hex(AnzahlPeriodenPZ) & "H"

'    m_FMBus.send Hex(AnzahlPeriodenPZ) & "H"
'    If m_FMBus.receive(500) <> "" Then
'        PrintStatus "Warnung: Periodenzahl PZ " & AnzahlPeriodenPZ & " für FM85 ausserhalb des zulässigen Bereiches"
'    End If

'    m_FMBus.dialog "**" & Hex(m_ersterPruefzaehlerNr) & "@", "FM85"
'    If g_Abbruch Then
'        Exit Sub
'    End If

'    m_FMBus.send "42 "
'    If Mid(m_FMBus.receive(500), 6, 2) <> "00" Then
'        If MsgBox("FM85 Fehlerbyte ist nicht '00'" & vbCrLf & "Möchten Sie weitermachen", vbYesNo, "FM85 Fehler") = vbYes Then
'        Else
            ' Todo: Allgemeine Abbruchfunktion
            ' Prüfung abbrechen
'            Call Abbruch
'            Exit Sub
'        End If
'    End If

''''''''''''''''''''''''''''''''''''''''''''
' FM85 Nr: 7  Referenzähler Vergleich:

    PrintStatus "Impulswertigkeit RefZ A: " & m_ReferenzzaehlerA.ImpulseQM
    AnzahlPeriodenRZA = (m_Pruefzeit / 3600) * m_DurchflussSoll * (m_ReferenzzaehlerA.ImpulseQM) '* Korrekturwert
    
    If g_App.Settings.getAnzahlMIDGruppen > 1 Then
       PrintStatus "Impulswertigkeit RefZ B: " & m_ReferenzzaehlerB.ImpulseQM
       AnzahlPeriodenRZB = (m_Pruefzeit / 3600) * m_DurchflussSoll * (m_ReferenzzaehlerB.ImpulseQM) '* Korrekturwert
   
       ' FM85 für Referenzzähler Vergleich Nr 7 setzen
       ' Adressieren
       m_FMBus.dialog "**" & Hex(g_FM85RefZAdresse) & "@", "FM85P"
       If g_Abbruch Then
           Exit Sub
       End If
   
       m_FMBus.send "R"
       m_FMBus.receive (500)
   
       sleep 1000, True
    
       ' Adressieren
       m_FMBus.send "**" & Hex(g_FM85RefZAdresse) & "@"
       m_FMBus.receive (500)
   
       ' Todo: Multiplikator
       sendonly "1s"
   
       ' keine Doppelimpulssprerre
       sendonly "G"
   
       ' Doppelimpuls-Zeit
       sendonly "0000S"
   
       ' Dämpfung
       sendonly "3T"
   
       ' Todo: K Wert für beide Referenzzähler sollte immer 1 sein
       sendonly Trim("1000K+1") ' entspricht k* 0.1000 * 10 ^1 = K = 1
   
       ' Referenzzähler A
       PrintStatus "Anzahl der Perioden RZA: " & AnzahlPeriodenRZA
       m_FMBus.send Hex(AnzahlPeriodenRZA) & "M"
       If m_FMBus.receive(500) <> "" Then
           PrintStatus "Warnung: Periodenzahl RZA " & AnzahlPeriodenRZA & " für FM85 ausserhalb des zulässigen Bereiches"
       End If
   
       ' Referenzzähler B
       PrintStatus "Anzahl der Perioden RZB: " & AnzahlPeriodenRZB
       m_FMBus.send Hex(AnzahlPeriodenRZB) & "H"
       If m_FMBus.receive(500) <> "" Then
           PrintStatus "Warnung: Periodenzahl RZB " & AnzahlPeriodenRZB & " für FM85 ausserhalb des zulässigen Bereiches"
       End If
   
       m_FMBus.send "**" & Hex(g_FM85RefZAdresse) & "@"
       m_FMBus.receive (500)
   
       m_FMBus.send "42 "
       If Mid(m_FMBus.receive(500), 6, 2) <> "00" Then
           If MsgBox("FM85 Nr.7 Fehlerbyte ist nicht '00'" & vbCrLf & "Möchten Sie weitermachen", vbYesNo) = vbYes Then
           Else
               Call Abbruch
               Exit Sub
           End If
       End If
   End If '2 RefZ
End Sub

Private Sub PrintStatus(sText As String)
    If Len(txtStatus.Text & sText) > 32768 Then
        txtStatus.Text = ""
    End If
    txtStatus.Text = txtStatus.Text & sText & vbCrLf
    txtStatus.SelStart = Len(txtStatus.Text)
    DebugMsg sText
    DoEvents
End Sub

Private Sub sendonly(Text)
    m_FMBus.send (Text)
    m_FMBus.receive (500)
End Sub

Private Function FehlerSpeichern(Fehler As Double, Pruefzaehler As CPruefzaehler, Pruefgang As CPruefgang, Pruefpunkt As CPruefpunkt, PruefpunktCol As CPruefpunktCol)
On Error GoTo FehlerSpeichernError
    Dim PruefgangNr As Long
    Dim SerienNr As Long
    Dim PPNr As Integer
    Dim rs As CRecordset
    Dim Feldname As String
    Dim sSQL As String
    
    PruefgangNr = Pruefgang.PruefgangNr
    SerienNr = Pruefzaehler.getSerienNr
    PPNr = PruefpunktCol.ItemNr(Pruefpunkt)
    
    Set rs = New CRecordset
    sSQL = "SELECT * from Prueffehler where PruefgangNr=" & PruefgangNr & " and SerienNr=" & SerienNr & ";"
    rs.openRS (sSQL)
    
    If rs.EOF Then
        rs.addNew
    End If
    
    Call rs.setValue("SerienNr", SerienNr)
    Call rs.setValue("PruefgangNr", PruefgangNr)
    
    Feldname = "PP" & CStr(PPNr) & "_Fehler"
    Call rs.setValue(Feldname, Fehler)
    Call rs.setValue("PruefDatum", Now)


    Call rs.update
    
    FehlerSpeichern = True
    Exit Function
FehlerSpeichernError:
    MsgBox ("FehlerSpeichern fehlgeschlagen: " & Err.Description)
End Function

'
'   @return Mittelwert der beiden Fehler-Werte, die am nächsten beieinander liegen,
'           sonst Mittelwert aus allen drei Fehler-Werten.
'
Private Function MittelwertDerFehlerOhneAusreisser(Fehler0 As Double, Fehler1 As Double, Fehler2 As Double) As Double
Dim d0 As Double
Dim d1 As Double
Dim d2 As Double

    ' Abstände bestimmen
    d0 = Abs(Fehler0 - Fehler1)
    d1 = Abs(Fehler0 - Fehler2)
    d2 = Abs(Fehler1 - Fehler2)
    ' Sonderfall wenn mind. 2 von 3 Abständen gleich
    MittelwertDerFehlerOhneAusreisser = (Fehler0 + Fehler1 + Fehler2) / 3
    ' Sonderfall wenn Abstand zw. F0 und F1 am kleinsten
    If d0 < d1 And d0 < d2 Then
        MittelwertDerFehlerOhneAusreisser = (Fehler0 + Fehler1) / 2
    End If
    ' Sonderfall wenn Abstand zw. F0 und F2 am kleinsten
    If d1 < d0 And d1 < d2 Then
        MittelwertDerFehlerOhneAusreisser = (Fehler0 + Fehler2) / 2
    End If
    ' Sonderfall wenn Abstand zw. F1 und F2 am kleinsten
    If d2 < d0 And d2 < d1 Then
        MittelwertDerFehlerOhneAusreisser = (Fehler1 + Fehler2) / 2
    End If
End Function


Private Sub WaageZuruecksetzen()
    Dim Behaelter As CBehaelter
    Dim i As Integer

    Set m_Waage = g_App.getWaage
    For i = 1 To 2
        
        
        Set Behaelter = m_ArrayBehaelter(i)
        If Behaelter.m_WaageAnwahl > 0 Then
            Debug.Print "Waage " & i & ": Grenzwert=" & Behaelter.m_WaageGrenzwert & " setzen..."
            m_Waage.Anwahl Behaelter.m_WaageAnwahl
            sleep 1000, True
            m_Waage.SetNettoGrenzwert1 Behaelter.m_WaageGrenzwert, Behaelter.m_Genauigkeit
            lblGrenzwert.Caption = ""
        End If
    Next
End Sub


' Führt eine komplette Ultraschallzählerprüfung für einen Prüfpunkt durch.
' Übergabe der Daten durch udtPruefdaten
Private Function UltraschallPruefung(ByRef udtPruefdaten() As TypUSPruefdaten) As Long
' kein Fehler annehmen
UltraschallPruefung = 0

Dim Einbauplatz As CEinbauplatz
Dim EinbauplatzNr As Integer
Dim Zeitrahmenzaehler As Long
Dim Fehler As Long
Dim FehlerRZ As Long

Dim lngTemp As Long
Dim Stopzeitpunkt(10) As Long 'Zeitpunkt zum Stoppen des jeweiligen FM Zählers
Dim Pruefzaehler As CPruefzaehler
Dim dblTemperatur As Double
Dim StartzeitpunktRZ As Long
Dim lngReturn  As Long
Dim blnHalbzeit As Boolean
Dim lngZeitpunktms As Long

Dim lngZeitpunktTemperaturmessungMs As Long

Dim i As Integer

    ' Bezugszeit
    m_Tstart = GetTickCount()
        
    ' Starte alle Zähler
    Zeitrahmenzaehler = 0
    
    PrintStatus " Start-Phase"
    PrintStatus "----------------------------------"
    m_Tpruef = 0
    AnzeigeAktualisieren
    ' Für alle Einbauplätze
    For EinbauplatzNr = 1 To g_App.Settings.EinbauplaetzeJeStrang
               
        With udtPruefdaten(EinbauplatzNr)
        .Stopzeitpunkt = 0
        .Fehlerinfo = ""
        .blnPruefungsfehler = False
        ' Soll dieser Zähler geprüft werden
        If .SollPruefzeit_s > 0 Then
            Set Einbauplatz = m_colEinbauplatz(EinbauplatzNr)
            Set Pruefzaehler = Einbauplatz.getPruefzaehler

            ' Temperatur für diese Ultraschallzählung messen und im Rechenwerk setzten
            dblTemperatur = m_SPS.GetEinlaufTemperatur
            ' Todo: nur im Bedarfsfall, wenn Zaehler T nicht selbst misst
            lngReturn = USSetTemperatur(EinbauplatzNr, dblTemperatur)
            
            
            If lngReturn = 0 Then
                PrintStatus "Temperatur '" & dblTemperatur & "' messen und setzten für Einbauplatz " & EinbauplatzNr
            Else
                PrintStatus "Fehler: Temperatur '" & dblTemperatur & "' messen und setzten für Einbauplatz " & EinbauplatzNr & " fehlgschlagen!"
                .Fehlerinfo = .Fehlerinfo & "Temperatur konnte nicht gesetzt werden für Einbauplatz " & EinbauplatzNr & vbCrLf
                .blnPruefungsfehler = True
            End If
            
            ' Eine Prüfzeit für alle Zähler aus dem ersten zu prüfenden Zähler
            ' Notwendig, da alle Zähler der Einbauplatz-Reihe nach gestartet und gestopt werden.
            If m_Tpruef = 0 Then
                m_Tpruef = udtPruefdaten(EinbauplatzNr).SollPruefzeit_s * 1000
            End If
            
            PrintStatus "Zähler-Einbauplatz: " & EinbauplatzNr
            
            ' mit Beginn eines Zeitrahmens synchronisieren
            Do
                Zeitrahmenzaehler = Zeitrahmenzaehler + 1
                ' Stopzeitpunkt dieses Zählers bestimmen
                ' RZ Zaehler starten
                PrintStatus "RZ soll zum Zeitpunkt " & Zeitrahmenzaehler * ZEITRAHMENDAUER & " starten"
                Fehler = StarteRZZaehlerZumZeitpunkt(EinbauplatzNr, m_Tstart + Zeitrahmenzaehler * ZEITRAHMENDAUER, .RZ_START_Rueckkehrzeitpunkt, lngZeitpunktms)
                ' Todo Zeitpunkt in Funktion einbauen
                udtPruefdaten(EinbauplatzNr).StartzeitpunktRZ = .RZ_START_Rueckkehrzeitpunkt
                PrintStatus lngZeitpunktms - m_Tstart & " RZ_START begonnen"
                PrintStatus .RZ_START_Rueckkehrzeitpunkt - m_Tstart & " RZ_START abgeschlossen"
                PrintStatus "RZ_START Dauer: " & .RZ_START_Rueckkehrzeitpunkt - lngZeitpunktms
                
                
                Select Case Fehler
                    Case KEIN_FEHLER
                        PrintStatus "RZ_START im Zeitrahmen " & Zeitrahmenzaehler & " OK"
                        Fehler = StarteUSZaehlerZumZeitpunkt(EinbauplatzNr, m_Tstart + Zeitrahmenzaehler * ZEITRAHMENDAUER + DELTA_START, .NOWA_START_Rueckkehrzeitpunkt, lngZeitpunktms)
                        PrintStatus lngZeitpunktms - m_Tstart & " NOWA_START begonnen"
                        PrintStatus .NOWA_START_Rueckkehrzeitpunkt - m_Tstart & " NOWA_START abgeschlossen"
                        Select Case Fehler
                            Case KEIN_FEHLER
                                ' hat geklappt
                                PrintStatus "NOWA_START im Zeitrahmen " & Zeitrahmenzaehler & " OK"
                                ' nur bei erfolgreichem Start den Stopzeitpunkt setzen
                                .Stopzeitpunkt = m_Tstart + (Zeitrahmenzaehler * ZEITRAHMENDAUER) + m_Tpruef
                                PrintStatus "RZ soll zum Zeitpunkt " & .Stopzeitpunkt - m_Tstart & " gestopt werden"
                                DoEvents
                            Case FEHLER_ZUSPAET
                                PrintStatus lngZeitpunktms & " Zeitfenster für Start des US-Zähler verpasst. DELTA_START zu niedrig?"
                            Case Else
                                PrintStatus "Fehlercode beim Starten des US-Zählers: " & Fehler
                                .Fehlerinfo = .Fehlerinfo & "Fehlercode beim Starten des US-Zählers " & EinbauplatzNr & ".Fehler:" & Fehler & vbCrLf
                                .blnPruefungsfehler = True
                        End Select
                    Case FEHLER_ZUSPAET
                        PrintStatus " Zeitfenster für Start des RZ-Zähler " & EinbauplatzNr & " verpasst."
                    Case KEINE_ANTWORT_FEHLER
                        PrintStatus " keine Antwort beim Starten des RZ-Zählers " & EinbauplatzNr
                        .Fehlerinfo = .Fehlerinfo & "keine Antwort beim Starten des RZ-Zählers " & EinbauplatzNr & vbCrLf
                        .blnPruefungsfehler = True
                End Select
            Loop While Fehler = FEHLER_ZUSPAET
            PrintStatus "----------------------------------"
        End If ' SollPruefzeit_s > 0
        End With
    Next EinbauplatzNr
    
    
    Do
        sleep 1000, True
        ' Verbleibende Zeit 1s bis zum Zeitrahmen vor dem ersten Stop
        lngTemp = m_Tpruef + m_Tstart - (1 * ZEITRAHMENDAUER) - GetTickCount()
        AnzeigeAktualisieren
                
        ' Bis 3s vor Ende Temperatur in alle Zähler schreiben
        If lngTemp > 3000 Then
            UpdateTemperaturInZaehler
        End If
            
        ' Halbzeit nur einmal abwarten
        If Not blnHalbzeit And m_Tpruef / 2 + m_Tstart < GetTickCount Then
            blnHalbzeit = True
    
            dblTemperatur = m_SPS.GetEinlaufTemperatur
            PrintStatus "Halbzeit Temperatur=" & Format(dblTemperatur, "0.00") & "°C"
            
            For Each Einbauplatz In m_colEinbauplatz
                Set Pruefzaehler = Einbauplatz.getPruefzaehler
                If Not Pruefzaehler Is Nothing Then
                    EinbauplatzNr = Einbauplatz.getNr
                    ' Halbzeit-Temperatur merken
                    udtPruefdaten(EinbauplatzNr).dblTemperatur = dblTemperatur
                End If ' Pruefzaehler is nothing
            Next Einbauplatz
        End If

        DoEvents
        If g_Abbruch Then
            Exit Function
        End If
        
    Loop While lngTemp > 1000 'Zeit bis zum Ende
    
    PrintStatus "----------------------------------"
    PrintStatus GetTickCount - m_Tstart & " Stop-Phase"
    ' alle US-Zähler und MIDs Stoppen
    Zeitrahmenzaehler = 0
    
    
    For EinbauplatzNr = 1 To g_App.Settings.EinbauplaetzeJeStrang
    
        With udtPruefdaten(EinbauplatzNr)
        .RZ_IstPruefzeit_ms = 0
        .US_IstPruefzeit_ms = 0
        
        If .Stopzeitpunkt <> 0 Then 'Wenn Stopzeit <> 0 dann war Start für diesen Zähler erfolgreich
            PrintStatus "Zähler-Einbauplatz: " & EinbauplatzNr
            Do
                PrintStatus "Warte auf Zeitpunkt zum Stopen des RZ: " & .Stopzeitpunkt + Zeitrahmenzaehler * ZEITRAHMENDAUER - m_Tstart
                FehlerRZ = StoppeRZZaehlerZumZeitpunkt(EinbauplatzNr, .Stopzeitpunkt + Zeitrahmenzaehler * ZEITRAHMENDAUER, .RZ_STOP_Rueckkehrzeitpunkt, lngZeitpunktms)
                PrintStatus "RZ_STOP zum Zeitpunkt " & lngZeitpunktms - m_Tstart & " begonnen"
                PrintStatus "RZ_STOP zum Zeitpunkt " & .RZ_STOP_Rueckkehrzeitpunkt - m_Tstart & " abgeschlossen"
                PrintStatus "RZ_STOP Dauer: " & .RZ_STOP_Rueckkehrzeitpunkt - lngZeitpunktms
                
                .RZ_IstPruefzeit_ms = .RZ_STOP_Rueckkehrzeitpunkt - .RZ_START_Rueckkehrzeitpunkt
                PrintStatus "reine RZ Prüfzeit (Rückkehr): " & .RZ_IstPruefzeit_ms
                
                Select Case FehlerRZ
                    Case KEIN_FEHLER
                        PrintStatus "RZ_STOP im Zeitrahmen " & Zeitrahmenzaehler & " OK"
                        ' hat geklappt
                        Fehler = StoppeUSZaehlerZumZeitpunkt(EinbauplatzNr, udtPruefdaten(EinbauplatzNr).Stopzeitpunkt + Zeitrahmenzaehler * ZEITRAHMENDAUER + DELTA_START + DELTA_FM, .NOWA_STOP_Rueckkehrzeitpunkt, lngZeitpunktms)
                        PrintStatus lngZeitpunktms - m_Tstart & " NOWA_STOP begonnen"
                        PrintStatus .NOWA_STOP_Rueckkehrzeitpunkt - m_Tstart & " NOWA_STOP abgeschlossen"
                        
                        ' .RZ_IstPruefzeit_ms = .Stopzeitpunkt + Zeitrahmenzaehler * ZEITRAHMENDAUER + DELTA_START + DELTA_FM
                        ' .US_IstPruefzeit_ms = .RZ_STOP_Rueckkehrzeitpunkt - .RZ_START_Rueckkehrzeitpunkt
                        
                        .RZ_IstPruefzeit_ms = .RZ_STOP_Rueckkehrzeitpunkt - .RZ_START_Rueckkehrzeitpunkt
                        PrintStatus "reine RZ Pruefzeit (Rückkehr): " & .RZ_IstPruefzeit_ms
                        Select Case Fehler
                            Case KEIN_FEHLER
                            ' hat geklappt
                                PrintStatus " NOWA_STOP für Einbauplatz " & EinbauplatzNr & " OK"
                                ' .US_IstPruefzeit_ms = .Stopzeitpunkt + Zeitrahmenzaehler * ZEITRAHMENDAUER + DELTA_START + DELTA_FM
                                
                                .US_IstPruefzeit_ms = .NOWA_STOP_Rueckkehrzeitpunkt - .NOWA_START_Rueckkehrzeitpunkt
                                PrintStatus "reine NOWA Zeit (Rückkehr): " & .US_IstPruefzeit_ms
                                DoEvents
                            Case FEHLER_ZUSPAET
                                ' Dieses Volumen kann nicht mehr synchron gemessen werden
                                Debug.Print " Zeitfenster für Stopp des US-Zählers " & EinbauplatzNr & " verpasst."
                                .Fehlerinfo = .Fehlerinfo & "Zeitfenster für Stopp des US-Zählers verpasst." & vbCrLf
                                .blnPruefungsfehler = True
                            Case Else
                                ' Dieses Volumen kann nicht mehr synchron gemessen werden
                                .Fehlerinfo = .Fehlerinfo & "Fehler beim Stoppen des RZ-Zählers für EinbauplatzNr " & EinbauplatzNr & ". IECCOM-Fehler: " & Fehler & vbCrLf
                                Debug.Print " Fehler beim Stoppen des RZ-Zählers für EinbauplatzNr " & EinbauplatzNr & ". IECCOM-Fehler: " & Fehler & vbCrLf
                                .blnPruefungsfehler = True
                            End Select
                    Case FEHLER_ZUSPAET
                        PrintStatus GetTickCount - m_Tstart & " Zeitfenster für Stopp des RZ-Zähler " & EinbauplatzNr & " verpasst."
                        Zeitrahmenzaehler = Zeitrahmenzaehler + 1
                    Case Else
                        ' Dieses Volumen kann nicht mehr geprüft werden
                        .Fehlerinfo = .Fehlerinfo & "Fehler '" & Fehler & "' beim stoppen des RZ-Zählers für Einbauplatznr " & EinbauplatzNr & vbCrLf
                        
                        .RZ_IstPruefzeit_ms = 0
                        .blnPruefungsfehler = True
                End Select
            Loop While FehlerRZ = FEHLER_ZUSPAET
            PrintStatus "----------------------------------"
        End If ' Stopzeitpunkt <> 0
        End With
    Next EinbauplatzNr
    AnzeigeAktualisieren
End Function



Private Function StarteUSundRZZaehler(EinbauplatzNr As Integer, Optional lngIdentNrForVeriaction As Long = -1) As Long
    Dim US_COM_Port As Integer
    US_COM_Port = g_App.Settings.getUSComPort(EinbauplatzNr)
    m_FMBus.send "**" & EinbauplatzNr & "@"
    If m_FMBus.receive(500) = "" Then
            PrintStatus "Fehler in StarteUSundRZZaehler mit FM85 an Einbauplatz " & EinbauplatzNr & ": keine Antwort"
        StarteUSundRZZaehler = KEINE_ANTWORT_FEHLER
        Exit Function
    End If
    m_FMBus.send "O"
    
    StarteUSundRZZaehler = modIECCOM.NOWA_START(US_COM_Port)
    If StarteUSundRZZaehler <> 0 Then
        PrintStatus "modIECCOM.NOWA_START Return-Wert:" & StarteUSundRZZaehler
        Exit Function
    End If

End Function



Private Function StoppeUSundRZZaehler(EinbauplatzNr As Integer, Optional lngIdentNrForVeriaction As Long = -1) As Long
    Dim US_COM_Port As Integer
    US_COM_Port = g_App.Settings.getUSComPort(EinbauplatzNr)
    
    m_FMBus.send "**" & EinbauplatzNr & "@"
    If m_FMBus.receive(500) = "" Then
        StoppeUSundRZZaehler = KEINE_ANTWORT_FEHLER
        Exit Function
    End If
    m_FMBus.send "q"
    
    StoppeUSundRZZaehler = modIECCOM.NOWA_STOP(US_COM_Port, lngIdentNrForVeriaction)
    If StoppeUSundRZZaehler <> 0 Then
        Exit Function
    End If
End Function



Private Function StarteRZZaehlerZumZeitpunkt(EinbauplatzNr As Integer, Zeitpunkt As Long, Rueckkehrzeitpunkt As Long, Optional ByRef lngZeitpunktms As Long) As Long
If g_testModus Then
    Rueckkehrzeitpunkt = Zeitpunkt + 30
    StarteRZZaehlerZumZeitpunkt = 0
    Exit Function
End If

m_FMBus.send "**" & EinbauplatzNr & "@"
If m_FMBus.receive(500) = "" Then
    StarteRZZaehlerZumZeitpunkt = KEINE_ANTWORT_FEHLER
    Exit Function
End If

StarteRZZaehlerZumZeitpunkt = FEHLER_ZUSPAET ' zu Spät
Do While Zeitpunkt > GetTickCount()
    StarteRZZaehlerZumZeitpunkt = KEIN_FEHLER
Loop
If StarteRZZaehlerZumZeitpunkt = FEHLER_ZUSPAET Then
    ' zu spät
    Exit Function
End If

lngZeitpunktms = GetTickCount()
m_FMBus.send "O"
Rueckkehrzeitpunkt = GetTickCount()
End Function


Private Function StoppeRZZaehlerZumZeitpunkt(EinbauplatzNr As Integer, Zeitpunkt As Long, Rueckkehrzeitpunkt As Long, Optional ByRef lngZeitpunktms As Long) As Long
If g_testModus Then
    Rueckkehrzeitpunkt = Zeitpunkt + 30
    StoppeRZZaehlerZumZeitpunkt = 0
    Exit Function
End If

m_FMBus.send "**" & EinbauplatzNr & "@"
If m_FMBus.receive(500) = "" Then
    StoppeRZZaehlerZumZeitpunkt = KEINE_ANTWORT_FEHLER
    Exit Function
End If

If Not m_PruefungsArtWaage Then
    StoppeRZZaehlerZumZeitpunkt = FEHLER_ZUSPAET ' zu Spät
    Do While Zeitpunkt > GetTickCount()
        StoppeRZZaehlerZumZeitpunkt = KEIN_FEHLER
    Loop
    If StoppeRZZaehlerZumZeitpunkt = FEHLER_ZUSPAET Then
        ' zu spät
        Exit Function
    End If
End If
lngZeitpunktms = GetTickCount
m_FMBus.send "q"
Rueckkehrzeitpunkt = GetTickCount
End Function


Private Function StoppeUSZaehlerZumZeitpunkt(EinbauplatzNr As Integer, Zeitpunkt As Long, Rueckkehrzeitpunkt As Long, Optional ByRef lngZeitpunktms As Long) As Long
Dim US_COM_Port As Integer
Rueckkehrzeitpunkt = GetTickCount
lngZeitpunktms = GetTickCount

Debug.Print "Zeit bis zum US-Zähler Stoppen:" & Zeitpunkt - GetTickCount()

US_COM_Port = g_App.Settings.getUSComPort(EinbauplatzNr)

If Not m_PruefungsArtWaage Then
    StoppeUSZaehlerZumZeitpunkt = FEHLER_ZUSPAET ' zu Spät
    Do While Zeitpunkt > GetTickCount()
        StoppeUSZaehlerZumZeitpunkt = KEIN_FEHLER
    Loop
    If StoppeUSZaehlerZumZeitpunkt = FEHLER_ZUSPAET Then
        ' zu spät
        Exit Function
    End If
End If
lngZeitpunktms = GetTickCount
StoppeUSZaehlerZumZeitpunkt = modIECCOM.NOWA_STOP(US_COM_Port)
Rueckkehrzeitpunkt = GetTickCount
End Function

' Rückgabe: 0 wenn kein Fehler
Private Function StarteUSZaehlerZumZeitpunkt(EinbauplatzNr As Integer, Zeitpunkt As Long, Rueckkehrzeitpunkt As Long, Optional ByRef lngZeitpunktms As Long) As Long
Dim US_COM_Port As Integer

    StarteUSZaehlerZumZeitpunkt = FEHLER_ZUSPAET  ' Zu spät
    US_COM_Port = g_App.Settings.getUSComPort(EinbauplatzNr)
    
    Do While Zeitpunkt > GetTickCount()
        StarteUSZaehlerZumZeitpunkt = KEIN_FEHLER
    Loop
    
    If StarteUSZaehlerZumZeitpunkt = FEHLER_ZUSPAET Then
        ' zu spät
        Exit Function
    End If
    lngZeitpunktms = GetTickCount
    StarteUSZaehlerZumZeitpunkt = modIECCOM.NOWA_START(US_COM_Port)
    Rueckkehrzeitpunkt = GetTickCount
End Function


Private Function Funktionspruefung() As Long
Dim QIst As Double
Dim udtPruefdaten_imPP_mitEBP(10) As TypUSPruefdaten
Dim Einbauplatz As CEinbauplatz
Dim EinbauplatzNr As Integer

Dim Pruefzaehler As CPruefzaehler
Dim dblTemperatur As Double
Dim ComPort  As Integer
Dim lngReturn As Long
Dim dtmMessDauer As Date

Dim dblEnergie As Double

Dim dblResult As Double
Dim dblDeltaT_US  As Double


lstPruefpunkte.Clear
strFunktionsPruefungMsg = ""

TestAutomatik:
   If Not m_SPS.IstAutomatik Then
       Dummy = MsgBox("Bitte SPS auf Automatik stellen", vbOKCancel)
       If Dummy = vbCancel Then
           endDialog (IDCANCEL)
           Exit Function
       End If
       GoTo TestAutomatik
   End If
        
   If Not m_SPS.IstStreckePruefbereit Then
       ' Betrieb Vorbereiten
       m_SPS.setBetrieb 1
       
       PrintStatus "Betrieb vorbereiten: Spannen und Füllen..."
       Do While Not m_SPS.IstStreckeGefuellt
           sleep 1000, True
           If g_Abbruch = True Then
               Exit Function
           End If
       Loop
       ' nach dem Füllen: Betrieb auf 0
       sleep 500
       m_SPS.setBetrieb 0
    End If
         
   If Not m_SPS.IstStreckePruefbereit Then
       ' Betrieb Vorbereiten
       m_SPS.setBetrieb 1
       
       PrintStatus "Betrieb vorbereiten: Spannen und Füllen..."
       Do While Not m_SPS.IstStreckeGefuellt
           sleep 1000, True
           If g_Abbruch = True Then
               Exit Function
           End If
       Loop
       ' nach dem Füllen: Betrieb auf 0
       sleep 500
       m_SPS.setBetrieb 0
          
       PrintStatus "Warte auf Pruefbereitschaft der SPS..."
       Do While Not m_SPS.IstStreckePruefbereit
           sleep 1000, True
           If g_Abbruch = True Then
               Exit Function
           End If
       Loop
   End If ' Pruefbereit
   PrintStatus "Strecke ist Prüfbereit !"
   PrintStatus "***** Funktionsprüfung ******"
'------------------------------------------------------------------------
      
   m_Pruefzeit = g_App.Settings.GetUSFunktionspruefung_Pruefzeit()
   Set m_Pruefpunkt = m_colUniquePP.getCollection.Item(1)
   m_DurchflussSoll = m_Pruefpunkt.getQ
   
   lstPruefpunkte.AddItem m_DurchflussSoll
   PrintStatus "Durchfluss Soll=" & m_DurchflussSoll
   Set m_Referenzzaehler = New CRefzaehler
   Call m_Referenzzaehler.loadForDurchfluss(m_DurchflussSoll, g_App.Settings.getMIDGruppe)
   m_SPS.SetQDiff 0
   
   m_SPS.SetQSoll 0
   sleep 1000
   m_SPS.setBetrieb 0
   sleep 1000
   
   m_DurchflussSoll = m_colUniquePP.getCollection.Item(1).getQ
   lblQSoll.Caption = m_DurchflussSoll
   
   ' Pumpe, MID, Regelart
   Call initSPSfuerPP
   Call DurchflussLstAktualisieren

   Call initSPSfuerDurchlauf

        ' Vergleichsprüfung gegen RefZ.: Betrieb starten
        m_SPS.setBetrieb 2
        
        ' auf konsten Durchfluß warten
        PrintStatus "Warten auf Solldurchfluß erreicht..."
        If Not g_testModus Then
            Do While Not m_SPS.SolldurchflussErreicht
                lblQIst.Caption = Format(m_SPS.getQIst, "0.000")
                sleep 500, True
                If g_Abbruch = True Then
                    Exit Function
                End If
            Loop
        End If
'------------------------------------
        
'       ' Durchflußanzeige RefIstWert korrigiert
        If Not g_testModus Then
            QIst = m_SPS.getQIst
        Else
            QIst = 99
        End If
        PrintStatus "Solldurchfluss erreicht bei Q=" & Format(QIst, "0.000")
        lblQIst.Caption = Format(QIst, "0.000")
    
                
         mdblToleranzEnergie = g_App.Settings.GetUSFunktionspruefung_Toleranz
         mdblToleranzDeltaT = g_App.Settings.GetUSFunktionspruefung_GetDelta_T
         
         
        For Each Einbauplatz In m_colEinbauplatz
            EinbauplatzNr = Einbauplatz.getNr
            Set Pruefzaehler = Einbauplatz.getPruefzaehler
            If (Not Pruefzaehler Is Nothing) Then
               ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
               mudtMessDaten(EinbauplatzNr).intPortNr = ComPort
               PrintStatus "Vorbereitung der Funktionssprüfung für Einbauplatz " & EinbauplatzNr & " am COMPort " & ComPort
               
               If ResetTemperaturTransferLock(ComPort) <> 0 Then
                  strFunktionsPruefungMsg = strFunktionsPruefungMsg & "Temperatur unlock fehlgeschlagen für Einbauplatz " & EinbauplatzNr & vbCrLf
                  PrintStatus "Temperatur unlock fehlgeschlagen für Einbauplatz " & EinbauplatzNr
               End If


            Else
               mudtMessDaten(EinbauplatzNr).intPortNr = 0
            End If
            
             
            'Alle Werte löschen
            mudtMessDaten(EinbauplatzNr).dtmStartZeit = 0
            mudtMessDaten(EinbauplatzNr).dtmStopZeit = 0
            mudtMessDaten(EinbauplatzNr).dblStartDeltaT = 0
            mudtMessDaten(EinbauplatzNr).dblStopDeltaT = 0
      '     mudtMessDaten(EinbauplatzNr).dblStartEnergy = 0
            mudtMessDaten(EinbauplatzNr).dblStopEnergy = 0
      '     mudtMessDaten(EinbauplatzNr).dblStartVolume = 0
            mudtMessDaten(EinbauplatzNr).dblStopVolume = 0
            mudtMessDaten(EinbauplatzNr).blnDeltaT_OK = False
            mudtMessDaten(EinbauplatzNr).blnEnergy_OK = False
      Next
            
      For Each Einbauplatz In m_colEinbauplatz
          EinbauplatzNr = Einbauplatz.getNr
          Set Pruefzaehler = Einbauplatz.getPruefzaehler
          If (Not Pruefzaehler Is Nothing) Then
            ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
            
            lngReturn = USSetTemperatureLock(Einbauplatz.getNr, False)
            If lngReturn = 0 Then
               lngReturn = modIECCOM.NOWA_START(ComPort)
               If lngReturn <> 0 Then
                  strFunktionsPruefungMsg = strFunktionsPruefungMsg & "NOWA_START für Einbauplatz " & EinbauplatzNr & " fehlgeschlagen" & vbCrLf
                  PrintStatus "NOWA_START für Einbauplatz " & EinbauplatzNr & " fehlgeschlagen" & vbCrLf
               Else
                  PrintStatus "NOWA_START am Einbauplatz" & EinbauplatzNr
                  mudtMessDaten(EinbauplatzNr).dtmStartZeit = GetTime()
                  lngReturn = Get_T_fp(ComPort, enuTemp_DeltaVorlaufRuecklauf, dblResult)
                     If lngReturn <> 0 Then
                        strFunktionsPruefungMsg = strFunktionsPruefungMsg & "Fehler beim Auslesen der Temperaturdifferenz für " & EinbauplatzNr & vbCrLf
                        PrintStatus "Fehler beim Auslesen der Temperaturdifferenz für " & EinbauplatzNr & vbCrLf
                     Else
                        PrintStatus "Einbauplatz" & EinbauplatzNr & " dblStartDeltaT: " & dblResult
                        mudtMessDaten(EinbauplatzNr).dblStartDeltaT = dblResult
                     End If
               End If ' NOWA_START OK
            Else
               PrintStatus "unset Temperature Lock am Einbauplatz " & EinbauplatzNr & " fehlgeschlagen"
               strFunktionsPruefungMsg = strFunktionsPruefungMsg & "unset Temperature Lock am Einbauplatz " & EinbauplatzNr & " fehlgeschlagen" & vbCrLf
            End If ' Temperatur Lock
         End If 'Pruefzaehler Is Nothing
      Next 'Einbauplatz
      
      PrintStatus "Messung dauert " & m_Pruefzeit & " Sekunden"
      Call sleep(m_Pruefzeit * 1000, True)
    
      For Each Einbauplatz In m_colEinbauplatz
         EinbauplatzNr = Einbauplatz.getNr
         Set Pruefzaehler = Einbauplatz.getPruefzaehler
         If (Not Pruefzaehler Is Nothing) Then
            ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
            
            lngReturn = modIECCOM.NOWA_STOP(ComPort)
            If lngReturn <> 0 Then
               strFunktionsPruefungMsg = strFunktionsPruefungMsg & "NOWA_STOP fehlgeschlagen am Einbauplatz " & EinbauplatzNr
               PrintStatus "NOWA_STOP fehlgeschlagen am Einbauplatz " & EinbauplatzNr
            Else
               mudtMessDaten(Einbauplatz.getNr).dtmStopZeit = GetTime()
               PrintStatus "NOWA_STOP am Einbauplatz " & EinbauplatzNr
            End If
         End If
      Next
            
      m_SPS.SetQSoll 0
      sleep 1000
      m_SPS.setBetrieb 0
         
      For Each Einbauplatz In m_colEinbauplatz
         EinbauplatzNr = Einbauplatz.getNr
         Set Pruefzaehler = Einbauplatz.getPruefzaehler
         ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
         If (Not Pruefzaehler Is Nothing) Then
            lngReturn = Get_T_fp(ComPort, enuTemp_DeltaVorlaufRuecklauf, dblResult)
            If lngReturn <> 0 Then
               strFunktionsPruefungMsg = strFunktionsPruefungMsg & "Fehler beim Auslesen der Temperaturdifferenz im Einbauplatz " & EinbauplatzNr & vbCrLf
               PrintStatus "Fehler beim Auslesen der Temperaturdifferenz im Einbauplatz " & EinbauplatzNr & vbCrLf
            Else
            
               PrintStatus "StopDeltaT = " & Format(dblResult, "0.00") & " am Einbauplatz " & EinbauplatzNr
               mudtMessDaten(EinbauplatzNr).dblStopDeltaT = dblResult
               
               lngReturn = Get_NOWA_energy(ComPort, dblResult)
               If lngReturn <> 0 Then
                  strFunktionsPruefungMsg = strFunktionsPruefungMsg & "Fehler beim Auslesen des Energiewertes im Einbauplatz " & EinbauplatzNr & vbCrLf
                  PrintStatus "Fehler beim Auslesen des Energiewertes im Einbauplatz " & EinbauplatzNr & vbCrLf
               Else
                  PrintStatus "NOWA_Energie= " & dblResult & " am Einbauplatz " & EinbauplatzNr
                  mudtMessDaten(EinbauplatzNr).dblStopEnergy = dblResult
                  lngReturn = Get_NOWA_volume_fp(ComPort, dblResult)
                  If lngReturn <> 0 Then
                     strFunktionsPruefungMsg = strFunktionsPruefungMsg & "Fehler beim Auslesen des Volumens im Einbauplatz " & EinbauplatzNr & vbCrLf
                     PrintStatus "Fehler beim Auslesen des Volumens im Einbauplatz " & EinbauplatzNr
                  Else
                     PrintStatus "dblStopVolume= " & Format(dblResult, "0.00") & " am Einbauplatz " & EinbauplatzNr
                     mudtMessDaten(EinbauplatzNr).dblStopVolume = dblResult
                     ' Energie OK ?
                     mudtMessDaten(EinbauplatzNr).blnEnergy_OK = isEnergyOK(mudtMessDaten(EinbauplatzNr).dblStopVolume, mudtMessDaten(EinbauplatzNr).dblStopEnergy, _
                                                 mudtMessDaten(EinbauplatzNr).dblStartDeltaT, mudtMessDaten(EinbauplatzNr).dblStopDeltaT, _
                                                 dtmMessDauer)
                     
                     PrintStatus "- - - - - - "
                     PrintStatus "Einbauplatz " & EinbauplatzNr
                     'Alle Werte anzeigen
                     PrintStatus "Comport " & mudtMessDaten(EinbauplatzNr).intPortNr
                     PrintStatus "dtmStartZeit " & mudtMessDaten(EinbauplatzNr).dtmStartZeit
                     PrintStatus "dtmStopZeit  " & mudtMessDaten(EinbauplatzNr).dtmStopZeit
                     PrintStatus "dblStartDeltaT " & Format(mudtMessDaten(EinbauplatzNr).dblStartDeltaT, "0.00")
                     PrintStatus "dblStopDeltaT " & mudtMessDaten(EinbauplatzNr).dblStopDeltaT
               '      mudtMessDaten(EinbauplatzNr).dblStartEnergy = 0
                     PrintStatus "dblStopEnergy " & Format(mudtMessDaten(EinbauplatzNr).dblStopEnergy, "0.00")
               '      mudtMessDaten(EinbauplatzNr).dblStartVolume = 0
                     PrintStatus "dblStopVolume " & Format(mudtMessDaten(EinbauplatzNr).dblStopVolume, "0.00")
                     'PrintStatus "blnDeltaT_OK " & mudtMessDaten(EinbauplatzNr).blnDeltaT_OK
                      PrintStatus "blnEnergy_OK " & mudtMessDaten(EinbauplatzNr).blnEnergy_OK
                     
                     
                     
                     
                     'If Not DeltaT_Difference_OK(mudtMessDaten(EinbauplatzNr).intPortNr) Then
                        'Fehlerabweichung zu groß
                       ' strFunktionsPruefungMsg = strFunktionsPruefungMsg & "DeltaT Fehlerabweichung am Einbauplatz " & EinbauplatzNr & " zu groß" & vbCrLf
                        'PrintStatus "DeltaT Fehlerabweichung am Einbauplatz " & EinbauplatzNr & " zu groß" & vbCrLf
                     'Else
                        'mudtMessDaten(Einbau).blnDeltaT_OK = True
                     'End If
         
         
                  End If 'Get_NOWA_volume_fp lngReturn <> 0
               End If ' Get_NOWA_energy lngReturn <> 0
            End If ' Get_T_fp lngReturn <> 0
         End If 'not Pruefzaehler Is Nothing
      Next ' Einbauplatz
      m_SPS.SetQSoll 0
      
      For Each Einbauplatz In m_colEinbauplatz
         EinbauplatzNr = Einbauplatz.getNr
         Set Pruefzaehler = Einbauplatz.getPruefzaehler
         If (Not Pruefzaehler Is Nothing) Then
            
            If mudtMessDaten(EinbauplatzNr).dtmStopZeit > 0 And mudtMessDaten(EinbauplatzNr).dtmStartZeit > 0 Then
            dtmMessDauer = mudtMessDaten(EinbauplatzNr).dtmStopZeit - mudtMessDaten(EinbauplatzNr).dtmStartZeit
     
               dblEnergie = GetSollEnergy(mudtMessDaten(EinbauplatzNr).dblStopVolume, mudtMessDaten(EinbauplatzNr).dblStopEnergy, _
                                                 mudtMessDaten(EinbauplatzNr).dblStartDeltaT, mudtMessDaten(EinbauplatzNr).dblStopDeltaT, _
                                                 dtmMessDauer)
                                                 
               PrintStatus "Einbauplatz " & EinbauplatzNr & ": gerechnete Energie= " & Format(dblEnergie, "0.00") & " kWh"
               PrintStatus "Einbauplatz " & EinbauplatzNr & ": NOWA Energie= " & Format(mudtMessDaten(EinbauplatzNr).dblStopEnergy, "0.00")
               
               
               If mudtMessDaten(EinbauplatzNr).dblStopEnergy <> 0 Then
                  PrintStatus "Fehler der Energie in %: " & Format((mudtMessDaten(EinbauplatzNr).dblStopEnergy - dblEnergie) / mudtMessDaten(EinbauplatzNr).dblStopEnergy * 100, "0.00")
               
                  If (mudtMessDaten(EinbauplatzNr).dblStopEnergy - dblEnergie) / mudtMessDaten(EinbauplatzNr).dblStopEnergy > g_App.Settings.GetUSFunktionspruefung_Toleranz Then
                     strFunktionsPruefungMsg = strFunktionsPruefungMsg & "Einbauplatz " & EinbauplatzNr & ":"
                     strFunktionsPruefungMsg = strFunktionsPruefungMsg & "   Die NOWA Energie weicht von der errechneten Energie ab:" & vbCrLf
                     strFunktionsPruefungMsg = strFunktionsPruefungMsg & "   errechnete Energie= " & Format(dblEnergie, "0.00") & " kWh" & vbCrLf
                     strFunktionsPruefungMsg = strFunktionsPruefungMsg & "   NOWA Energie= " & Format(mudtMessDaten(EinbauplatzNr).dblStopEnergy, "0.00") & " kWh" & vbCrLf
                     strFunktionsPruefungMsg = strFunktionsPruefungMsg & "   Abweichung    : " & Format((mudtMessDaten(EinbauplatzNr).dblStopEnergy - dblEnergie) / mudtMessDaten(EinbauplatzNr).dblStopEnergy * 100, "0.00") & " %" & vbCrLf
                     strFunktionsPruefungMsg = strFunktionsPruefungMsg & "   Toleranzgrenze: " & g_App.Settings.GetUSFunktionspruefung_Toleranz & " %" & vbCrLf
                  End If
               Else
                   strFunktionsPruefungMsg = strFunktionsPruefungMsg & "Einbauplatz " & EinbauplatzNr & vbCrLf & "   NOWA Energie = 0 !" & vbCrLf
               End If
               
               PrintStatus "gemessenes DeltaT = " & (mudtMessDaten(EinbauplatzNr).dblStartDeltaT + mudtMessDaten(EinbauplatzNr).dblStopDeltaT) / 2 & " K"
               
               If (mudtMessDaten(EinbauplatzNr).dblStartDeltaT + mudtMessDaten(EinbauplatzNr).dblStopDeltaT) / 2 < g_App.Settings.GetUSFunktionspruefung_GetDelta_T Then
                     strFunktionsPruefungMsg = strFunktionsPruefungMsg & "Einbauplatz " & EinbauplatzNr & vbCrLf
                     strFunktionsPruefungMsg = strFunktionsPruefungMsg & "   DeltaT unterschreitet die Toleranzgrenze von " & g_App.Settings.GetUSFunktionspruefung_GetDelta_T & " °K" & vbCrLf
                     strFunktionsPruefungMsg = strFunktionsPruefungMsg & "   gemessenes DeltaT: " & Format((mudtMessDaten(EinbauplatzNr).dblStartDeltaT + mudtMessDaten(EinbauplatzNr).dblStopDeltaT) / 2, "0.00") & " °K" & vbCrLf
               Else
                  mudtMessDaten(EinbauplatzNr).blnDeltaT_OK = True
               End If ' DeltaT
               
               If mudtMessDaten(EinbauplatzNr).blnDeltaT_OK = True And mudtMessDaten(EinbauplatzNr).blnEnergy_OK = True Then
                  PrintStatus "Funktionsprüfung OK in Tabelle Speicherabbild schreiben"
                  SavePruefergebnis getUSFabNr(EinbauplatzNr), True
               Else
                  PrintStatus "Funktionsprüfung fehlgeschlagen in Tabelle Speicherabbild schreiben"
                  SavePruefergebnis getUSFabNr(EinbauplatzNr), False
               End If
            Else
            ' Prüfung nicht erfolgreich
            End If ' Prüfung erfolgreich
         End If ' Pruefzaehler eingebaut
      Next
      
      'If Not AllDeltaT_OK(mudtMessDaten()) Then
      'Nur die Meldung auf der Status-Anzeige ist zu sehen (z.Zt.)
      'End If
      
   ' For EinbauplatzNr = 0 To UBound(mudtMessDaten)
     ' dtmMessDauer = mudtMessDaten(EinbauplatzNr).dtmStopZeit - mudtMessDaten(EinbauplatzNr).dtmStartZeit
      '               MsgBox "dblStartVolume" & vbTab & mudtMessDaten(i).dblStartVolume & vbCrLf & _
      '                      "dblStopVolume" & vbTab & mudtMessDaten(i).dblStopVolume & vbCrLf & _
      '                      "dblStartEnergy" & vbTab & mudtMessDaten(i).dblStartEnergy & vbCrLf & _
      '                      "dblStopEnergy" & vbTab & mudtMessDaten(i).dblStopEnergy & vbCrLf & vbCrLf & _
      '                      "DAUER:         " & vbTab & dblMessDauer & _
      '                      "Durchfluß:     " & vbTab & mudtMessDaten(i).dblStopVolume / 1000 / dblMessDauer & " m³/h"
      
      '               MsgBox "dblStopVolume" & vbTab & mudtMessDaten(i).dblStopVolume & vbCrLf & _
      '                      "dblStopEnergy" & vbTab & mudtMessDaten(i).dblStopEnergy & vbCrLf & vbCrLf & _
      '                      "DAUER:         " & vbTab & dtmMessDauer & _
      '                      "Durchfluß:     " & vbTab & mudtMessDaten(i).dblStopVolume / 1000 / (dtmMessDauer * 24#) & " m³/h"
      
      'If mudtMessDaten(EinbauplatzNr).blnDeltaT_OK Then

      'mudtMessDaten(EinbauplatzNr).blnEnergy_OK = isEnergyOK(mudtMessDaten(EinbauplatzNr).dblStopVolume, mudtMessDaten(EinbauplatzNr).dblStopEnergy, _
                                           mudtMessDaten(EinbauplatzNr).dblStartDeltaT, mudtMessDaten(EinbauplatzNr).dblStopDeltaT, _
                                           dtmMessDauer)
      'End If
   'Next
EndeFunktionspruefung:
    If strFunktionsPruefungMsg <> "" Then
      Call MsgBox(strFunktionsPruefungMsg, , "Ergebniss der Funktionsprüfung")
      PrintStatus "Ergebniss der Funktionsprüfung:" & vbCrLf & strFunktionsPruefungMsg
   Else
      Call MsgBox("Alle eingebauten Zähler haben die Funktionsprüfung bestanden", , "Ergebniss der Funktionsprüfung")
      PrintStatus "Alle eingebauten Zähler haben die Funktionsprüfung bestanden"
      strFunktionsPruefungMsg = "Alle eingebauten Zähler haben die Funktionsprüfung bestanden."
    End If
    
End Function

Private Function Vorpruefung() As Long


    Dim Einbauplatz As CEinbauplatz
    Dim Pruefzaehler As CPruefzaehler
    Dim USVolumen As Double
    Dim RefVolumen As Double
    Dim PPNr As Integer
    Dim EinbauplatzNr As Integer
    Dim dblFehler As Double
    Dim lngReturn As Long
    Dim lngError As Long
    Dim Identitaetsnummer As Long
    Dim QIst As Double
    Dim dblTemperatur As Double
    Dim RefZFehler As Double
    
    Dim lngUSPruefZeit_ms As Long
    Dim lngRZPruefZeit_ms As Long
    
    Dim Fehler As Double
    Dim udtPruefdaten_imPP_mitEBP(10) As TypUSPruefdaten

    Dim firmwareVersion As Byte
    
    Dim ComPort As Integer
    Dim lngRet As Long
    Dim dblLetzterRZFehler As Double
    
    Dim udtUSParameter(10) As JustageParameter_Type
    Dim udtUSZusatzParameter(10) As US_ZusatzParameter_Typ
    
    ''''''''''''''''''''''''''''''
    Dim dblFehlerInQb(10) As Double
    Dim dblIstFlussInQb(10) As Double
    Dim dblSollFlussInQb(10) As Double
    Dim dblTemperaturInQb(10) As Double
    
    Dim dblNeuIstFluss1_m3ph As Double
    Dim dblQminFehler As Double
    
    Dim objJustageWerte(10) As CJustagewerte
    
    Set m_Referenzzaehler = New CRefzaehler
    
    
    If Not g_testModus Then
        ' Einstellung für Automatik-Modus in der SPS testen
TestAutomatik:
        If Not m_SPS.IstAutomatik Then
            Dummy = MsgBox("Bitte SPS auf Automatik stellen", vbOKCancel)
            If Dummy = vbCancel Then
                endDialog (IDCANCEL)
                Exit Function
            End If
            GoTo TestAutomatik
        End If
        
        If Not m_SPS.IstStreckePruefbereit Then
            ' Betrieb Vorbereiten
            m_SPS.setBetrieb 1
            
            PrintStatus "Betrieb vorbereiten: Spannen und Füllen..."
            Do While Not m_SPS.IstStreckeGefuellt
                sleep 1000, True
                If g_Abbruch = True Then
                    Exit Function
                End If
            Loop
            ' nach dem Füllen: Betrieb auf 0
            sleep 500
            m_SPS.setBetrieb 0
            
           '------------------------------------------------------------------------
        
            PrintStatus "Warte auf Pruefbereitschaft der SPS..."
            Do While Not m_SPS.IstStreckePruefbereit
                sleep 1000, True
                If g_Abbruch = True Then
                    Exit Function
                End If
            Loop
        End If ' Pruefbereit
        PrintStatus "Strecke ist Prüfbereit !"
    End If ' Testmodus


    PrintStatus "***** Vorprüfung ******"
    
    '''''''''''''''''''''''''''
    ' Schleife Vorprüfpunkte
    '''''''''''''''''''''''''''
    
    m_colUniqueVorPP.sortQ
    
    ' ########################### Nachjustage ###########################
    ' Je Einbauplatz werden die aktuellen Daten aus dem Zähler gelesen
    
    If mbln_nachjustage = True Then
        MsgBox ("neue ungetestete Funktion: Es findet eine Nachjustage statt. Die Startkonstanten werden aus dem Zähler gelesen.")
    End If
    
    For Each Einbauplatz In m_colEinbauplatz
        Set Pruefzaehler = Einbauplatz.getPruefzaehler
        If Not Pruefzaehler Is Nothing Then
            EinbauplatzNr = Einbauplatz.getNr
            ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
            
            ' OffsetJustage / Tabelle USJustageWerte
            Set objJustageWerte(EinbauplatzNr) = New CJustagewerte
            objJustageWerte(EinbauplatzNr).SerienNr = Pruefzaehler.getSerienNr
            
            
            If mbln_nachjustage = True Then
               
               Call modIECCOM.GetOffsetAndGeberAndBereich(ComPort, udtUSParameter(Einbauplatz.getNr))
               ' hinzugefügt RH 5.11.2002:
               Call modIECCOM.Get_FP_Flow_MaxMin(ComPort, udtUSZusatzParameter(Einbauplatz.getNr).FP_Flow_Min, udtUSZusatzParameter(Einbauplatz.getNr).FP_Flow_Max)
               
               ShowUSParameter udtUSParameter(Einbauplatz.getNr), udtUSZusatzParameter(Einbauplatz.getNr), "Justage Parameter aus Zähler", Einbauplatz.getNr
               
            Else
            
               ' Die sieben Justage Parameter aus DB vorbesetzen
               udtUSParameter(Einbauplatz.getNr).Geberkonstante1_IST_m = Pruefzaehler.getVorpruefpunkte.getGeberkonstante1
               udtUSParameter(Einbauplatz.getNr).Geberkonstante2_IST_m = Pruefzaehler.getVorpruefpunkte.getGeberkonstante2
               udtUSParameter(Einbauplatz.getNr).Offset1_IST_m3ph = Pruefzaehler.getVorpruefpunkte.getOffset1
               udtUSParameter(Einbauplatz.getNr).Offset2_IST_m3ph = Pruefzaehler.getVorpruefpunkte.getOffset2
               udtUSParameter(Einbauplatz.getNr).Bereich_ns = Pruefzaehler.getVorpruefpunkte.getBereich
               udtUSParameter(Einbauplatz.getNr).SteilheitGeber_nsp°C = Pruefzaehler.getVorpruefpunkte.getSteilheitGeber
               udtUSParameter(Einbauplatz.getNr).OffsetGeber_ns = Pruefzaehler.getVorpruefpunkte.getOffsetGeber
               
               ' die neuen Justage Parameter aus DB vorbesetzen
               udtUSParameter(Einbauplatz.getNr).Geberkonstante_Neu1_m = Pruefzaehler.getVorpruefpunkte.getGeberkonstante1
               udtUSParameter(Einbauplatz.getNr).Geberkonstante_Neu2_m = Pruefzaehler.getVorpruefpunkte.getGeberkonstante2
               udtUSParameter(Einbauplatz.getNr).Offset_Neu1_m3ph = Pruefzaehler.getVorpruefpunkte.getOffset1
               udtUSParameter(Einbauplatz.getNr).Offset_Neu2_m3ph = Pruefzaehler.getVorpruefpunkte.getOffset2
               udtUSParameter(Einbauplatz.getNr).Unlinearitaet = Pruefzaehler.getVorpruefpunkte.getUnlinearitaet / 100
               
               ' Parameter für Heiß-Kalt Spreizung as DB Vorbesetzten
               udtUSParameter(Einbauplatz.getNr).Offset_Qmin = Pruefzaehler.getVorpruefpunkte.getOffset_Qmin
               udtUSParameter(Einbauplatz.getNr).Offset_QBereich = Pruefzaehler.getVorpruefpunkte.getOffset_QBereich
               udtUSParameter(Einbauplatz.getNr).Offset_Qp = Pruefzaehler.getVorpruefpunkte.getOffset_Qp
               udtUSParameter(Einbauplatz.getNr).SollFehlerDifferenz_Qmin = Pruefzaehler.getVorpruefpunkte.getSollFehlerDifferenz_Qmin
               
               udtUSZusatzParameter(Einbauplatz.getNr).FP_Flow_Min = Pruefzaehler.getVorpruefpunkte.getFlowMin
               udtUSZusatzParameter(Einbauplatz.getNr).FP_Flow_Max = Pruefzaehler.getVorpruefpunkte.getFlowMax
               udtUSZusatzParameter(Einbauplatz.getNr).PulseMode = Pruefzaehler.getVorpruefpunkte.getPulseMode
               udtUSZusatzParameter(Einbauplatz.getNr).FP_Impulswertigkeit = Pruefzaehler.getVorpruefpunkte.getImpulswertigkeit
               udtUSZusatzParameter(Einbauplatz.getNr).FP_Impulswertigkeit_Pruef = Pruefzaehler.getVorpruefpunkte.getImpulswertigkeit_Pruef
               
               ShowUSParameter udtUSParameter(Einbauplatz.getNr), udtUSZusatzParameter(Einbauplatz.getNr), "Justage Parameter aus Datenbank", Einbauplatz.getNr
          End If ' nachjustage
        End If ' Pruefzaehler is nothing

    Next Einbauplatz
    
   ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

   ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
   
   
    If mbln_nachjustage = False Then
      
         '''''''''''''''''''''''' in Zähler schreiben '''''''''''''''''''''''''''''
         PrintStatus "Set Offset,Geber,Bereich/Impulswertigkeit/FlowMin/FlowMax f.a. Zähler"
         For Each Einbauplatz In m_colEinbauplatz
             Set Pruefzaehler = Einbauplatz.getPruefzaehler
             If Not Pruefzaehler Is Nothing Then
                 EinbauplatzNr = Einbauplatz.getNr
                 ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
                 ' und merken
                 udtPruefdaten_imPP_mitEBP(EinbauplatzNr).JustageParameter = udtUSParameter(EinbauplatzNr)

                 lngRet = modIECCOM.SetOffsetAndGeberAndBereich(ComPort, udtUSParameter(Einbauplatz.getNr))
                 If lngRet <> 0 Then
                     DebugMsg ("SetOffsetAndGeberAndBereich für Einbauplatz " & EinbauplatzNr & " gab Fehler " & lngRet & " zurück")
                 End If
                 
                 lngRet = modIECCOM.SetImpulsWertigkeitAndPulseMode(ComPort, udtUSZusatzParameter(Einbauplatz.getNr).FP_Impulswertigkeit, udtUSZusatzParameter(Einbauplatz.getNr).FP_Impulswertigkeit_Pruef, udtUSZusatzParameter(Einbauplatz.getNr).PulseMode)
                 If lngRet <> 0 Then
                     DebugMsg ("SetImpulsWertigkeitAndPulseMode für Einbauplatz " & EinbauplatzNr & " gab Fehler " & lngRet & " zurück")
                 End If
                 
                
                Call modIECCOM.Get_Slave_FLASH_Firmware_Version(ComPort, firmwareVersion)
                If firmwareVersion <= 23 Then
                    ' Vorgabe: AP, nichts tun , 25.03.2003
                    'lngRet = modIECCOM.Set_FP_Flow_MaxMin(COMport, udtUSZusatzParameter(Einbauplatz.getNr).FP_Flow_Min * 2, udtUSZusatzParameter(Einbauplatz.getNr).FP_Flow_Max)
                Else
                    lngRet = modIECCOM.Set_FP_Flow_MaxMin(ComPort, udtUSZusatzParameter(Einbauplatz.getNr).FP_Flow_Min, udtUSZusatzParameter(Einbauplatz.getNr).FP_Flow_Max)
                End If
                 
                 'ShowUSParameter udtUSParameter(Einbauplatz.getNr), udtUSZusatzParameter(Einbauplatz.getNr), "Justage Parameter aus Datenbank", Einbauplatz.getNr
                 
             End If ' Pruefzaehler is nothing
         Next Einbauplatz
   End If
   
    '''''''''''''''''''''''' 1. Prüfpunkt bei Qmax ''''''''''''''''''''''
    PPNr = 1
    Set m_vorPruefpunkt = m_colUniqueVorPP.getCollection.Item(PPNr)
    
    m_DurchflussSoll = m_vorPruefpunkt.getQ
    m_Pruefzeit = m_vorPruefpunkt.GetTime
    
    m_VolumenSoll = m_Pruefzeit * m_DurchflussSoll / 3.6
    PrintStatus "geschätztes Soll-Volumen in Litern: " & m_VolumenSoll
    lblSollV.Caption = Format(m_VolumenSoll, "0")
            
    Call m_Referenzzaehler.loadForDurchfluss(m_DurchflussSoll, g_App.Settings.getMIDGruppe)
    m_SPS.SetQDiff 0

    PrintStatus "Vorprüfung im Vorprüfpunkt 1 (QNenn):"
    
    lngRet = VorpruefungImPP(PPNr, udtPruefdaten_imPP_mitEBP())
    
    If lngRet < 0 Then
        g_Abbruch = True
        Vorpruefung = -1
    End If
    If g_Abbruch Then Exit Function
                    
    For Each Einbauplatz In m_colEinbauplatz
        Set Pruefzaehler = Einbauplatz.getPruefzaehler
        If Not Pruefzaehler Is Nothing Then
            EinbauplatzNr = Einbauplatz.getNr
            ' veränderten Wert wieder zurückholen
            udtUSParameter(EinbauplatzNr).SteilheitGeber_nsp°C = udtPruefdaten_imPP_mitEBP(EinbauplatzNr).JustageParameter.SteilheitGeber_nsp°C
        
            ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
                
            If udtPruefdaten_imPP_mitEBP(EinbauplatzNr).blnPruefungsfehler = False Then
                If udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo <> "" Then
                    PrintStatus udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo
                End If
                
                ' kein Fehler aufgetreten
                Call GetUSVolumen(EinbauplatzNr, USVolumen)
                
                If USVolumen = 0 Then
                    MsgBox ("US Volumen konnte nicht ermittelt werden")
                    Vorpruefung = -20
                    'Stop
                End If
                
                lngUSPruefZeit_ms = udtPruefdaten_imPP_mitEBP(EinbauplatzNr).US_IstPruefzeit_ms
                lngRZPruefZeit_ms = udtPruefdaten_imPP_mitEBP(EinbauplatzNr).RZ_IstPruefzeit_ms
                PrintStatus "US Zähler Prüfzeit(" & EinbauplatzNr & ")= " & lngUSPruefZeit_ms & " ms"
                PrintStatus "RZ Zähler Prüfzeit(" & EinbauplatzNr & ")= " & lngRZPruefZeit_ms & " ms"
                
                PrintStatus "US Volumen am Einbauplatz " & EinbauplatzNr & " [m³]:" & USVolumen
                
                ' Refererenz Volumen bestimmen
                If Not m_VorPruefungsArtWaage Then
                   ' Refererenz Volumen bestimmen aus Referenzzähler
                   Call GetRZVolumen(EinbauplatzNr, m_Referenzzaehler, RefVolumen)
                   PrintStatus "RZ Volumen [m³]:" & RefVolumen
                   dblLetzterRZFehler = m_Referenzzaehler.letzterFehler(m_DurchflussSoll)
                   PrintStatus "Fehler des RZ in diesem Prüfpunkt: " & Format(dblLetzterRZFehler, "0.0")
                   RefVolumen = RefVolumen / (1 + dblLetzterRZFehler / 100)
                   PrintStatus "Ist-Volumen (korrigiert mit Fehler des RZ): " & RefVolumen
                Else
                   ' Refererenz Volumen bestimmen aus Gewicht der Waage
                   RefVolumen = Volumen(m_Waage.GetGewicht, udtPruefdaten_imPP_mitEBP(EinbauplatzNr).dblTemperatur)
                   PrintStatus "Ist-Volumen [m³] (aus Waage, korrigiert mit Temperatur): " & RefVolumen
                   ' Hier sind die Prüfzeiten rechnerisch gleich
                   lngRZPruefZeit_ms = lngUSPruefZeit_ms
                End If
                
                If RefVolumen = 0 Then
                    MsgBox ("Referenz Volumen (Waage oder Referenzzähler) konnte nicht ermittelt werden")
                    Vorpruefung = -21
                    'Stop
                End If
                    
                MSFlexGrid1.Row = Einbauplatz.getNr
                MSFlexGrid1.Col = PPNr
                
                If Not lngUSPruefZeit_ms = 0 Then
                  If Not m_VorPruefungsArtWaage Then
                     'Offset_Qp abziehen, um Kurve nach oben zu bekommen
                     'geändert am 20.01.2004 AP mit Gepräch mit UD
                     RefVolumen = RefVolumen * (1 - udtUSParameter(Einbauplatz.getNr).Offset_Qp / 100 * (-1))
                     ' mit den wahren Prüfzeiten korrigierter Fehler
                     Fehler = 100 * (USVolumen / lngUSPruefZeit_ms - RefVolumen / lngRZPruefZeit_ms) / (RefVolumen / lngRZPruefZeit_ms)
                     PrintStatus "Fehler = 100 * (USVolumen / lngUSPruefZeit_ms - RefVolumen / lngRZPruefZeit_ms) / (RefVolumen / lngRZPruefZeit_ms) =" & Format(Fehler, "0.00")
                     
                  Else
                     'Offset_Qp abziehen, um Kurve nach oben zu bekommen
                     'geändert am 20.01.2004 AP mit Gepräch mit UD
                     RefVolumen = RefVolumen * (1 - udtUSParameter(Einbauplatz.getNr).Offset_Qp / 100 * (-1))
                     Fehler = 100 * (USVolumen - RefVolumen) / RefVolumen
                     PrintStatus "Fehler = 100 * (USVolumen - RefVolumen) / RefVolumen =" & Format(Fehler, "0.00")
                  End If
                  
                  dblTemperatur = m_SPS.GetEinlaufTemperatur
                  
                  MSFlexGrid1.Text = Format(Fehler, "0.00")
                  
                  udtUSParameter(Einbauplatz.getNr).Istfluss2_m3ph = USVolumen / (lngUSPruefZeit_ms / 1000 / 60 / 60)
                  udtUSParameter(Einbauplatz.getNr).Sollfluss2_m3ph = RefVolumen / (lngRZPruefZeit_ms / 1000 / 60 / 60)
                  udtUSParameter(Einbauplatz.getNr).Temperatur2_°C = dblTemperatur
                  
                  PrintStatus "gemessenes Q vom US = (USVolumen / (lngUSPruefZeit_ms / 1000 / 60 / 60)=" & udtUSParameter(Einbauplatz.getNr).Istfluss2_m3ph
                  PrintStatus "gemessenes Q vom FM85 = RefVolumen / (lngRZPruefZeit_ms / 1000 / 60 / 60) =" & udtUSParameter(Einbauplatz.getNr).Sollfluss2_m3ph
                  
                  
                  ShowUSParameter udtUSParameter(Einbauplatz.getNr), udtUSZusatzParameter(Einbauplatz.getNr), "Justage Parameter nach 1. Vor-Prüfpunkt Qmax", Einbauplatz.getNr
                Else
                    PrintStatus "Vorprüfung für Einbauplatz " & EinbauplatzNr & " fehlgeschlagen."
                    
                    MSFlexGrid1.Text = "?"
                    Vorpruefung = -23
                    'Stop
                End If
            Else
                PrintStatus "Vorprüfung für Einbauplatz " & EinbauplatzNr & " fehlgeschlagen:"
                PrintStatus udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo
            End If
            gudtUSParameter = udtUSParameter(Einbauplatz.getNr)
        End If ' Pruefzaehler is nothing
    Next Einbauplatz
    
    
    
    
    '''''''''''''''''''''''' Qmin ''''''''''''''''''''''
    ' Qmin
    
    PPNr = m_colUniqueVorPP.getCollection.Count
    Set m_vorPruefpunkt = m_colUniqueVorPP.getCollection.Item(PPNr)
    
    m_DurchflussSoll = m_vorPruefpunkt.getQ
    m_Pruefzeit = m_vorPruefpunkt.GetTime
    
    m_VolumenSoll = m_Pruefzeit * m_DurchflussSoll / 3.6
    PrintStatus "geschätztes Soll-Volumen in Litern: " & Format(m_VolumenSoll, "0.000")
    lblSollV.Caption = Format(m_VolumenSoll, "0")
            
    Call m_Referenzzaehler.loadForDurchfluss(m_DurchflussSoll, g_App.Settings.getMIDGruppe)
    m_SPS.SetQDiff 0

    PrintStatus "Vorprüfung im Vorprüfpunkt (Qmin):"
    
    lngRet = VorpruefungImPP(PPNr, udtPruefdaten_imPP_mitEBP())
    If lngRet < 0 Then
        Vorpruefung = -1
        g_Abbruch = True
    End If
    If g_Abbruch Then Exit Function
                
    For Each Einbauplatz In m_colEinbauplatz
        Set Pruefzaehler = Einbauplatz.getPruefzaehler
        If Not Pruefzaehler Is Nothing Then
            EinbauplatzNr = Einbauplatz.getNr
            
            ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
                
            If udtPruefdaten_imPP_mitEBP(EinbauplatzNr).blnPruefungsfehler = False Then
                If udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo <> "" Then
                    PrintStatus udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo
                End If
                
                ' kein Fehler aufgetreten
                Call GetUSVolumen(EinbauplatzNr, USVolumen)
                
                If USVolumen = 0 Then
                    MsgBox ("US Volumen konnte nicht ermittelt werden")
                    Vorpruefung = -20
                    'Stop
                End If
                
                lngUSPruefZeit_ms = udtPruefdaten_imPP_mitEBP(EinbauplatzNr).US_IstPruefzeit_ms
                lngRZPruefZeit_ms = udtPruefdaten_imPP_mitEBP(EinbauplatzNr).RZ_IstPruefzeit_ms
                PrintStatus "US Zähler Prüfzeit(" & EinbauplatzNr & ")= " & lngUSPruefZeit_ms & " ms"
                PrintStatus "RZ Zähler Prüfzeit(" & EinbauplatzNr & ")= " & lngRZPruefZeit_ms & " ms"
                
                PrintStatus "US Volumen am Einbauplatz " & EinbauplatzNr & " [m³]:" & USVolumen
                
                ' Refererenz Volumen bestimmen
                If Not m_VorPruefungsArtWaage Then
                   ' Refererenz Volumen bestimmen aus Referenzzähler
                   Call GetRZVolumen(EinbauplatzNr, m_Referenzzaehler, RefVolumen)
                   PrintStatus "RZ Volumen [m³]:" & RefVolumen
                   dblLetzterRZFehler = m_Referenzzaehler.letzterFehler(m_DurchflussSoll)
                   PrintStatus "Fehler des RZ in diesem Prüfpunkt: " & Format(dblLetzterRZFehler, "0.0")
                   RefVolumen = RefVolumen / (1 + dblLetzterRZFehler / 100)
                   PrintStatus "Ist-Volumen (korrigiert mit Fehler des RZ): " & RefVolumen
                Else
                   ' Refererenz Volumen bestimmen aus Gewicht der Waage
                   RefVolumen = Volumen(m_Waage.GetGewicht, udtPruefdaten_imPP_mitEBP(EinbauplatzNr).dblTemperatur)
                   PrintStatus "Ist-Volumen [m³] (aus Waage, korrigiert mit Temperatur): " & RefVolumen
                   ' Hier sind die Prüfzeiten rechnerisch gleich
                   lngRZPruefZeit_ms = lngUSPruefZeit_ms
                End If
                
                If RefVolumen = 0 Then
                    MsgBox ("Referenz Volumen (Waage oder Referenzzähler) konnte nicht ermittelt werden")
                    Vorpruefung = -21
                    'Stop
                End If
                    
                MSFlexGrid1.Row = Einbauplatz.getNr
                MSFlexGrid1.Col = PPNr
                                    
                If Not lngUSPruefZeit_ms = 0 Then
                    If Not m_VorPruefungsArtWaage Then
                        'Offset_Qmin abziehen, um Kurve nach oben zu bekommen
                        'geändert am 20.01.2004 AP mit Gepräch mit UD
                        RefVolumen = RefVolumen * (1 - udtUSParameter(Einbauplatz.getNr).Offset_Qmin / 100 * (-1))
                        ' mit den wahren Prüfzeiten korrigierter Fehler
                        Fehler = 100 * (USVolumen / lngUSPruefZeit_ms - RefVolumen / lngRZPruefZeit_ms) / (RefVolumen / lngRZPruefZeit_ms)
                        PrintStatus "Fehler = 100 * (USVolumen / lngUSPruefZeit_ms - RefVolumen / lngRZPruefZeit_ms) / (RefVolumen / lngRZPruefZeit_ms) =" & Format(Fehler, "0.00")
                    Else
                        'Offset_Qmin abziehen, um Kurve nach oben zu bekommen
                        'geändert am 20.01.2004 AP mit Gepräch mit UD
                        RefVolumen = RefVolumen * (1 - udtUSParameter(Einbauplatz.getNr).Offset_Qmin / 100 * (-1))
                        Fehler = 100 * (USVolumen - RefVolumen) / RefVolumen
                        PrintStatus "Fehler = 100 * (USVolumen - RefVolumen) / RefVolumen =" & Format(Fehler, "0.00")
                    End If
                    
                    dblTemperatur = m_SPS.GetEinlaufTemperatur
                    
                    MSFlexGrid1.Text = Format(Fehler, "0.00")
                
                    udtUSParameter(Einbauplatz.getNr).Istfluss1_m3ph = USVolumen / (lngUSPruefZeit_ms / 1000 / 60 / 60)
                    udtUSParameter(Einbauplatz.getNr).Sollfluss1_m3ph = RefVolumen / (lngRZPruefZeit_ms / 1000 / 60 / 60)
                    udtUSParameter(Einbauplatz.getNr).Temperatur1_°C = dblTemperatur
                  
                  
                     ' hier speichern
                     objJustageWerte(EinbauplatzNr).IstFluss2 = udtUSParameter(Einbauplatz.getNr).Istfluss2_m3ph
                     objJustageWerte(EinbauplatzNr).SollFluss2 = udtUSParameter(Einbauplatz.getNr).Sollfluss2_m3ph
                     objJustageWerte(EinbauplatzNr).Temperatur2 = udtUSParameter(Einbauplatz.getNr).Temperatur2_°C
                     
                     objJustageWerte(EinbauplatzNr).IstFluss1 = udtUSParameter(Einbauplatz.getNr).Istfluss1_m3ph
                     objJustageWerte(EinbauplatzNr).SollFluss1 = udtUSParameter(Einbauplatz.getNr).Sollfluss1_m3ph
                     objJustageWerte(EinbauplatzNr).Temperatur1 = udtUSParameter(Einbauplatz.getNr).Temperatur1_°C
               
                  
                    PrintStatus "gemessenes Q vom US = (USVolumen / (lngUSPruefZeit_ms / 1000 / 60 / 60)=" & udtUSParameter(Einbauplatz.getNr).Istfluss1_m3ph
                    PrintStatus "gemessenes Q vom FM85 = RefVolumen / (lngRZPruefZeit_ms / 1000 / 60 / 60) =" & udtUSParameter(Einbauplatz.getNr).Sollfluss1_m3ph
                    
                    ShowUSParameter udtUSParameter(Einbauplatz.getNr), udtUSZusatzParameter(Einbauplatz.getNr), "Justage Parameter nach 2. Vor-Prüfpunkt vor Justage", Einbauplatz.getNr
                    
                    
                    gudtUSParameter = udtUSParameter(EinbauplatzNr)
                    'A.P.am 18.08.02
                    If mbln_nachjustage = False Then
                     ' RH am 30.4.2003
                        If mbln_HeissKaltSpreizungBerechnen = True Then
                           
                           PrintStatus "Heiss-Kalt Spreizung Berechnen: Seriennr=" & Pruefzaehler.getSerienNr & ", m_DurchflussSoll=" & m_DurchflussSoll
                           
                           If Pruefzaehler.getVorpruefpunkte.LadeHeissesQMin(Pruefzaehler.getSerienNr, m_DurchflussSoll, dblQminFehler) Then
                              
                              gudtUSParameter.IstFehler_qmin_50°C = dblQminFehler
                              
                              ' Formel Aufruf
                              ' 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
                              modUS2000_Algorithmen.Qmin_Temperaturjustage
                              ShowUSParameter gudtUSParameter, udtUSZusatzParameter(Einbauplatz.getNr), "Justage Parameter nach Qmin_Temperaturjustage an Einbauplatz ", Einbauplatz.getNr
                              
                           End If
                        End If
                        
                        modUS2000_Algorithmen.Justage_mit_ZeroFlow
                        
                        'Neu AP 04.07.03
                        'objJustageWerte(EinbauplatzNr).save
                        ShowUSParameter gudtUSParameter, udtUSZusatzParameter(Einbauplatz.getNr), "Justage Parameter nach Justage_mit_ZeroFlow nach Prüfpunkt Nr2 = Qmin", Einbauplatz.getNr
                    Else
                        ' Nachjustage
                        modUS2000_Algorithmen.Justage_Execute
                        ShowUSParameter gudtUSParameter, udtUSZusatzParameter(Einbauplatz.getNr), "Justage Parameter nach Justage_Execute (Nachjustage) nach Prüfpunkt Nr2 = Qmin", Einbauplatz.getNr
                    End If
                    
                    udtUSParameter(EinbauplatzNr) = gudtUSParameter
                    
                Else
                    PrintStatus "Vorprüfung für Einbauplatz " & EinbauplatzNr & " fehlgeschlagen."
                    
                    MSFlexGrid1.Text = "?"
                    Vorpruefung = -23
                    'Stop
                End If
            Else
                PrintStatus "Vorprüfung für Einbauplatz " & EinbauplatzNr & " fehlgeschlagen:"
                PrintStatus udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo
            End If
            gudtUSParameter = udtUSParameter(Einbauplatz.getNr)
        End If ' Pruefzaehler is nothing
    Next Einbauplatz
   
    '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

    PrintStatus "SetOffsetAndGeberAndBereich f.a. Zähler"
    For Each Einbauplatz In m_colEinbauplatz
        Set Pruefzaehler = Einbauplatz.getPruefzaehler
        If Not Pruefzaehler Is Nothing Then
            EinbauplatzNr = Einbauplatz.getNr
            ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
            
            If udtPruefdaten_imPP_mitEBP(EinbauplatzNr).blnPruefungsfehler = False Then
                lngRet = modIECCOM.SetOffsetAndGeberAndBereich(ComPort, udtUSParameter(Einbauplatz.getNr))
                If lngRet <> 0 Then
                    DebugMsg ("SetOffsetAndGeberAndBereich für Einbauplatz " & EinbauplatzNr & " gab Fehler " & lngRet & " zurück")
                    Vorpruefung = -29
                    Exit Function
                End If
            Else
                PrintStatus "SetOffsetAndGeber für Einbauplatz " & EinbauplatzNr & " nicht erfolgt"
            End If
            
        End If ' Pruefzaehler is nothing
    Next Einbauplatz
    
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    '
    '        Bereichsjustage
    '
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    If mbln_Bereichsjustage = True And m_colUniqueVorPP.Count > 2 Then
        PPNr = 2
        Set m_vorPruefpunkt = m_colUniqueVorPP.getCollection.Item(PPNr)
    
        m_DurchflussSoll = m_vorPruefpunkt.getQ
        m_Pruefzeit = m_vorPruefpunkt.GetTime
        
        m_VolumenSoll = m_Pruefzeit * m_DurchflussSoll / 3.6
        PrintStatus "geschätztes Soll-Volumen in Litern: " & m_VolumenSoll
        lblSollV.Caption = Format(m_VolumenSoll, "0")
                
        Call m_Referenzzaehler.loadForDurchfluss(m_DurchflussSoll, g_App.Settings.getMIDGruppe)
        m_SPS.SetQDiff 0
    
        PrintStatus "Vorprüfung im Vorprüfpunkt (Qmin):"
        
        lngRet = VorpruefungImPP(PPNr, udtPruefdaten_imPP_mitEBP())
        If lngRet < 0 Then
            g_Abbruch = True
            Vorpruefung = -1
        End If
        If g_Abbruch Then Exit Function
                    
        For Each Einbauplatz In m_colEinbauplatz
            Set Pruefzaehler = Einbauplatz.getPruefzaehler
            If Not Pruefzaehler Is Nothing Then
                EinbauplatzNr = Einbauplatz.getNr
                
                ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
                    
                If udtPruefdaten_imPP_mitEBP(EinbauplatzNr).blnPruefungsfehler = False Then
                    If udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo <> "" Then
                        PrintStatus udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo
                    End If
                    
                    ' kein Fehler aufgetreten
                    Call GetUSVolumen(EinbauplatzNr, USVolumen)
                    
                    If USVolumen = 0 Then
                        ErrorMsg ("US Volumen konnte nicht ermittelt werden (gleich 0)")
                        Vorpruefung = -20
                        Exit Function
                    End If
                    
                    lngUSPruefZeit_ms = udtPruefdaten_imPP_mitEBP(EinbauplatzNr).US_IstPruefzeit_ms
                    lngRZPruefZeit_ms = udtPruefdaten_imPP_mitEBP(EinbauplatzNr).RZ_IstPruefzeit_ms
                    PrintStatus "US Zähler Prüfzeit(" & EinbauplatzNr & ")= " & lngUSPruefZeit_ms & " ms"
                    PrintStatus "RZ Zähler Prüfzeit(" & EinbauplatzNr & ")= " & lngRZPruefZeit_ms & " ms"
                    
                    PrintStatus "US Volumen am Einbauplatz " & EinbauplatzNr & " [m³]:" & USVolumen
                    
                    ' Refererenz Volumen bestimmen
                    If Not m_VorPruefungsArtWaage Then
                       ' Refererenz Volumen bestimmen aus Referenzzähler
                       Call GetRZVolumen(EinbauplatzNr, m_Referenzzaehler, RefVolumen)
                       PrintStatus "RZ Volumen [m³]:" & RefVolumen
                       dblLetzterRZFehler = m_Referenzzaehler.letzterFehler(m_DurchflussSoll)
                       PrintStatus "Fehler des RZ in diesem Prüfpunkt: " & Format(dblLetzterRZFehler, "0.0")
                       RefVolumen = RefVolumen / (1 + dblLetzterRZFehler / 100)
                       PrintStatus "Ist-Volumen (korrigiert mit Fehler des RZ): " & RefVolumen
                    Else
                       ' Refererenz Volumen bestimmen aus Gewicht der Waage
                       RefVolumen = Volumen(m_Waage.GetGewicht, udtPruefdaten_imPP_mitEBP(EinbauplatzNr).dblTemperatur)
                       PrintStatus "Ist-Volumen [m³] (aus Waage, korrigiert mit Temperatur): " & RefVolumen
                       ' Hier sind die Prüfzeiten rechnerisch gleich
                       lngRZPruefZeit_ms = lngUSPruefZeit_ms
                    End If
                    
                    If RefVolumen = 0 Then
                        ErrorMsg ("Referenz Volumen (Waage oder Referenzzähler) konnte nicht ermittelt werden")
                        Vorpruefung = -21
                        Exit Function
                    End If
                        
                    MSFlexGrid1.Row = Einbauplatz.getNr
                    MSFlexGrid1.Col = PPNr
                                        
                    If Not lngUSPruefZeit_ms = 0 Then
                        If Not m_VorPruefungsArtWaage Then
                            ' mit den wahren Prüfzeiten korrigierter Fehler
                            Fehler = 100 * (USVolumen / lngUSPruefZeit_ms - RefVolumen / lngRZPruefZeit_ms) / (RefVolumen / lngRZPruefZeit_ms)
                            'Offset_QBereich abziehen, um Kurve nach oben zu bekommen
                            Fehler = Fehler - udtUSParameter(Einbauplatz.getNr).Offset_QBereich
                            PrintStatus "Fehler = 100 * (USVolumen / lngUSPruefZeit_ms - RefVolumen / lngRZPruefZeit_ms) / (RefVolumen / lngRZPruefZeit_ms) =" & Format(Fehler, "0.00")
                        Else
                            Fehler = 100 * (USVolumen - RefVolumen) / RefVolumen
                            'Offset_QBereich abziehen, um Kurve nach oben zu bekommen
                            Fehler = Fehler - udtUSParameter(Einbauplatz.getNr).Offset_QBereich
                            PrintStatus "Fehler = 100 * (USVolumen - RefVolumen) / RefVolumen =" & Format(Fehler, "0.00")
                        End If
                        '''''''''''''''''''''''''''''''''''''''''''''''''''''''
                        
                        MSFlexGrid1.Text = Format(Fehler, "0.00")
                        
                       dblFehlerInQb(Einbauplatz.getNr) = Fehler
                       dblIstFlussInQb(Einbauplatz.getNr) = USVolumen / (lngUSPruefZeit_ms / 1000 / 60 / 60)
                       dblSollFlussInQb(Einbauplatz.getNr) = RefVolumen / (lngRZPruefZeit_ms / 1000 / 60 / 60)
                       dblTemperaturInQb(Einbauplatz.getNr) = m_SPS.GetEinlaufTemperatur
                    
                       PrintStatus "gemessenes Q2 vom US = (USVolumen / (lngUSPruefZeit_ms / 1000 / 60 / 60)=" & dblIstFlussInQb(Einbauplatz.getNr)
                       PrintStatus "gemessenes Q2 vom FM85 = RefVolumen / (lngRZPruefZeit_ms / 1000 / 60 / 60) =" & dblSollFlussInQb(Einbauplatz.getNr)
                       PrintStatus "gemessene Temp2 =" & dblTemperaturInQb(Einbauplatz.getNr)
                        
                        ''''''''''''''''''''''''''''''''''''''''''''''''''''''''
                    Else
                        PrintStatus "Vorprüfung für Einbauplatz " & EinbauplatzNr & " fehlgeschlagen."
                        
                        MSFlexGrid1.Text = "?"
                        Vorpruefung = -23
                        Exit Function
                    End If
                Else
                    PrintStatus "Vorprüfung für Einbauplatz " & EinbauplatzNr & " fehlgeschlagen:"
                    PrintStatus udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo
                End If
                gudtUSParameter = udtUSParameter(Einbauplatz.getNr)
            End If ' Pruefzaehler is nothing
        Next Einbauplatz
    

      For Each Einbauplatz In m_colEinbauplatz
         Set Pruefzaehler = Einbauplatz.getPruefzaehler
         If Not Pruefzaehler Is Nothing Then
            EinbauplatzNr = Einbauplatz.getNr
              
            ' Annahme: die Bereichsjustage wird nur in Folge der normale Justage durchgeführt, d.h. dass
            '          bedingt durch die vorangestellte Justage Soll und Ist Durchflüsse als gleich angesehen werden
            ' Qmin-ist = Qmin-soll   und    Qmax-ist = Qmax-soll
            udtUSParameter(Einbauplatz.getNr).Istfluss1_m3ph = udtUSParameter(Einbauplatz.getNr).Sollfluss1_m3ph
            udtUSParameter(Einbauplatz.getNr).Istfluss2_m3ph = udtUSParameter(Einbauplatz.getNr).Sollfluss2_m3ph
            
            ' Die GeberKonstanten und der Offset werden aus den bereits berechneten Variablen Neu in die nun
            ' nicht mehr gültigen IST Variablen übergeben
            udtUSParameter(Einbauplatz.getNr).Geberkonstante1_IST_m = udtUSParameter(Einbauplatz.getNr).Geberkonstante_Neu1_m
            udtUSParameter(Einbauplatz.getNr).Offset1_IST_m3ph = udtUSParameter(Einbauplatz.getNr).Offset_Neu1_m3ph
            udtUSParameter(Einbauplatz.getNr).Geberkonstante2_IST_m = udtUSParameter(Einbauplatz.getNr).Geberkonstante_Neu2_m
            udtUSParameter(Einbauplatz.getNr).Offset2_IST_m3ph = udtUSParameter(Einbauplatz.getNr).Offset_Neu2_m3ph
            udtUSParameter(Einbauplatz.getNr).Unlinearitaet = -dblFehlerInQb(Einbauplatz.getNr) / 100
            
            ' Speichern der Unlinearitaet für Offsetjustage
            objJustageWerte(Einbauplatz.getNr).Unlinearitaet = udtUSParameter(EinbauplatzNr).Unlinearitaet
            
            ShowUSParameter udtUSParameter(Einbauplatz.getNr), udtUSZusatzParameter(Einbauplatz.getNr), "Justage Parameter nach Bereichs-Vorprüfpunkt vor Bereichs-Justage", Einbauplatz.getNr
            
            ' ########   BEREICHSJUSTAGE WIRD OHNE ZEROFLOWJUSTAGE AUSGEFÜHRT   ########
            gudtUSParameter = udtUSParameter(EinbauplatzNr)
            modUS2000_Algorithmen.Justage_Execute
            udtUSParameter(EinbauplatzNr) = gudtUSParameter
            
            ' ------------------------------------------------
            ShowUSParameter udtUSParameter(Einbauplatz.getNr), udtUSZusatzParameter(Einbauplatz.getNr), "Justage Parameter nach Bereichs-Vor-Prüfpunkt nach Bereichs-Justage ", Einbauplatz.getNr
           
           End If
      Next Einbauplatz
        
         PrintStatus "SetOffsetAndGeberAndBereich f.a. Zähler"
        For Each Einbauplatz In m_colEinbauplatz
            Set Pruefzaehler = Einbauplatz.getPruefzaehler
            If Not Pruefzaehler Is Nothing Then
                EinbauplatzNr = Einbauplatz.getNr
                ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
                
                If udtPruefdaten_imPP_mitEBP(EinbauplatzNr).blnPruefungsfehler = False Then
                    lngRet = modIECCOM.SetOffsetAndGeberAndBereich(ComPort, udtUSParameter(Einbauplatz.getNr))
                    If lngRet <> 0 Then
                        DebugMsg ("SetOffsetAndGeberAndBereich für Einbauplatz " & EinbauplatzNr & " gab Fehler " & lngRet & " zurück")
                        Vorpruefung = -29
                        Exit Function
                    End If
                Else
                    PrintStatus "SetOffsetAndGeber für Einbauplatz " & EinbauplatzNr & " nicht erfolgt"
                End If
                
            End If ' Pruefzaehler is nothing
        Next Einbauplatz

   End If ' Bereichsjustage
    
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
   
    PrintStatus "OffsetJustage Werte in Tabelle USJustageWerte speichern"
    For Each Einbauplatz In m_colEinbauplatz
        Set Pruefzaehler = Einbauplatz.getPruefzaehler
        If Not Pruefzaehler Is Nothing Then
            EinbauplatzNr = Einbauplatz.getNr
            
            ' OffsetJustage / Tabelle USJustageWerte
            ' --------------------------------------
            objJustageWerte(EinbauplatzNr).FP_Bereich = udtUSParameter(EinbauplatzNr).Bereich_ns
            objJustageWerte(EinbauplatzNr).FP_K_Geber1 = udtUSParameter(EinbauplatzNr).Geberkonstante_Neu1_m
            objJustageWerte(EinbauplatzNr).FP_K_Geber2 = udtUSParameter(EinbauplatzNr).Geberkonstante_Neu2_m
            objJustageWerte(EinbauplatzNr).FP_O_Geber = udtUSParameter(EinbauplatzNr).OffsetGeber_ns
            objJustageWerte(EinbauplatzNr).FP_QOffset1 = udtUSParameter(EinbauplatzNr).Offset_Neu1_m3ph
            objJustageWerte(EinbauplatzNr).FP_QOffset2 = udtUSParameter(EinbauplatzNr).Offset_Neu2_m3ph
            objJustageWerte(EinbauplatzNr).FP_ST_Geber = udtUSParameter(EinbauplatzNr).SteilheitGeber_nsp°C
            
            ' Datum der letzten Vorprüfung, die für diesen Zähler gemacht wurde
            objJustageWerte(EinbauplatzNr).DatumVorpruefung = m_Pruefgang.Datum
            
            ' Die eigentliche Berechnung der Justage ist etwas später
            objJustageWerte(EinbauplatzNr).DatumJustage = Now
            
            ' Die Offsets, die für diese Justage aus der Datenbank vorgegeben waren
            objJustageWerte(EinbauplatzNr).Offset_Qp = udtUSParameter(EinbauplatzNr).Offset_Qp
            objJustageWerte(EinbauplatzNr).Offset_Bereich = udtUSParameter(EinbauplatzNr).Offset_QBereich
            objJustageWerte(EinbauplatzNr).Offset_Qmin = udtUSParameter(EinbauplatzNr).Offset_Qmin
            
            
            ' nach einer Vorprüfung alle Justage-Werte für OffsetJustage speichern
            objJustageWerte(EinbauplatzNr).save
        End If
    Next
    
    PrintStatus "***** Vorprüfung beendet ******"
    Vorpruefung = 0
End Function
Private Function VorpruefungImPP(PPNr As Integer, udtPruefdaten_imPP_mitEBP() As TypUSPruefdaten) As Long
Dim QIst As Double
Dim Einbauplatz As CEinbauplatz
Dim Pruefzaehler As CPruefzaehler

Dim dblTemperatur  As Double
Dim EinbauplatzNr As Integer
Dim Identitaetsnummer As Long
Dim ComPort As Integer
Dim lngRet As Long
Dim QIstSPS As Double
Dim blnPruefungFertig As Boolean
Dim dblVolumenWaage As Double
Dim dblVolumenRZ As Double

Dim lngReturn As Long
Dim dblVolumenUS As Double
Dim Fehler As Double
Dim SteilheitGeber_nsp(10) As Double

' muss gesetzt sein
'   m_vorPruefpunkt

    m_SPS.setBetrieb 0
    sleep 1000
    
    m_DurchflussSoll = m_vorPruefpunkt.getQ
    lblQSoll.Caption = m_DurchflussSoll
    
    ' Pumpe, MID, Regelart
    Call initSPSfuerPP

    Call DurchflussLstAktualisieren

    DoEvents
    
    Call m_Referenzzaehler.loadForDurchfluss(m_DurchflussSoll, g_App.Settings.getMIDGruppe)
    
    lblFehlerRZ.Caption = Format(m_Referenzzaehler.letzterFehler(m_DurchflussSoll), "0.00")

    PrintStatus "Neuer Prüfpunkt: " & m_DurchflussSoll
    
    If m_VorPruefungsArtWaage = True Then
    '''''''''''''''''''''''''''''''  W A A G E    A N F A N G ''''''''''''''''''''''''''''''''''''
         
         'Call initSPSfuerWaage
         If WaageVorbereitenFuerPP() < 0 Then
            VorpruefungImPP = -1
            Exit Function
         End If
         
         PrintStatus "Warten auf Prüfbereitschaft der Strecke"
         Do While Not m_SPS.IstStreckePruefbereit
             sleep 1000, True
             If g_Abbruch = True Then
                 Exit Function
             End If
         Loop
          
      
         dblTemperatur = m_SPS.GetEinlaufTemperatur
         PrintStatus "Temperatur: " & Format(dblTemperatur, "0.00") & " °C"
         
         
         If mbln_ZeroFlowMessung = True And PPNr = 1 Then
               Setze_FP_St_GeberKonstanteZeroflow SteilheitGeber_nsp()
               For Each Einbauplatz In m_colEinbauplatz
               Set Pruefzaehler = Einbauplatz.getPruefzaehler
               EinbauplatzNr = Einbauplatz.getNr
                  If Not Pruefzaehler Is Nothing Then
                     ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
                     If SteilheitGeber_nsp(EinbauplatzNr) <> 0 Then
                        PrintStatus "Einbauplatz " & EinbauplatzNr & " SteilheitGeber=" & Format(SteilheitGeber_nsp(EinbauplatzNr) * 1000000000, "0.00000") & " ns/'C"
                        
                        udtPruefdaten_imPP_mitEBP(EinbauplatzNr).JustageParameter.SteilheitGeber_nsp°C = SteilheitGeber_nsp(EinbauplatzNr)
                        lngReturn = modIECCOM.SetOffsetAndGeberAndBereich(ComPort, udtPruefdaten_imPP_mitEBP(EinbauplatzNr).JustageParameter)
                     End If
                  End If
               Next
         End If
   
         For Each Einbauplatz In m_colEinbauplatz
             Set Pruefzaehler = Einbauplatz.getPruefzaehler
             If (Not Pruefzaehler Is Nothing) Then
                 ' Pruefzaehler ist eingebaut
                 If Not Pruefzaehler.getPruefpunkte Is Nothing Then
                     If (Pruefzaehler.getVorpruefpunkte.hasQ(m_DurchflussSoll) = True) Then
                        Call USSetTemperatur(Einbauplatz.getNr, dblTemperatur)
                        PrintStatus "Temperatur in den Zähler schreiben"
                     End If
                End If
            End If
        Next
        
        ' US Messung starten
         For Each Einbauplatz In m_colEinbauplatz
             Set Pruefzaehler = Einbauplatz.getPruefzaehler
             If (Not Pruefzaehler Is Nothing) Then
                 ' Pruefzaehler ist eingebaut
                 If Not Pruefzaehler.getPruefpunkte Is Nothing Then
                     If (Pruefzaehler.getVorpruefpunkte.hasQ(m_DurchflussSoll) = True) Then
                
                         MSFlexGrid1.Row = Einbauplatz.getNr
                         MSFlexGrid1.Col = 0
                         MSFlexGrid1.Text = Einbauplatz.getPruefzaehler.getSerienNr
                         
                         'Call USSetTemperatur(Einbauplatz.getNr, dblTemperatur)
                         
                         udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).dblTemperatur = dblTemperatur
                         udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollDurchfluss = m_DurchflussSoll
                         udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollPruefzeit_s = m_vorPruefpunkt.GetTime
                         
                        If StarteUSundRZZaehler(Einbauplatz.getNr, Einbauplatz.getPruefzaehler.getSerienNr) = 0 Then
                           PrintStatus "NOVA_START für Einbauplatz " & Einbauplatz.getNr & " OK"
                        Else
                           udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).blnPruefungsfehler = True
                           udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo = "NOVA_START für Einbauplatz " & Einbauplatz.getNr & " fehlgeschlagen."
                           PrintStatus "NOVA_START für Einbauplatz " & Einbauplatz.getNr & " fehlgeschlagen."
                           If Err.Number <> 0 Then
                              PrintStatus "Fehler " & Err.Number & " :" & Err.Description
                           End If
                        End If
                     Else
                         PrintStatus "Warnung: Prüfzähler am Einbauplatz " & Einbauplatz.getNr & " enthält nicht den Vorprüfpunkt Q=" & m_DurchflussSoll
                     End If
                 End If
             End If
         Next
         Call initSPSfuerPP
         m_SPS.setBetrieb 2
         m_Tstart = GetTickCount
         PrintStatus "Pumpe gestartet"
         Do While Not ((m_Pumpe.GetStatus And 4) = 4)
            DoEvents
            If g_Abbruch = True Then
                Exit Function
            End If
         Loop
         PrintStatus "Pumpe läuft"
         
            QIstSPS = 0
            blnPruefungFertig = False
            
         ' Waagen SPS-Grenzwert abwarten
            Do While Not blnPruefungFertig
                If m_SPS.GrenzwertWaageErreicht Then
                    blnPruefungFertig = True
                Else
                    If QIstSPS = 0 And (GetTickCount - m_Tstart) \ 1000 > m_Pruefzeit \ 2 Then
                        QIstSPS = m_SPS.getQIst
                        PrintStatus "IstDurchfluss zur halben Prüfzeit: " & Format(QIstSPS, "0.000") & " m³/h"
                    End If
                                    
                    lblQIst.Caption = Format(m_SPS.getQIst, "0.000")
                    lblGewicht.Caption = Format(m_Waage.GetGewicht, "0.000")
                    sleep 500
                End If
                AnzeigeAktualisieren
                
                UpdateTemperaturInZaehler
                
                sleep 100
                DoEvents
                
                If g_Abbruch Then Exit Function
            Loop
            
            PrintStatus "Waagen-Grenzwert erreicht"
            ' Wasser stoppen
            m_SPS.setBetrieb 0
            
            ' Prüfzeit messen/stoppen in s
            m_Tpruef = (GetTickCount - m_Tstart) \ 1000
            
            m_Waage.SetNettoGrenzwert1 m_Behaelter.m_WaageGrenzwert, m_Behaelter.m_Genauigkeit
            
            ' Waagenruhe abwarten
            PrintStatus "Warte auf Waagenruhe"
            Call m_Waage.WarteAufRuhe
        
            ' Referenz-Volumen aus Waagen-Gewicht ermitteln
            dblVolumenWaage = Volumen(m_Waage.GetGewicht, dblTemperatur) ' in m³
            PrintStatus "VolumenWaage: " & Format(dblVolumenWaage, "0.000") & " m³"
            
            For Each Einbauplatz In m_colEinbauplatz
                EinbauplatzNr = Einbauplatz.getNr
                Set Pruefzaehler = Einbauplatz.getPruefzaehler
                If (Not Pruefzaehler Is Nothing) Then
                    lngReturn = StoppeUSundRZZaehler(EinbauplatzNr)
                    If lngReturn = 0 Then
                        PrintStatus "RZ-STOP und NOVA_STOP OK"
                        udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).RZ_IstPruefzeit_ms = m_Tpruef * 1000
                        udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).US_IstPruefzeit_ms = m_Tpruef * 1000
                    Else
                        PrintStatus "RZ-STOP und NOVA_STOP Fehler:" & lngReturn
                        udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).blnPruefungsfehler = True
                    End If
                End If ' PZ is nothing and GetActive
            Next Einbauplatz
            
            ' Volumen aus US Zaehler lesen
            For Each Einbauplatz In m_colEinbauplatz
                EinbauplatzNr = Einbauplatz.getNr
                Set Pruefzaehler = Einbauplatz.getPruefzaehler
                If (Not Pruefzaehler Is Nothing) Then
                    dblVolumenUS = 0
                    lngReturn = GetUSVolumen(EinbauplatzNr, dblVolumenUS, Einbauplatz.getPruefzaehler.getSerienNr)
                    If dblVolumenUS = 0 Then
                       udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).blnPruefungsfehler = True
                    End If
                     
                    PrintStatus "Volumen des US: " & dblVolumenUS & " m³"
                    Fehler = (dblVolumenUS - dblVolumenWaage) / dblVolumenWaage * 100
                    
                    udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).VolumenWaage = dblVolumenWaage
                End If
            Next
            Debug.Print
'''''''''''''''''''''''''''''''  W A A G E    E N D E ''''''''''''''''''''''''''''''''''''''''
    Else
'''''''''''''''''''''''''''''''  V E R G L E I C H    ''''''''''''''''''''''''''''''''''''''''
       Call initSPSfuerDurchlauf
         
       If mbln_ZeroFlowMessung = True And PPNr = 1 Then
               Setze_FP_St_GeberKonstanteZeroflow SteilheitGeber_nsp()
               For Each Einbauplatz In m_colEinbauplatz
               Set Pruefzaehler = Einbauplatz.getPruefzaehler
               EinbauplatzNr = Einbauplatz.getNr
                  If Not Pruefzaehler Is Nothing Then
                     ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
                     If SteilheitGeber_nsp(EinbauplatzNr) <> 0 Then
                        PrintStatus "Einbauplatz " & EinbauplatzNr & " SteilheitGeber=" & Format(SteilheitGeber_nsp(EinbauplatzNr) * 1000000000, "0.00000") & " ns/'C"
                        
                        udtPruefdaten_imPP_mitEBP(EinbauplatzNr).JustageParameter.SteilheitGeber_nsp°C = SteilheitGeber_nsp(EinbauplatzNr)
                        lngReturn = modIECCOM.SetOffsetAndGeberAndBereich(ComPort, udtPruefdaten_imPP_mitEBP(EinbauplatzNr).JustageParameter)
                     End If
                  End If
               Next
         End If
        ' Vergleichsprüfung gegen RefZ.: Betrieb starten
        m_SPS.setBetrieb 2
        
        ' auf konsten Durchfluß warten
        PrintStatus "Warten auf Solldurchfluß erreicht..."
        If Not g_testModus Then
            Do While Not m_SPS.SolldurchflussErreicht
                lblQIst.Caption = Format(m_SPS.getQIst, "0.000")
                sleep 500, True
                If g_Abbruch = True Then
                    Exit Function
                End If
            Loop
        End If
        
'            ' Durchflußanzeige RefIstWert korrigiert
        If Not g_testModus Then
            QIst = m_SPS.getQIst
        Else
            QIst = 99
        End If
        PrintStatus "Solldurchfluss erreicht bei Q=" & Format(QIst, "0.000")
        lblQIst.Caption = Format(QIst, "0.000")
    
        For Each Einbauplatz In m_colEinbauplatz
            Set Pruefzaehler = Einbauplatz.getPruefzaehler
            If (Not Pruefzaehler Is Nothing) Then
                ' Pruefzaehler ist eingebaut
                If Not Pruefzaehler.getPruefpunkte Is Nothing Then
                    If (Pruefzaehler.getVorpruefpunkte.hasQ(m_DurchflussSoll) = True) Then
               
                        MSFlexGrid1.Row = Einbauplatz.getNr
                        MSFlexGrid1.Col = 0
                        MSFlexGrid1.Text = Einbauplatz.getPruefzaehler.getSerienNr

                        udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollDurchfluss = m_DurchflussSoll
                        udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollPruefzeit_s = m_vorPruefpunkt.GetTime
                    Else
                        PrintStatus "Warnung: Prüfzähler am Einbauplatz " & Einbauplatz.getNr & " enthält nicht den Vorprüfpunkt Q=" & m_DurchflussSoll
                    End If
                End If
            End If
        Next


        If g_testModus Then
            dblTemperatur = 21.99
        Else
            dblTemperatur = m_SPS.GetEinlaufTemperatur
        End If
                
        Call UltraschallPruefung(udtPruefdaten_imPP_mitEBP())

        For EinbauplatzNr = 1 To g_App.Settings.EinbauplaetzeJeStrang
           If udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo <> "" Then
               PrintStatus "Fehler bei der Vorprüfung:" & udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo
               udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo = ""
           End If
        Next EinbauplatzNr
                    
        DoEvents
        If g_Abbruch Then
            Exit Function
        End If
        
        ' Wasser stoppen
        m_SPS.setBetrieb 8
        sleep 500
        m_SPS.setBetrieb 0
        lblQIst.Caption = ""
        PrintStatus "Wasser gestoppt"
        
        '''''''''''''''''''''''''''''''  V E R G L E I C H   E N D E '''''''''''''''''''''''''''''''''''
    End If
End Function

Private Function Bereichsjustage() As Long
    Dim Einbauplatz As CEinbauplatz
    Dim Pruefzaehler As CPruefzaehler
    Dim USVolumen As Double
    Dim RefVolumen As Double
    Dim PPNr As Integer
    Dim EinbauplatzNr As Integer
    Dim dblFehler As Double
    Dim lngReturn As Long
    Dim lngError As Long
    Dim Identitaetsnummer As Long
    Dim QIst As Double
    Dim dblTemperatur As Double
    Dim RefZFehler As Double
    
    Dim lngUSPruefZeit_ms As Long
    Dim lngRZPruefZeit_ms As Long
    
    Dim Fehler As Double
    Dim udtPruefdaten_imPP_mitEBP(10) As TypUSPruefdaten
    Dim udtPruefdaten_Bereichsgrenze(10) As TypUSPruefdaten

    Dim ComPort As Integer
    Dim lngRet As Long
    
    Dim udtUSParameter(10) As JustageParameter_Type
    Dim udtUSZusatzParameter(10) As US_ZusatzParameter_Typ
    
    Set m_Referenzzaehler = New CRefzaehler
    

    ' Einstellung für Automatik-Modus in der SPS testen
TestAutomatik:
    If Not m_SPS.IstAutomatik Then
        Dummy = MsgBox("Bitte SPS auf Automatik stellen", vbOKCancel)
        If Dummy = vbCancel Then
            endDialog (IDCANCEL)
            Exit Function
        End If
        GoTo TestAutomatik
    End If
    
    If Not m_SPS.IstStreckePruefbereit Then
        ' Betrieb Vorbereiten
        m_SPS.setBetrieb 1
        
        PrintStatus "Betrieb vorbereiten: Spannen und Füllen..."
        Do While Not m_SPS.IstStreckeGefuellt
            sleep 1000, True
            If g_Abbruch = True Then
                Exit Function
            End If
        Loop
        ' nach dem Füllen: Betrieb auf 0
        sleep 500
        m_SPS.setBetrieb 0
        
       '------------------------------------------------------------------------
    
        PrintStatus "Warte auf Pruefbereitschaft der SPS..."
        Do While Not m_SPS.IstStreckePruefbereit
            sleep 1000, True
            If g_Abbruch = True Then
                Exit Function
            End If
        Loop
    End If ' Pruefbereit
    PrintStatus "Strecke ist Prüfbereit !"

    PrintStatus "***** Bereichsjustage ******"


' Justage Zählerdaten bestimmen

    
    PPNr = 0
    m_colUniqueVorPP.sortQ
    
    
    '''''''''''''''''''''''' Prüfpunkt bei Q2 ''''''''''''''''''''''
    ' Qmax
    Set m_vorPruefpunkt = m_colUniqueVorPP.getCollection.Item(2)
    PPNr = 2

    m_DurchflussSoll = m_vorPruefpunkt.getQ
    m_Pruefzeit = m_vorPruefpunkt.GetTime
    
    m_VolumenSoll = m_Pruefzeit * m_DurchflussSoll / 3.6
    PrintStatus "geschätztes Soll-Volumen in Litern: " & m_VolumenSoll
    lblSollV.Caption = Format(m_VolumenSoll, "0")
            
    Call m_Referenzzaehler.loadForDurchfluss(m_DurchflussSoll, g_App.Settings.getMIDGruppe)
    m_SPS.SetQDiff 0 'm_Referenzzaehler.letzterFehler(m_DurchflussSoll)
    
    
    For Each Einbauplatz In m_colEinbauplatz
        Set Pruefzaehler = Einbauplatz.getPruefzaehler
        If Not Pruefzaehler Is Nothing Then
            EinbauplatzNr = Einbauplatz.getNr
            ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
            
            ' Die sieben Justage Parameter aus Zähler lesen
            ' Geberkonstante1_IST_m
            ' Geberkonstante2_IST_m
            ' SteilheitGeber_nsp°C
            ' OffsetGeber_ns
            If modIECCOM.GetOffsetAndGeberAndBereich(ComPort, udtUSParameter(Einbauplatz.getNr)) <> 0 Then
                MsgBox "GetOffsetAndGeberAndBereich konten nicht ausgelesen werden. Bereichsjustage wird abgebrochen."
                Bereichsjustage = -1
                Exit Function
            Else
                Call ShowUSParameter(udtUSParameter(Einbauplatz.getNr), udtUSZusatzParameter(Einbauplatz.getNr), "Justage Parameter aus Zähler gelesen:", Einbauplatz.getNr)
            End If
        End If
    Next
      
   PrintStatus "Vorprüfung im Vorprüfpunkt 2:"

   lngRet = VorpruefungImPP(PPNr, udtPruefdaten_imPP_mitEBP())
   If lngRet = -1 Then
        Exit Function
   End If


    For Each Einbauplatz In m_colEinbauplatz
        Set Pruefzaehler = Einbauplatz.getPruefzaehler
        If Not Pruefzaehler Is Nothing Then
            EinbauplatzNr = Einbauplatz.getNr
            ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
    
            If udtPruefdaten_imPP_mitEBP(EinbauplatzNr).blnPruefungsfehler = False Then
            
                ' Volumen bestimmen
                Call GetRZVolumen(EinbauplatzNr, m_Referenzzaehler, RefVolumen)
                PrintStatus "RZ Volumen [m³]:" & RefVolumen
                PrintStatus "Fehler des RZ in diesem Prüfpunkt: " & Format(m_Referenzzaehler.letzterFehler(m_DurchflussSoll), "0.0")
                RefVolumen = RefVolumen / (1 + m_Referenzzaehler.letzterFehler(m_DurchflussSoll) / 100)
                        
                PrintStatus "Ist-Volumen:" & RefVolumen
                
                Call GetUSVolumen(EinbauplatzNr, USVolumen)
                PrintStatus "US Volumen [m³]:" & Format(USVolumen, "0.0000")
                
                If USVolumen = 0 Then
                    MsgBox ("US Volumen ist 0")
                    Bereichsjustage = -24
                    Stop
                    'Exit Function
                End If
                If RefVolumen = 0 Then
                    Stop
                    MsgBox ("Ref. Volumen ist 0")
                    Bereichsjustage = -25
                    'Exit Function
                End If
                
                            
                MSFlexGrid1.Row = Einbauplatz.getNr
                MSFlexGrid1.Col = PPNr
                                                     
                lngUSPruefZeit_ms = udtPruefdaten_imPP_mitEBP(EinbauplatzNr).US_IstPruefzeit_ms
                lngRZPruefZeit_ms = udtPruefdaten_imPP_mitEBP(EinbauplatzNr).RZ_IstPruefzeit_ms
                
                PrintStatus "US Zähler Prüfzeit(" & EinbauplatzNr & ")= " & lngUSPruefZeit_ms & " ms"
                PrintStatus "RZ Zähler Prüfzeit(" & EinbauplatzNr & ")= " & lngRZPruefZeit_ms & " ms"
                                             
                If Not lngUSPruefZeit_ms = 0 Then
                    If Not lngUSPruefZeit_ms = 0 Then
                        udtUSParameter(Einbauplatz.getNr).Istfluss1_m3ph = USVolumen / (lngUSPruefZeit_ms / 1000 / 60 / 60)
                        udtUSParameter(Einbauplatz.getNr).Sollfluss1_m3ph = RefVolumen / (lngRZPruefZeit_ms / 1000 / 60 / 60)
                        udtUSParameter(Einbauplatz.getNr).Temperatur1_°C = m_SPS.GetEinlaufTemperatur
                        
                        If Not m_VorPruefungsArtWaage Then
                            ' mit den wahren Prüfzeiten korrigierter Fehler
                            Fehler = 100 * (USVolumen / lngUSPruefZeit_ms - RefVolumen / lngRZPruefZeit_ms) / (RefVolumen / lngRZPruefZeit_ms)
                            PrintStatus "Fehler = 100 * (USVolumen / lngUSPruefZeit_ms - RefVolumen / lngRZPruefZeit_ms) / (RefVolumen / lngRZPruefZeit_ms) =" & Format(Fehler, "0.00")
                        Else
                            Fehler = 100 * (USVolumen - RefVolumen) / RefVolumen
                            PrintStatus "Fehler = 100 * (USVolumen - RefVolumen) / RefVolumen =" & Format(Fehler, "0.00")
                        End If
                        
                        udtUSParameter(Einbauplatz.getNr).Unlinearitaet = -Fehler
                        
                        MSFlexGrid1.Text = Format(Fehler, "0.00")
                    Else
                        MsgBox ("US PP Zeit = 0 !")
                        Bereichsjustage = -26
                        Exit Function
                    End If
                Else
                    MsgBox ("RZ PP Zeit = 0 !")
                    Bereichsjustage = -27
                    Exit Function
                End If
            
                gudtUSParameter = udtUSParameter(EinbauplatzNr)
                ShowUSParameter gudtUSParameter, udtUSZusatzParameter(EinbauplatzNr), "Justage Parameter vor Bereichs Justage", Einbauplatz.getNr
                
                'Eingefügt provisorisch am 18.08.02
                modUS2000_Algorithmen.Justage_Execute
                
                ShowUSParameter gudtUSParameter, udtUSZusatzParameter(EinbauplatzNr), "Justage Parameter nach Bereichs Justage", Einbauplatz.getNr
                udtUSParameter(EinbauplatzNr) = gudtUSParameter
            Else
                PrintStatus "Einbauplatz " & EinbauplatzNr & " konnte nicht justiert werden"
                PrintStatus udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo
                udtPruefdaten_imPP_mitEBP(EinbauplatzNr).Fehlerinfo = ""
            End If
        End If ' Pruefzaehler is nothing
    Next Einbauplatz

    
    PrintStatus "SetOffsetAndGeberAndBereich f.a. Zähler"
    For Each Einbauplatz In m_colEinbauplatz
        Set Pruefzaehler = Einbauplatz.getPruefzaehler
        If Not Pruefzaehler Is Nothing Then
            EinbauplatzNr = Einbauplatz.getNr
            ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
            
            If udtPruefdaten_imPP_mitEBP(EinbauplatzNr).blnPruefungsfehler = False Then
                lngRet = modIECCOM.SetOffsetAndGeberAndBereich(ComPort, udtUSParameter(Einbauplatz.getNr))
                If lngRet <> 0 Then
                    DebugMsg ("SetOffsetAndGeberAndBereich für Einbauplatz " & EinbauplatzNr & " gab Fehler " & lngRet & " zurück")
                    Bereichsjustage = -29
                    Stop
                End If
            Else
                PrintStatus "SetOffsetAndGeber für Einbauplatz " & EinbauplatzNr & " nicht erfolgt"
            End If
            
        End If ' Pruefzaehler is nothing
    Next Einbauplatz
    
    
    PrintStatus "***** Bereichs-Justage beendet ******"
    
End Function

Private Sub AnzeigeAktualisieren()
    
    lblZeit.Caption = (GetTickCount - m_Tstart) \ 1000 & "/" & m_Pruefzeit
   
    If Not g_testModus Then
        lblQIst = Format(m_SPS.getQIst, "0.000")
    End If
        
End Sub

Private Sub AnzeigeAktualisieren_mit_Waage()
    
    lblZeit.Caption = (GetTickCount - m_Tstart) \ 1000 & "/" & m_Pruefzeit
   
    If Not g_testModus Then
        lblQIst = Format(m_SPS.getQIst, "0.000")
    End If
    
    If m_PruefungsArtWaage Then
        lblGewicht.Caption = Format(m_Waage.GetGewicht, "0.00")
    End If
    
End Sub

'Private Sub KontinuierrlichePruefung()
'Dim altePumpeNr As Integer
'Dim udtPruefdaten_imPP_mitEBP(10) As TypUSPruefdaten
'Dim Einbauplatz As CEinbauplatz
'Dim EinbauplatzNr As Integer
'Dim lngReturn As Long
'
'Dim Pruefzaehler As CPruefzaehler
'Dim DurchflussRZ As Double
'Dim DurchflussUS As Double
'Dim dblVolumenRZ  As Double
'Dim dblVolumenUS  As Double
'Dim blnFertig As Boolean
'Dim ResultFilePath As String
'Dim ResultFileHandle  As Long
'Dim QIstSPS As Double
'Dim QFlow_fp As Double
'Dim Fehler As Double
'Dim bBetriebNeustart As Boolean
'
'
'    Set m_Referenzzaehler = New CRefzaehler
'
'    m_SPS.setBetrieb 0
'    sleep 2000
'
'
'    ResultFilePath = "C:\kont.txt"
'    On Error Resume Next
'    Kill ResultFilePath
'    On Error GoTo 0
'
'
'    ResultFileHandle = FreeFile()
'    Open ResultFilePath For Append As ResultFileHandle
'
'    Print #ResultFileHandle, "Ergebnisse der Kontinuierlichen Prüfung"
'    If m_PruefungsArtWaage Then
'        Print #ResultFileHandle, "gegen Waage"
'    Else
'        Print #ResultFileHandle, "gegen Referenzzähler"
'    End If
'    Print #ResultFileHandle, ""
'
'    Print #ResultFileHandle, "EinbauplatzNr" & vbTab & "DurchflussSoll" & vbTab & "QIstSPS" & vbTab & "Fehler" & vbTab & "Prüfzeit" & vbTab & "MID/Pumpe"
'    Close #ResultFileHandle
'
'    m_DurchflussSoll = CDbl(txtFlowMax.Text)
'
'    Call m_Referenzzaehler.loadForDurchfluss(m_DurchflussSoll, g_App.Settings.getMIDGruppe)
'    m_SPS.SetMID m_Referenzzaehler.EinbauplatzNr
'
'    ' Pumpenauswahl
'    m_SPS.AllePumpenAbwaehlen
'    Set m_Pumpe = Pumpenwahl(m_DurchflussSoll, m_ColPumpen)
'    m_Pumpe.Anwahl
'
'    ' Durchlauf auswählen
'    m_SPS.setBehaelter 1
'
'    bBetriebNeustart = True
'
'    Do
'        PrintStatus "Nächster Durchfluss: " & m_DurchflussSoll
'        m_SPS.SetQSoll m_DurchflussSoll
'        lblQSoll.Caption = m_DurchflussSoll
'
'        If Not m_Referenzzaehler.IstOkFuerDurchfluss(m_DurchflussSoll) Then
'            m_SPS.SetQSoll 0
'            sleep 5000
'
'            m_SPS.setBetrieb 0
'            sleep 2000
'
'            Call m_Referenzzaehler.loadForDurchfluss(m_DurchflussSoll, g_App.Settings.getMIDGruppe)
'            m_SPS.SetMID m_Referenzzaehler.EinbauplatzNr
'            bBetriebNeustart = True
'        End If
'
'        If Not m_Pumpe.IstOkFuerDurchfluss(m_DurchflussSoll) Then
'            m_SPS.SetQSoll 0
'            sleep 5000
'
'            m_SPS.setBetrieb 0
'            sleep 2000
'
'
'            ' Pumpenauswahl
'            m_SPS.AllePumpenAbwaehlen
'            Set m_Pumpe = Pumpenwahl(m_DurchflussSoll, m_ColPumpen)
'            m_Pumpe.Anwahl
'            PrintStatus "zu startende Pumpe: " & m_Pumpe.GetSPSVarname
'
'            bBetriebNeustart = True
'
'        End If
'
'        If bBetriebNeustart = True Then
'
'            m_SPS.SetServoStellung lookupFUServoStellwert(m_DurchflussSoll)
'            m_SPS.SetQSoll m_DurchflussSoll
'            lblQSoll.Caption = m_DurchflussSoll
'
'            m_SPS.setBetrieb 2
'            bBetriebNeustart = False
'
'        End If
'
'        ' Warten bis Durchfluss erreicht ist
'        PrintStatus "Warte auf 'Solldurchfluss erreicht'"
'        Do While Not m_SPS.SolldurchflussErreicht
'            QIstSPS = Format(m_SPS.getQIst, "0.000")
'            lblQIst.Caption = QIstSPS
'            sleep 500, True
'            If g_Abbruch = True Then
'                Exit Sub
'            End If
'        Loop
'        sleep 2000
'
'
'        ' Prüfzeit in s ausrechnen
'        m_Pruefzeit = 240 / m_DurchflussSoll
'        If m_Pruefzeit < 60 Then
'            m_Pruefzeit = 60
'        End If
'
'
'        For Each Einbauplatz In m_colEinbauplatz
'            Set Pruefzaehler = Einbauplatz.getPruefzaehler
'            EinbauplatzNr = Einbauplatz.getNr
'
'
'            If Not Pruefzaehler Is Nothing Then
'
'                    udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollDurchfluss = m_DurchflussSoll
'                    udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollPruefzeit_s = m_Pruefzeit
'
'            End If
'        Next
'        DoEvents
'
'        m_Tstart = GetTickCount
'        QIstSPS = Format(m_SPS.getQIst, "0.000")
'        lngReturn = UltraschallPruefung(udtPruefdaten_imPP_mitEBP)
'
'        ' lngReturn = 0
'
'        If lngReturn = 0 Then
'            ' Fehlerermittlung
'            For Each Einbauplatz In m_colEinbauplatz
'                Set Pruefzaehler = Einbauplatz.getPruefzaehler
'                EinbauplatzNr = Einbauplatz.getNr
'
'                If Not Pruefzaehler Is Nothing Then
'                lngReturn = GetUSVolumen(EinbauplatzNr, dblVolumenUS, Einbauplatz.getPruefzaehler.getSerienNr) And 0
'                    If lngReturn = 0 Then
'                        PrintStatus "Volumen des USZ: " & dblVolumenUS & " m³"
'                        lngReturn = GetRZVolumen(EinbauplatzNr, m_Referenzzaehler, dblVolumenRZ)
'                        If lngReturn = 0 Then
'
'                           PrintStatus "Volumen des RZ: " & dblVolumenRZ & " m³"
'                           dblVolumenRZ = dblVolumenRZ / (1 + m_Referenzzaehler.letzterFehler(m_DurchflussSoll) / 100)
'                           PrintStatus "Fehler des RZ in diesem PP:" & m_Referenzzaehler.letzterFehler(m_DurchflussSoll)
'                           PrintStatus "korrigiertes Volumen: " & dblVolumenRZ & " m³"
'
'
'                            ' unterschiedliche Prüfzeiten eliminieren
'                            DurchflussRZ = dblVolumenRZ / udtPruefdaten_imPP_mitEBP(EinbauplatzNr).RZ_IstPruefzeit_ms
'                            DurchflussUS = dblVolumenUS / udtPruefdaten_imPP_mitEBP(EinbauplatzNr).US_IstPruefzeit_ms
'
'                            'Simulation
'                            'DurchflussRZ = m_DurchflussSoll
'                            'DurchflussUS = DurchflussRZ * (1 + (Rnd(1) * 0.1 - 0.05))
'
'                            PrintStatus "US Durchfluss: " & DurchflussUS
'                            PrintStatus "Ist-Durchfluss: " & DurchflussRZ
'
'                            Fehler = ((DurchflussUS - DurchflussRZ) / DurchflussRZ) * 100
'                            PrintStatus "ergibt Fehler: " & Format(Fehler, "0.0") & " %"
'
'                            ResultFileHandle = FreeFile()
'                            Open ResultFilePath For Append As ResultFileHandle
'
'                            Print #ResultFileHandle, EinbauplatzNr & vbTab & Format(m_DurchflussSoll, "0.000") & vbTab & Format(QIstSPS, "0.000") & vbTab & Format(Fehler, "0.00") & vbTab & m_Pruefzeit & vbTab & "MID" & m_Referenzzaehler.Nennweite & "," & m_Pumpe.GetSPSVarname
'                            Close #ResultFileHandle
'                        Else
'                            PrintStatus " GETRZVolumen Fehlfunktion:" & lngReturn
'                        End If
'                    Else
'                        PrintStatus " GETUSVolumen Fehlfunktion:" & lngReturn
'                    End If
'                End If
'            Next
'        End If ' UltraschallPruefung
'
'        ' Durchfluss ändern
'        m_DurchflussSoll = CDbl(Format(m_DurchflussSoll * 0.9, "0.000"))
'
'        If m_DurchflussSoll < CDbl(txtFlowMin) Then
'            blnFertig = True
'        End If
'
'    Loop While Not blnFertig
'
'    PrintStatus "Kontinuierliche Prüfung beendet"
'End Sub


Private Sub KontinuierrlichePruefungWaage()
Dim altePumpeNr As Integer
Dim udtPruefdaten_imPP_mitEBP(10) As TypUSPruefdaten
Dim Einbauplatz As CEinbauplatz
Dim EinbauplatzNr As Integer
Dim lngReturn As Long

Dim Pruefzaehler As CPruefzaehler
Dim DurchflussRZ As Double
Dim DurchflussUS As Double
Dim dblVolumenRZ  As Double
Dim dblVolumenUS  As Double
Dim dblVolumenWaage As Double

Dim blnFertig As Boolean

Dim ResultFileHandle  As Long
Dim QIstSPS As Double
Dim QFlow_fp As Double
Dim Fehler As Double
Dim bBetriebNeustart As Boolean
Dim Temperatur As Double
Dim blnPruefungFertig As Boolean

    m_SPS.setBetrieb 0
    sleep 2000
    lblGesZeit.Visible = False
    Set m_Referenzzaehler = New CRefzaehler
    
    If g_Abbruch Then
        Exit Sub
    End If
    
    m_DurchflussSoll = CDbl(txtFlowMax.Text)
    
    ' Pumpe für den Start auswählen
    m_SPS.AllePumpenAbwaehlen
    Set m_Pumpe = Pumpenwahl(m_DurchflussSoll, m_ColPumpen)
    PrintStatus "zu startende Pumpe: " & m_Pumpe.GetSPSVarname
    bBetriebNeustart = True
            
    Set m_Referenzzaehler = New CRefzaehler
    Call m_Referenzzaehler.loadForDurchfluss(m_DurchflussSoll, g_App.Settings.getMIDGruppe)
    m_SPS.SetQDiff 0 ' m_Referenzzaehler.letzterFehler(m_DurchflussSoll)
        
    Do
        PrintStatus "Nächster Durchfluss: " & m_DurchflussSoll
        Debug.Print m_ersterPruefzaehler.getIdentNrObj.getNennweite
        
        'geändert am 22.01.2004 AP
        m_Pruefzeit = 500 / m_DurchflussSoll 'Falls neue Nennweiten geprüft werden sollten
        Select Case m_ersterPruefzaehler.getIdentNrObj.getNennweite
            Case 50
                m_Pruefzeit = 100 / m_DurchflussSoll
            Case 65
                m_Pruefzeit = 160 / m_DurchflussSoll
            Case 80
                m_Pruefzeit = 250 / m_DurchflussSoll
            Case 100
                m_Pruefzeit = 400 / m_DurchflussSoll
        End Select
        
        'Die Prüfzeit soll 60 Sekunden nie unterschreiten
        If m_Pruefzeit <= 60 Then
            m_Pruefzeit = 60
        End If
        
        'neu am 21.01.2004 AP die Prüfzeit soll 600 Sekunden nicht überschreiten
        If m_Pruefzeit >= 1100 Then
           m_Pruefzeit = 1100
        End If
        
        PrintStatus "Prüfzeit: " & m_Pruefzeit
        
        ' Ist der Referenzzähler für diesen Durchfluß geeignet ?
        If Not m_Referenzzaehler.IstOkFuerDurchfluss(m_DurchflussSoll) Then
            ' Referenzzaehler wechseln
            PrintStatus "Referenzzaehler wechseln"
            If Not m_PruefungsArtWaage Then
                m_SPS.SetQSoll 0
                sleep 5000
            
                m_SPS.setBetrieb 0
                sleep 2000
            End If
            
            Call m_Referenzzaehler.loadForDurchfluss(m_DurchflussSoll, g_App.Settings.getMIDGruppe)
            m_SPS.SetQDiff 0 ' m_Referenzzaehler.letzterFehler(m_DurchflussSoll)
            PrintStatus "nutze MID " & m_Referenzzaehler.Nennweite
            
            bBetriebNeustart = True
        End If
    
        If Not m_Pumpe.IstOkFuerDurchfluss(m_DurchflussSoll) Then
            ' Pumpe wechseln
            PrintStatus "Pumpe wechseln"
            If Not m_PruefungsArtWaage Then
                m_SPS.SetQSoll 0
                sleep 5000
                
                m_SPS.setBetrieb 0
                sleep 2000
            End If
            ' Pumpenauswahl
            m_SPS.AllePumpenAbwaehlen
            Set m_Pumpe = Pumpenwahl(m_DurchflussSoll, m_ColPumpen)
            PrintStatus "zu startende Pumpe: " & m_Pumpe.GetSPSVarname
            bBetriebNeustart = True
        End If
        
        ' hier gehts los, Pumpe und MID sind eingestellt
        
        If m_PruefungsArtWaage Then
                 
            ' Waage soweit wie nötig füllen und leeren, Grenzwert setzen
            If WaageVorbereitenFuerPP() < 0 Then
                ' Änderung 9.9.2002
                GoTo NextDurchfluss
            End If
            
        Else
            ' Durchlauf (kein Beählter) auswählen
            m_SPS.setBehaelter 1
        
            m_SPS.SetQSoll m_DurchflussSoll
            lblQSoll.Caption = m_DurchflussSoll
            
            m_SPS.SetMID m_Referenzzaehler.EinbauplatzNr
            
            m_SPS.SetQSoll m_DurchflussSoll
            lblQSoll.Caption = m_DurchflussSoll
            
            
            If bBetriebNeustart = True Then
                m_SPS.SetServoStellung lookupFUServoStellwert(m_DurchflussSoll)
                        
                ' Pumpe starten
                m_Pumpe.Anwahl
                m_SPS.SetMID m_Referenzzaehler.EinbauplatzNr
                m_SPS.setBetrieb 2
                bBetriebNeustart = False
            End If
        
            ' Warten bis Durchfluss erreicht ist
            PrintStatus "Warte auf 'Solldurchfluss erreicht'"
            Do While Not m_SPS.SolldurchflussErreicht
                QIstSPS = CDbl(m_SPS.getQIst)
                lblQIst.Caption = Format(QIstSPS, "0.000")
                sleep 500, True
                If g_Abbruch = True Then
                    Exit Sub
                End If
            Loop
            'sleep 2000
        End If ' keine Waage
        
        ' Wenn keine Waage: Wasser läuft
        ' Wenn       Waage: Wasser läuft nicht, Waage tariert
            
        For Each Einbauplatz In m_colEinbauplatz
            Set Pruefzaehler = Einbauplatz.getPruefzaehler
            EinbauplatzNr = Einbauplatz.getNr
        
            If Not Pruefzaehler Is Nothing Then
                    ' OptoTimer reset
                   Call USSetOptoOffTimerMax(Einbauplatz.getNr)
                    ' Pruefdaten setzen für Ultraschallprüfung
                    udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollDurchfluss = m_DurchflussSoll
                    udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollPruefzeit_s = m_Pruefzeit
            End If
        Next
        DoEvents
        
        Temperatur = m_SPS.GetEinlaufTemperatur
        
        If m_PruefungsArtWaage Then
            For Each Einbauplatz In m_colEinbauplatz
                Set Pruefzaehler = Einbauplatz.getPruefzaehler
                EinbauplatzNr = Einbauplatz.getNr
                If Not Pruefzaehler Is Nothing Then
                    lngReturn = StarteUSundRZZaehler(Einbauplatz.getNr)
                    If lngReturn = 0 Then
                            PrintStatus "RZ-START und NOVA_START OK"
                        Else
                            PrintStatus "RZ-START und NOVA_START Fehler:" & lngReturn
                        End If
                End If
            Next
            
            ' Waage virtuell tarieren
            m_Waage.SoftTara
            ' Prüfung starten
            
            m_SPS.AllePumpenAbwaehlen
            m_Pumpe.Anwahl
            m_SPS.SetMID m_Referenzzaehler.EinbauplatzNr
            
            m_SPS.SetServoStellung lookupFUServoStellwert(m_DurchflussSoll)
            m_SPS.SetQSoll m_DurchflussSoll
            
            m_SPS.setBetrieb 2
            m_Tstart = GetTickCount
            PrintStatus "Pumpe gestartet"
            Do While Not ((m_Pumpe.GetStatus And 4) = 4)
                sleep 500, True
                If g_Abbruch = True Then
                   Exit Sub
                End If
            Loop
            PrintStatus "Pumpe läuft"
            
            ' Prüfung startet
            lblGewicht = m_Waage.GetGewicht
            
            PrintStatus "Prüfung läuft, Ventil offen."
            QIstSPS = 0
            
            
            
            
            blnPruefungFertig = False
            Do While Not blnPruefungFertig
                If m_SPS.GrenzwertWaageErreicht Then
                    blnPruefungFertig = True
                Else
                
                    If QIstSPS = 0 And (GetTickCount - m_Tstart) \ 1000 > m_Pruefzeit \ 2 Then
                        QIstSPS = m_SPS.getQIst
                        PrintStatus "IstDurchfluss zur halben Prüfzeit: " & QIstSPS & " m³/h"
                    End If
                
                    lblQIst.Caption = Format(m_SPS.getQIst, "0.000")
                    lblGewicht = m_Waage.GetGewicht
                    sleep 500
                End If
                AnzeigeAktualisieren_mit_Waage
                sleep 100
                DoEvents
                
                If g_Abbruch Then Exit Sub
            Loop
            PrintStatus "Waagen-Grenzwert erreicht"
            m_SPS.setBetrieb 0
            ' Prüfzeit messen/stoppen in s
            m_Tpruef = (GetTickCount - m_Tstart) \ 1000
            
            m_Waage.SetNettoGrenzwert1 m_Behaelter.m_WaageGrenzwert
            
            PrintStatus "Warte auf Waagenruhe"
            Call m_Waage.WarteAufRuhe
            dblVolumenWaage = Volumen(m_Waage.GetGewicht, Temperatur) ' in m³
            PrintStatus "VolumenWaage: " & Format(dblVolumenWaage, "0.00000") & " m³"
            
            For Each Einbauplatz In m_colEinbauplatz
                EinbauplatzNr = Einbauplatz.getNr
                Set Pruefzaehler = Einbauplatz.getPruefzaehler
                If (Not Pruefzaehler Is Nothing) Then
                
                    lngReturn = StoppeUSundRZZaehler(EinbauplatzNr)
                    If lngReturn = 0 Then
                        PrintStatus "RZ-STOP und NOVA_STOP OK"
                    Else
                        PrintStatus "RZ-STOP und NOVA_STOP Fehler:" & lngReturn
                    End If
                End If ' PZ is nothing and GetActive
            Next Einbauplatz
            
            For Each Einbauplatz In m_colEinbauplatz
                EinbauplatzNr = Einbauplatz.getNr
                Set Pruefzaehler = Einbauplatz.getPruefzaehler
                If (Not Pruefzaehler Is Nothing) Then
                    lngReturn = GetUSVolumen(EinbauplatzNr, dblVolumenUS)
                    PrintStatus "Volumen des US: " & dblVolumenUS & " m³"
                    
                    Fehler = (dblVolumenUS - dblVolumenWaage) / dblVolumenWaage * 100
                    PrintStatus "ergibt Fehler: " & Format(Fehler, "0.0") & " %"
                    
                    saveKontPrueffehler Fehler, QIstSPS, dblVolumenUS, dblVolumenRZ, dblVolumenWaage, EinbauplatzNr, Temperatur, m_Tpruef, Einbauplatz.getPruefzaehler.getSerienNr
                    'auskommentiert am 29.08.02 Pfeiffer
                    'ResultFileHandle = FreeFile()
                    'Open ResultFilePath For Append As ResultFileHandle


'                    Print #ResultFileHandle, EinbauplatzNr & vbTab & Format(m_DurchflussSoll, "0.000") & vbTab & Format(QIstSPS, "0.000") & vbTab & Format(Fehler, "0.00") & vbTab & m_Tpruef & vbTab & "MID" & m_Referenzzaehler.Nennweite & "," & m_Pumpe.GetSPSVarname & vbTab & Format(dblVolumenUS, "0.00000") & vbTab & Format(dblVolumenWaage, "0.00000")
'                    Close #ResultFileHandle
                End If
            Next
        Else
        
            ' keine Waage
            sleep 1000
            QIstSPS = Format(m_SPS.getQIst, "0.000")
            lngReturn = UltraschallPruefung(udtPruefdaten_imPP_mitEBP)
            If g_Abbruch Then
                Exit Sub
            End If
            
            If lngReturn = 0 Then
                ' Fehlerermittlung
                For Each Einbauplatz In m_colEinbauplatz
                    Set Pruefzaehler = Einbauplatz.getPruefzaehler
                    EinbauplatzNr = Einbauplatz.getNr
                    
                    If Not Pruefzaehler Is Nothing Then
                        lngReturn = GetUSVolumen(EinbauplatzNr, dblVolumenUS) 'And 0
                        If lngReturn = 0 Then
                            PrintStatus "Volumen des USZ: " & dblVolumenUS & " m³"
                            lngReturn = GetRZVolumen(EinbauplatzNr, m_Referenzzaehler, dblVolumenRZ) And 0
                            If lngReturn = 0 Then
                                PrintStatus "Volumen des RZ: " & dblVolumenRZ & " m³"
                                PrintStatus "Fehler des RZ in diesem PP:" & m_Referenzzaehler.letzterFehler(m_DurchflussSoll)
                                dblVolumenRZ = dblVolumenRZ / (1 + m_Referenzzaehler.letzterFehler(m_DurchflussSoll) / 100)
                                PrintStatus "korrigiertes Volumen:" & dblVolumenRZ & " m³"
                                
                                ' unterschiedliche Prüf-Zeiten elimienieren
                                DurchflussRZ = dblVolumenRZ / udtPruefdaten_imPP_mitEBP(EinbauplatzNr).RZ_IstPruefzeit_ms
                                
                                If udtPruefdaten_imPP_mitEBP(EinbauplatzNr).US_IstPruefzeit_ms = 0 Then
                                    PrintStatus "US_IstPruefzeit_ms = 0, dh. Fehler konnte nicht ermittelt werden"
                                Else
                                      DurchflussUS = dblVolumenUS / udtPruefdaten_imPP_mitEBP(EinbauplatzNr).US_IstPruefzeit_ms
                                                          
                                    'Simulation
                                    'DurchflussRZ = m_DurchflussSoll
                                    'DurchflussUS = DurchflussRZ * (1 + (Rnd(1) * 0.1 - 0.05))
                                     
                                    PrintStatus "US Durchfluss: " & DurchflussUS
                                    PrintStatus "Ist-Durchfluss: " & DurchflussRZ
                                    
                                    Fehler = ((DurchflussUS - DurchflussRZ) / DurchflussRZ) * 100
                                    PrintStatus "ergibt Fehler: " & Format(Fehler, "0.0") & " %"
                                    
                                    'Hier werden die Daten für die Prüfung gegen Referenzzähler angespeichert
                                    saveKontPrueffehler Fehler, QIstSPS, dblVolumenUS, dblVolumenRZ, dblVolumenWaage, EinbauplatzNr, Temperatur, m_Tpruef, Einbauplatz.getPruefzaehler.getSerienNr
                                                        
    '                                ResultFileHandle = FreeFile()
    '                                Open ResultFilePath For Append As ResultFileHandle
    '
    '                                Print #ResultFileHandle, EinbauplatzNr & vbTab & Format(m_DurchflussSoll, "0.000") & vbTab & Format(QIstSPS, "0.000") & vbTab & Format(Fehler, "0.00") & vbTab & m_Pruefzeit & vbTab & "MID" & m_Referenzzaehler.Nennweite & "," & m_Pumpe.GetSPSVarname
    '                                Close #ResultFileHandle
                                End If
                            Else
                                PrintStatus " GETRZVolumen Fehlfunktion:" & lngReturn
                            End If
                        Else
                            PrintStatus " GETUSVolumen Fehlfunktion:" & lngReturn
                        End If
                    End If
                Next
            End If ' UltraschallPruefung
        End If ' keine Waage
        
        ' Durchfluss ändern
NextDurchfluss:
        m_DurchflussSoll = CDbl(Format(m_DurchflussSoll * (100 - CDbl(Left(cmbKontSprung.Text, 8))) / 100, "0.000"))
        
        If m_DurchflussSoll < CDbl(txtFlowMin) Then
            blnFertig = True
        End If
    
    Loop While Not blnFertig
    lblGesZeit.Visible = True
    
    PrintStatus "Kontinuierliche Prüfung beendet"
End Sub

Private Sub KontinuierrlichePruefungInit()
    ResultFilePath = "C:\kont.txt"
        
    On Error Resume Next
    Kill ResultFilePath
    On Error GoTo 0
    
    txtFlowMax = m_colUniqueVorPP.Item(1).getQ
    txtFlowMin = m_colUniqueVorPP.Item(m_colUniqueVorPP.Count).getQ
    'geändert am 22.01.2004 AP Vorbesetzung der ComboBox mit dem 2.Wert
    cmbKontSprung.ListIndex = 2
    
End Sub



Public Sub cmdStart_Click()
    Dim i As Integer
    Dim Ende As Integer
    
    m_Pruefgang.save
    lblTitle.Caption = "kontinuierliche Ultraschall-Zähler Prüfung"
        
    Ende = CInt(txtKontCount.Text)
    For i = Ende To 1 Step -1
        If g_Abbruch Then Exit Sub
        txtKontCount.Text = i
        PrintStatus "kontinuierlicher Prüfgang " & Ende - i & "/" & Ende
        
        
        Call KontinuierrlichePruefungWaage
        
        Set m_Pruefgang = Nothing
        Set m_Pruefgang = New CPruefgang
        m_Pruefgang.save
        
        If g_Abbruch Then Exit Sub
    Next
End Sub


Private Sub ShowUSParameter(udtUSJustageParameter As JustageParameter_Type, udtUSZusatzParameter As US_ZusatzParameter_Typ, sUeberschrift As String, EinbauplatzNr As Integer)
        PrintStatus "-----------------------------------------------------"
        PrintStatus sUeberschrift
        
        PrintStatus "Einbauplatz: " & EinbauplatzNr
        PrintStatus "Bereich_ns: " & udtUSJustageParameter.Bereich_ns
        PrintStatus "Geberkonstante_Neu1_m: " & udtUSJustageParameter.Geberkonstante_Neu1_m
        PrintStatus "Geberkonstante_Neu2_m: " & udtUSJustageParameter.Geberkonstante_Neu2_m
        PrintStatus " "
        PrintStatus "Geberkonstante1_IST_m: " & udtUSJustageParameter.Geberkonstante1_IST_m
        PrintStatus "Geberkonstante2_IST_m: " & udtUSJustageParameter.Geberkonstante2_IST_m
        PrintStatus "SteilheitGeber:" & udtUSJustageParameter.SteilheitGeber_nsp°C
        PrintStatus "Istfluss1_m3ph: " & udtUSJustageParameter.Istfluss1_m3ph
        PrintStatus " "
        PrintStatus "Istfluss2_m3ph: " & udtUSJustageParameter.Istfluss2_m3ph
        PrintStatus "Offset_Neu1_m3ph: " & udtUSJustageParameter.Offset_Neu1_m3ph
        PrintStatus "Offset_Neu2_m3ph: " & udtUSJustageParameter.Offset_Neu2_m3ph
        PrintStatus "Offset1_IST_m3ph: " & udtUSJustageParameter.Offset1_IST_m3ph
        PrintStatus "Offset2_IST_m3ph: " & udtUSJustageParameter.Offset2_IST_m3ph
        PrintStatus "OffsetGeber_ns: " & udtUSJustageParameter.OffsetGeber_ns
        PrintStatus " "
        PrintStatus "Sollfluss1_m3ph: " & udtUSJustageParameter.Sollfluss1_m3ph
        PrintStatus "Sollfluss2_m3ph: " & udtUSJustageParameter.Sollfluss2_m3ph
        PrintStatus "Temperatur1_°C: " & udtUSJustageParameter.Temperatur1_°C
        PrintStatus "Temperatur2_°C: " & udtUSJustageParameter.Temperatur2_°C
        PrintStatus "Unlinearitaet: " & udtUSJustageParameter.Unlinearitaet
        PrintStatus " "
        PrintStatus "FP_Impulswertigkeit: " & udtUSZusatzParameter.FP_Impulswertigkeit
        PrintStatus "FP_Impulswertigkeit_Pruef: " & udtUSZusatzParameter.FP_Impulswertigkeit_Pruef
        PrintStatus "PulseMode: " & udtUSZusatzParameter.PulseMode
        PrintStatus "FP_Flow_Min: " & udtUSZusatzParameter.FP_Flow_Min
        PrintStatus "FP_Flow_Max: " & udtUSZusatzParameter.FP_Flow_Max
        PrintStatus "-----------------------------------------------------"
End Sub


Private Function UltraschallpruefungWaage() As Double
    Dim Einbauplatz As CEinbauplatz
    Dim Pruefzaehler As CPruefzaehler
    Dim udtPruefdaten_imPP_mitEBP(10) As TypUSPruefdaten
    Dim Temperatur As Double
    Dim dblVolumenWaage  As Double

' Folgende Werte mussen gesetzt sein:

' m_ersterPruefzaehler (QMax bestimmen zum Füllen)
' m_DurchflussSoll
' m_PruefungsartWaage
' m_Pruefzeit

 ' Waage (m_Waage) vorbereiten
' Call WaageVorbereitenFuerPP
 
 ' Referenzzazehler m_Referenzzaehler setzen
  
' m_SPS.SetMID m_Referenzzaehler.EinbauplatzNr

' SPS.MID, m_Referenzzaehler muss ausgewählt sein
' m_waage muss ausgewählt sein


'    For Each Einbauplatz In m_colEinbauplatz
'        Set Pruefzaehler = Einbauplatz.getPruefzaehler
'        EinbauplatzNr = Einbauplatz.getNr
'
'        If Not Pruefzaehler Is Nothing Then
'                ' OptoTimer reset
'               Call USSetOptoOffTimerMax(Einbauplatz.getNr)
'                ' Pruefdaten setzen für Ultraschallprüfung
'                udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollDurchfluss = m_DurchflussSoll
'                udtPruefdaten_imPP_mitEBP(Einbauplatz.getNr).SollPruefzeit_s = m_Pruefzeit
'        End If
'    Next
'    DoEvents
'
'    Temperatur = m_SPS.GetEinlaufTemperatur
'
'    m_Tstart = GetTickCount ' Startzeitpunkt
'
'    For Each Einbauplatz In m_colEinbauplatz
'        Set Pruefzaehler = Einbauplatz.getPruefzaehler
'        EinbauplatzNr = Einbauplatz.getNr
'        If Not Pruefzaehler Is Nothing Then
'            lngReturn = StarteUSundRZZaehler(Einbauplatz.getNr, Einbauplatz.getPruefzaehler.getSerienNr)
'            If lngReturn = 0 Then
'                    PrintStatus "RZ-START und NOVA_START OK"
'                Else
'                    PrintStatus "RZ-START und NOVA_START Fehler:" & lngReturn
'                End If
'        End If
'    Next
'
'    ' Prüfung starten
'
'    m_SPS.setBetrieb 2
'    PrintStatus "Pumpe läuft, Ventil ist noch geschlossen"
'    Do While Not ((m_Pumpe.GetStatus And 4) = 4)
'        sleep 500, True
'    Loop
'    PrintStatus "Prüfung läuft, Ventil offen."
'
'    blnPruefungFertig = False
'    Do While Not blnPruefungFertig
'        If m_SPS.GrenzwertWaageErreicht Then
'            blnPruefungFertig = True
'        Else
'            sleep 300, True
'        End If
'        AnzeigeAktualisieren
'        sleep 100
'        DoEvents
'
'        If g_Abbruch Then Exit Function
'    Loop
'    PrintStatus "Waagen-Grenzwert erreicht"
'
'    m_SPS.setBetrieb 0
'    PrintStatus "Warte auf Waagenruhe"
'    Call m_Waage.WarteAufRuhe
'
'    For Each Einbauplatz In m_colEinbauplatz
'        EinbauplatzNr = Einbauplatz.getNr
'        Set Pruefzaehler = Einbauplatz.getPruefzaehler
'        If (Not Pruefzaehler Is Nothing) Then
'
'            lngReturn = StoppeUSundRZZaehler(EinbauplatzNr)
'            If lngReturn = 0 Then
'                PrintStatus "RZ-STOP und NOVA_STOP OK"
'            Else
'                PrintStatus "RZ-STOP und NOVA_STOP Fehler:" & lngReturn
'            End If
'        End If ' PZ is nothing
'    Next Einbauplatz
'
End Function



Private Sub saveKontPrueffehler(Fehler As Double, QIst As Double, VolumenUS As Double, VolumenRZ As Double, VolumenWaage As Double, EinbauplatzNr As Integer, Temperatur As Double, Pruefzeit As Long, SerienNr As Long)
Dim rs As CRecordset
Set rs = New CRecordset

rs.openRS "KontPrueffehler", False
rs.addNew

Call rs.setValue("PruefgangNr", m_Pruefgang.PruefgangNr)
Call rs.setValue("Datum", Now())

Call rs.setValue("Fehler", Fehler)
Call rs.setValue("Solldurchfluss", m_DurchflussSoll)
Call rs.setValue("DurchflussSPS", QIst)
Call rs.setValue("VolumenUS", VolumenUS)
Call rs.setValue("VolumenRef", VolumenRZ)
Call rs.setValue("VolumenWaage", VolumenWaage)
Call rs.setValue("SerienNr", SerienNr)


If Not m_Pumpe Is Nothing Then
    Call rs.setValue("Pumpe", m_Pumpe.GetSPSVarname)
End If

If Not m_Referenzzaehler Is Nothing Then
    Call rs.setValue("MID", m_Referenzzaehler.Nennweite)
End If

Call rs.setValue("EinbauplatzNr", EinbauplatzNr)
Call rs.setValue("Temperatur", Temperatur)
Call rs.setValue("Pruefzeit", Pruefzeit)

rs.update
Set rs = Nothing
End Sub




Private Sub Form_Unload(Cancel As Integer)
On Error Resume Next
    If Not m_Waage Is Nothing Then
        m_Waage.releaseMScomm
        Set m_Waage = Nothing
    End If
End Sub



Private Function SindPruefzeitenOK() As Boolean
PrintStatus "SIndPruefzeitenOK..."

    SindPruefzeitenOK = True
    ' Exit Function

Dim Vorpruefpunkt As CVorpruefpunkt
Dim Pruefpunkt As CPruefpunkt
Dim dblSollVolumen As Double
Dim Behaelter As CBehaelter


If m_VorPruefungsArtWaage And mbln_Vorpruefung Then
    For Each Vorpruefpunkt In m_ersterPruefzaehler.getVorpruefpunkte.getPruefpunkte.getCollection
        dblSollVolumen = Vorpruefpunkt.getQ * Vorpruefpunkt.GetTime / 3.6
        
        Set Behaelter = New CBehaelter
        If Behaelter.IstOkFuerVolumen(dblSollVolumen) = True Then
            PrintStatus "Behälter für Prüfpunkt Q=" & Vorpruefpunkt.getQ & ", " & Vorpruefpunkt.GetTime & "s gefunden."
            PrintStatus "Behälter grenzwert:" & Behaelter.m_WaageGrenzwert
        Else
            MsgBox "### kein Behälter mit" & dblSollVolumen & "l für VorPrüfpunkt Q=" & Vorpruefpunkt.getQ & " und Tprüf=" & Vorpruefpunkt.GetTime & "s gefunden."
            PrintStatus "### kein Behälter mit" & dblSollVolumen & "l für VorPrüfpunkt Q=" & Vorpruefpunkt.getQ & " und Tprüf=" & Vorpruefpunkt.GetTime & "s gefunden."
            SindPruefzeitenOK = False
        End If
    Next
End If

If m_PruefungsArtWaage And mbln_Hauptpruefung Then
    For Each Pruefpunkt In m_ersterPruefzaehler.getPruefpunkte.getPruefpunkte.getCollection
        dblSollVolumen = Pruefpunkt.getQ * Pruefpunkt.GetTime / 3.6

        Set Behaelter = New CBehaelter
        If Behaelter.LoadForVolumen(dblSollVolumen) Then
            PrintStatus "Behälter mit " & dblSollVolumen & " l für Prüfpunkt Q=" & Pruefpunkt.getQ & " und Tprüf=" & Pruefpunkt.GetTime & "s gefunden."
            PrintStatus "Behälter grenzwert:" & Behaelter.m_WaageGrenzwert
        Else
            MsgBox "### kein Behälter mit " & dblSollVolumen & " l für Prüfpunkt Q=" & Pruefpunkt.getQ & ", " & Pruefpunkt.GetTime & "s gefunden."
            PrintStatus "### kein Behälter mit " & dblSollVolumen & " l für Prüfpunkt Q=" & Pruefpunkt.getQ & " und Tprüf=" & Pruefpunkt.GetTime & "s gefunden."
            SindPruefzeitenOK = False
        End If
    Next
End If

End Function

Function ResetTemperaturTransferLock(intPortNr As Integer, Optional lngIdentNoForVerification As Long = -1) As Long
Dim lngReturn As Long
Dim blnResult As Boolean

lngReturn = SetTemperatureTransferLock(intPortNr, False, lngIdentNoForVerification)
   If lngReturn <> 0 Then
      ResetTemperaturTransferLock = lngReturn
      Exit Function
   End If
   'Überprüfen !
   lngReturn = GetTemperatureTransferLock(intPortNr, blnResult, lngIdentNoForVerification)
   If lngReturn <> 0 Then
      ResetTemperaturTransferLock = lngReturn
      Exit Function
   End If
   If blnResult = True Then   'Temperatur kann nicht gemessen werden -> Zähler darf so nicht ausgeliefert werden !!!
      ResetTemperaturTransferLock = -55
      Exit Function
   End If
End Function



Function GetUSVoreinstellwert(dblDurchfluss As Double) As Integer
Dim strSQL As String
Dim rs As CRecordset
Dim iNennweite As Integer
Dim dblObererDurchfluss As Double
Dim dblUntererDurchfluss As Double
Dim dblObererVoreinstellwert As Double
Dim dblUntererVoreinstellwert As Double

On Error GoTo Errorhandler
Set rs = New CRecordset
iNennweite = m_ersterPruefzaehler.getIdentNrObj.getNennweite

strSQL = "SELECT * FROM USVoreinstellwerte where Nennweite = " & iNennweite & " and Pruefstation= " & g_App.PruefstationNr & " order by Durchfluss desc"

rs.openRS strSQL, True

dblObererDurchfluss = 0
dblUntererDurchfluss = 0

Do While Not rs.EOF
    Debug.Print rs.getDoubleValue("Durchfluss")
    dblObererDurchfluss = rs.getDoubleValue("Durchfluss")
    dblObererVoreinstellwert = rs.getDoubleValue("Voreinstellwert")
        
    
    If dblObererDurchfluss >= dblDurchfluss And dblDurchfluss >= dblUntererDurchfluss Then
        GetUSVoreinstellwert = dblObererVoreinstellwert - (dblObererVoreinstellwert - dblUntererVoreinstellwert) * (dblObererDurchfluss - dblDurchfluss) / (dblObererDurchfluss - dblUntererDurchfluss)
        PrintStatus "USVoreinstellwert (interpoliert)= " & GetUSVoreinstellwert
        Exit Function
    End If

    dblUntererDurchfluss = dblObererDurchfluss
    dblUntererVoreinstellwert = dblObererVoreinstellwert

    rs.MoveNext
Loop
    ErrorMsg "bitte Tabelle USVoreinstellwert pflegen"
    GetUSVoreinstellwert = 50
Exit Function

Errorhandler:
    ErrorMsg "Fehler " & Err.Number & " in GetUSVoreinstellwert: " & Err.Description
End Function


Private Sub Setze_FP_St_GeberKonstanteZeroflow(ByRef SteilheitGeber_nsp() As Double)
   Dim EinbauplatzNr As Integer
   Dim Einbauplatz As CEinbauplatz
   Dim Pruefzaehler As CPruefzaehler
   Dim ComPort As Integer
   Dim lngReturn As Long
   
   Dim dblFlpDiffTof As Double
   Dim dblFP_Zeroflow_DiffTof As Double
   Dim dblFP_Zeroflow_Temp As Double
   Dim dblFP_ST_Geber As Double
   Dim dblTemperatur As Double
   
   Dim intMessdauer As Integer
   Dim lngStartzeit As Long
   Dim i As Integer
   
   Dim mlngCountMessungenLaufzeit(10) As Long
   Dim mdblLaufzeitMittelSumme(10) As Double
   
   Dim mdblTemperaturMittelSumme(10) As Double
   Dim mlngCountMessungenTemp(10) As Double

   
   dblTemperatur = m_SPS.GetEinlaufTemperatur
   
   ' zur Berechnung der Mittelwerte auf Null setzen
   For i = 1 To 10
      mdblLaufzeitMittelSumme(i) = 0
      mdblTemperaturMittelSumme(i) = 0
      mlngCountMessungenLaufzeit(i) = 0
      mlngCountMessungenTemp(i) = 0
   Next
   
   ' Messdauer aus INI Datei holen
   intMessdauer = g_App.Settings.GETUSZeroflowMesszeit
   PrintStatus "Zeroflow Messung gestartet (Dauer " & intMessdauer & " s)"
   
   
   ' durchschnittliche Zeroflow Laufzeit für alle Einbauplätze bestimmen
   lngStartzeit = GetTickCount
   ' für die Dauer der Prüfzeit
   Do While (GetTickCount - lngStartzeit) / 1000 < intMessdauer
      lblZeit.Caption = Format((GetTickCount - lngStartzeit) / 1000, "0") & "/" & intMessdauer
      DoEvents
      ' für jeden Prüfzaehler
      For Each Einbauplatz In m_colEinbauplatz
         EinbauplatzNr = Einbauplatz.getNr
         ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
         Set Pruefzaehler = Einbauplatz.getPruefzaehler
         If Not Pruefzaehler Is Nothing Then
            Debug.Print "Einbauplatz " & EinbauplatzNr
            ' Hole die aktuelle Laufzeit im stehenden kalten Wasser für diesen Prüfzähler
            lngReturn = modIECCOM.Get_FLP_DIffTof(ComPort, dblFlpDiffTof)
            Debug.Print "Get_FLP_DIffTof: " & dblFlpDiffTof
            DoEvents
            If lngReturn = 0 Then
               ' Errechne den Mittelwert
               mlngCountMessungenLaufzeit(EinbauplatzNr) = mlngCountMessungenLaufzeit(EinbauplatzNr) + 1
               Debug.Print "Messung Nr " & mlngCountMessungenLaufzeit(EinbauplatzNr)
               mdblLaufzeitMittelSumme(EinbauplatzNr) = mdblLaufzeitMittelSumme(EinbauplatzNr) + dblFlpDiffTof
               Debug.Print "mdblLaufzeitMittelSumme(" & EinbauplatzNr & "): " & mdblLaufzeitMittelSumme(EinbauplatzNr)
            Else
               PrintStatus "Fehler in Get_FLP_DIffTof " & lngReturn & " für Einbauplatz " & EinbauplatzNr
            End If
         End If
      Next
   Loop
   
   
   For Each Einbauplatz In m_colEinbauplatz
      EinbauplatzNr = Einbauplatz.getNr
      ComPort = g_App.Settings.getUSComPort(EinbauplatzNr)
      Set Pruefzaehler = Einbauplatz.getPruefzaehler
      If Not Pruefzaehler Is Nothing Then
         ' Hole die im Zähler gespeicherte Temperatur der warmen Zeroflow Messung
         If modIECCOM.Get_FP_Zeroflow_DiffTof(ComPort, dblFP_Zeroflow_DiffTof) = 0 Then
            ' Hole die im Zähler gespeicherte Laufzeit der warmen Zeroflow Messung
            If modIECCOM.Get_FP_ZeroflowTemperature(ComPort, dblFP_Zeroflow_Temp) = 0 Then
            
               '            aktuelle kalte Laufzeit - gespeicherte warme Laufzeit
               'd ns/°C = -----------------------------------------------------------
               '            aktuelle kalte Temperatur - gespeicherte warme Temperatur
               
               dblFP_ST_Geber = (dblFP_Zeroflow_DiffTof - dblFlpDiffTof) / (dblFP_Zeroflow_Temp - dblTemperatur)
               ' Setze den JustageParameter
               SteilheitGeber_nsp(EinbauplatzNr) = dblFP_ST_Geber
            Else
               'Get_FP_ZeroflowTemperature
               Stop
            End If
         Else
            'Get_FP_Zeroflow_DiffTof
            Stop
         End If
      End If
   Next
End Sub



Sub UpdateTemperaturInZaehler()
    Dim Einbauplatz As CEinbauplatz
    Dim EinbauplatzNr  As Integer
    Dim Pruefzaehler As CPruefzaehler
    Dim dblTemperatur As Double
    Dim lngRet As Long
    Dim Fehler As Boolean
    Dim MerkerEinbauplatz As Byte
    
    
    dblTemperatur = m_SPS.GetEinlaufTemperatur
    'PrintStatus "Stations Temperatur ermittelt =" & Format(dblTemperatur, "0.00") & "Grad"
    For Each Einbauplatz In m_colEinbauplatz
        EinbauplatzNr = Einbauplatz.getNr
        Set Pruefzaehler = Einbauplatz.getPruefzaehler
        If (Not Pruefzaehler Is Nothing) And Einbauplatz.getAktiv Then
            ' dieser Zähler soll geprüft werden
        
            lngRet = USSetTemperatur(EinbauplatzNr, dblTemperatur)
            
            If lngRet = 0 Then
                'PrintStatus "USSetTemperatur OK: T=" & Format(dblTemperatur, "0.00") & " EP " & EinbauplatzNr
            Else
                Fehler = True
                MerkerEinbauplatz = EinbauplatzNr
                'PrintStatus "USSetTemperatur Fehler" & lngRet
            End If
            
        End If
    Next
    If Not Fehler Then
        'PrintStatus "In alle USZähler übertragen"
    Else
        PrintStatus "Übertragungsfehler nach USZähler " & MerkerEinbauplatz
    End If
End Sub