2712 lines
100 KiB
Plaintext
2712 lines
100 KiB
Plaintext
VERSION 5.00
|
|
Object = "{831FDD16-0C5C-11D2-A9FC-0000F8754DA1}#2.2#0"; "MSCOMCTL.OCX"
|
|
Object = "{5E9E78A0-531B-11CF-91F6-C2863C385E30}#1.0#0"; "msflxgrd.ocx"
|
|
Begin VB.Form frmVerbundzaehlerHauptpruefung
|
|
Caption = "Verbundzähler Prüfung"
|
|
ClientHeight = 11115
|
|
ClientLeft = 165
|
|
ClientTop = 450
|
|
ClientWidth = 15240
|
|
LinkTopic = "Form1"
|
|
ScaleHeight = 11115
|
|
ScaleWidth = 15240
|
|
StartUpPosition = 3 'Windows-Standard
|
|
Begin VB.Frame frMain
|
|
Height = 10995
|
|
Left = 30
|
|
TabIndex = 1
|
|
Top = 0
|
|
Width = 15405
|
|
Begin VB.CommandButton cmdCancel
|
|
Caption = "Abbruch"
|
|
Height = 735
|
|
Left = 8580
|
|
TabIndex = 39
|
|
Top = 10080
|
|
Width = 2475
|
|
End
|
|
Begin VB.CommandButton cmdSchrittAbbruch
|
|
Caption = "aktuellen Schritt abbrechen"
|
|
Height = 315
|
|
Left = 750
|
|
TabIndex = 36
|
|
Top = 7440
|
|
Width = 2265
|
|
End
|
|
Begin MSFlexGridLib.MSFlexGrid MSFgErgebnisse
|
|
Height = 2085
|
|
Left = 3690
|
|
TabIndex = 35
|
|
Top = 4980
|
|
Width = 7275
|
|
_ExtentX = 12832
|
|
_ExtentY = 3678
|
|
_Version = 393216
|
|
End
|
|
Begin MSComctlLib.ProgressBar ProgressBar1
|
|
Height = 315
|
|
Left = 210
|
|
TabIndex = 34
|
|
Top = 7110
|
|
Visible = 0 'False
|
|
Width = 3255
|
|
_ExtentX = 5741
|
|
_ExtentY = 556
|
|
_Version = 393216
|
|
Appearance = 1
|
|
End
|
|
Begin MSFlexGridLib.MSFlexGrid msfgAblauf
|
|
Height = 6675
|
|
Left = 240
|
|
TabIndex = 33
|
|
Top = 480
|
|
Width = 3285
|
|
_ExtentX = 5794
|
|
_ExtentY = 11774
|
|
_Version = 393216
|
|
Cols = 1
|
|
AllowBigSelection= 0 'False
|
|
Enabled = 0 'False
|
|
HighLight = 0
|
|
SelectionMode = 1
|
|
End
|
|
Begin VB.Frame Frame3
|
|
Caption = "Regulierung"
|
|
Height = 1005
|
|
Left = 11490
|
|
TabIndex = 28
|
|
Top = 720
|
|
Width = 3255
|
|
Begin VB.ComboBox cmbDaempfung
|
|
Enabled = 0 'False
|
|
Height = 315
|
|
Left = 1260
|
|
TabIndex = 29
|
|
Text = "Combo1"
|
|
Top = 570
|
|
Width = 975
|
|
End
|
|
Begin VB.Label Label12
|
|
Alignment = 1 'Rechts
|
|
Caption = "Sollwert"
|
|
Height = 315
|
|
Left = 180
|
|
TabIndex = 32
|
|
Top = 270
|
|
Width = 825
|
|
End
|
|
Begin VB.Label Label11
|
|
BorderStyle = 1 'Fest Einfach
|
|
Height = 285
|
|
Left = 1260
|
|
TabIndex = 31
|
|
Top = 240
|
|
Width = 1215
|
|
End
|
|
Begin VB.Label Label10
|
|
Caption = "Dämpfung"
|
|
Height = 315
|
|
Left = 240
|
|
TabIndex = 30
|
|
Top = 600
|
|
Width = 885
|
|
End
|
|
End
|
|
Begin VB.Frame frmOeffnenSchliessen
|
|
Caption = "Eingabe Öffnen / Schliessen Durchfluss"
|
|
Enabled = 0 'False
|
|
Height = 4185
|
|
Left = 11130
|
|
TabIndex = 17
|
|
Top = 5550
|
|
Visible = 0 'False
|
|
Width = 3945
|
|
Begin VB.Frame FrameOffnenSchliessen
|
|
Caption = "Einbauplatz B"
|
|
Height = 1185
|
|
Index = 2
|
|
Left = 240
|
|
TabIndex = 23
|
|
Top = 1620
|
|
Width = 3465
|
|
Begin VB.TextBox txtDurchflussOeffnen
|
|
Alignment = 1 'Rechts
|
|
Height = 345
|
|
Index = 2
|
|
Left = 180
|
|
TabIndex = 25
|
|
Top = 600
|
|
Width = 1305
|
|
End
|
|
Begin VB.TextBox txtDurchflussSchliessen
|
|
Alignment = 1 'Rechts
|
|
Height = 345
|
|
Index = 2
|
|
Left = 1890
|
|
TabIndex = 24
|
|
Top = 600
|
|
Width = 1305
|
|
End
|
|
Begin VB.Label Label8
|
|
Caption = "Öffnen [m³/h]"
|
|
Height = 345
|
|
Index = 1
|
|
Left = 210
|
|
TabIndex = 27
|
|
Top = 330
|
|
Width = 1245
|
|
End
|
|
Begin VB.Label Label9
|
|
Caption = "Schliessen [m³/h]"
|
|
Height = 255
|
|
Index = 1
|
|
Left = 1860
|
|
TabIndex = 26
|
|
Top = 300
|
|
Width = 1365
|
|
End
|
|
End
|
|
Begin VB.Frame FrameOffnenSchliessen
|
|
Caption = "Einbauplatz A"
|
|
Height = 1095
|
|
Index = 1
|
|
Left = 240
|
|
TabIndex = 18
|
|
Top = 450
|
|
Width = 3465
|
|
Begin VB.TextBox txtDurchflussSchliessen
|
|
Alignment = 1 'Rechts
|
|
Height = 345
|
|
Index = 1
|
|
Left = 1860
|
|
TabIndex = 22
|
|
Top = 570
|
|
Width = 1305
|
|
End
|
|
Begin VB.TextBox txtDurchflussOeffnen
|
|
Alignment = 1 'Rechts
|
|
Height = 345
|
|
Index = 1
|
|
Left = 150
|
|
TabIndex = 20
|
|
Top = 570
|
|
Width = 1305
|
|
End
|
|
Begin VB.Label Label9
|
|
Caption = "Schliessen [m³/h]"
|
|
Height = 345
|
|
Index = 0
|
|
Left = 1920
|
|
TabIndex = 21
|
|
Top = 300
|
|
Width = 1455
|
|
End
|
|
Begin VB.Label Label8
|
|
Caption = "Öffnen [m³/h]"
|
|
Height = 345
|
|
Index = 0
|
|
Left = 180
|
|
TabIndex = 19
|
|
Top = 300
|
|
Width = 1935
|
|
End
|
|
End
|
|
End
|
|
Begin VB.TextBox txtStatus
|
|
Height = 2415
|
|
Left = 3690
|
|
MultiLine = -1 'True
|
|
ScrollBars = 2 'Vertikal
|
|
TabIndex = 8
|
|
Top = 7200
|
|
Width = 7185
|
|
End
|
|
Begin MSFlexGridLib.MSFlexGrid MSFlexgridMessung
|
|
Height = 4545
|
|
Left = 3600
|
|
TabIndex = 3
|
|
Top = 450
|
|
Width = 7305
|
|
_ExtentX = 12885
|
|
_ExtentY = 8017
|
|
_Version = 393216
|
|
End
|
|
Begin VB.Frame Frame1
|
|
Height = 2145
|
|
Left = 120
|
|
TabIndex = 4
|
|
Top = 7740
|
|
Width = 3435
|
|
Begin VB.Label Label13
|
|
Caption = "PrüfgangNr"
|
|
Height = 255
|
|
Left = 240
|
|
TabIndex = 38
|
|
Top = 1620
|
|
Width = 915
|
|
End
|
|
Begin VB.Label lblPruefgangNr
|
|
BorderStyle = 1 'Fest Einfach
|
|
Height = 315
|
|
Left = 1290
|
|
TabIndex = 37
|
|
Top = 1590
|
|
Width = 1515
|
|
End
|
|
Begin VB.Label lblPruefzeitSoll
|
|
Alignment = 1 'Rechts
|
|
BorderStyle = 1 'Fest Einfach
|
|
Height = 345
|
|
Left = 1290
|
|
TabIndex = 15
|
|
Top = 1170
|
|
Width = 855
|
|
End
|
|
Begin VB.Label Label7
|
|
Caption = "Soll Pruefzeit"
|
|
Height = 315
|
|
Left = 150
|
|
TabIndex = 14
|
|
Top = 1200
|
|
Width = 1005
|
|
End
|
|
Begin VB.Label Label6
|
|
Caption = "s"
|
|
Height = 315
|
|
Left = 2220
|
|
TabIndex = 13
|
|
Top = 1230
|
|
Width = 555
|
|
End
|
|
Begin VB.Label lblQSoll
|
|
Alignment = 1 'Rechts
|
|
BorderStyle = 1 'Fest Einfach
|
|
Height = 345
|
|
Left = 1320
|
|
TabIndex = 12
|
|
Top = 150
|
|
Width = 855
|
|
End
|
|
Begin VB.Label Label5
|
|
Caption = "Soll-Durchfluss"
|
|
Height = 315
|
|
Left = 180
|
|
TabIndex = 11
|
|
Top = 210
|
|
Width = 1005
|
|
End
|
|
Begin VB.Label Label4
|
|
Caption = "m³/(h"
|
|
Height = 315
|
|
Left = 2280
|
|
TabIndex = 10
|
|
Top = 150
|
|
Width = 555
|
|
End
|
|
Begin VB.Label Label2
|
|
Caption = "m³/(h"
|
|
Height = 315
|
|
Left = 2280
|
|
TabIndex = 7
|
|
Top = 540
|
|
Width = 555
|
|
End
|
|
Begin VB.Label Label3
|
|
Caption = "Ist-Durchfluss"
|
|
Height = 315
|
|
Left = 180
|
|
TabIndex = 6
|
|
Top = 600
|
|
Width = 1005
|
|
End
|
|
Begin VB.Label lblQist
|
|
Alignment = 1 'Rechts
|
|
BorderStyle = 1 'Fest Einfach
|
|
Height = 345
|
|
Left = 1320
|
|
TabIndex = 5
|
|
Top = 540
|
|
Width = 855
|
|
End
|
|
End
|
|
Begin VB.CommandButton cmdWeiter
|
|
Caption = "Weiter"
|
|
Height = 735
|
|
Left = 11190
|
|
TabIndex = 16
|
|
Top = 10080
|
|
Width = 2475
|
|
End
|
|
Begin VB.Label lblAutosize
|
|
BorderStyle = 1 'Fest Einfach
|
|
Caption = "lblAutosize"
|
|
Height = 255
|
|
Left = 9780
|
|
TabIndex = 9
|
|
Top = 180
|
|
Visible = 0 'False
|
|
Width = 1065
|
|
End
|
|
Begin VB.Label Label1
|
|
Caption = "Fortschritt"
|
|
Height = 165
|
|
Left = 180
|
|
TabIndex = 2
|
|
Top = 210
|
|
Width = 1935
|
|
End
|
|
End
|
|
Begin MSComctlLib.StatusBar StatusBar1
|
|
Align = 2 'Unten ausrichten
|
|
Height = 435
|
|
Left = 0
|
|
TabIndex = 0
|
|
Top = 10680
|
|
Width = 15240
|
|
_ExtentX = 26882
|
|
_ExtentY = 767
|
|
Style = 1
|
|
_Version = 393216
|
|
BeginProperty Panels {8E3867A5-8586-11D1-B16A-00C0F0283628}
|
|
NumPanels = 1
|
|
BeginProperty Panel1 {8E3867AB-8586-11D1-B16A-00C0F0283628}
|
|
EndProperty
|
|
EndProperty
|
|
End
|
|
End
|
|
Attribute VB_Name = "frmVerbundzaehlerHauptpruefung"
|
|
Attribute VB_GlobalNameSpace = False
|
|
Attribute VB_Creatable = False
|
|
Attribute VB_PredeclaredId = True
|
|
Attribute VB_Exposed = False
|
|
Option Explicit
|
|
|
|
Public m_nRet As Integer
|
|
Public m_colEinbauplatz As Collection
|
|
Public m_Pruefgang As CPruefgang
|
|
Public m_colUniquePP As CPruefpunktCol
|
|
Public m_ColPumpen As Collection
|
|
Private m_Pumpe As CPumpe
|
|
|
|
Private m_DurchflussSoll As Double
|
|
Private m_Refzaehler As CRefzaehler
|
|
|
|
Private m_blnActivated As Boolean
|
|
|
|
Private m_lngPruefzeit_s As Long
|
|
|
|
Private m_FMBus As CFMBus
|
|
Private m_SPS As CSPS
|
|
|
|
Public m_blnSimulation As Boolean
|
|
|
|
Private m_Messdaten(2) As Pruefdaten_type
|
|
Private m_dblPruefzeit_s As Double
|
|
|
|
Private m_blnAbbruch As Boolean ' aktuellen Schritt abbrechen
|
|
|
|
Private mblnWeiter As Boolean
|
|
Private m_ersterPruefzaehler As CPruefzaehler
|
|
|
|
Public m_lngImpulswertigkeit_NZ As Long
|
|
|
|
Private m_PruefungAbbrechen As Boolean ' Prüfung muss wegen defektem Zähler abgebrochen werden
|
|
|
|
Public mbln_eRegister As Boolean
|
|
|
|
Const INISECTION = "Verbundzaehlerpruefung"
|
|
Const INIKEY_PRUEFZEIT_DER_IMPULSZAEHLUNG = "Pruefzeit_Impulszaehlung"
|
|
Const INIKEY_MAX_IMPULSE_HZ = "MaxImpulseHZBeiNZPeriodendauermessung"
|
|
Const INIKEY_MAX_IMPULSE_NZ = "MaxImpulseNZBeiHZPeriodendauermessung"
|
|
|
|
Private Type Pruefdaten_type
|
|
FM85Adresse_RZ As Integer
|
|
FM85Adresse_HZ As Integer
|
|
FM85Adresse_NZ As Integer
|
|
|
|
Impulswertigkeit_HZ As Long
|
|
Impulswertigkeit_NZ As Long
|
|
Impulswertigkeit_RZ As Long
|
|
|
|
Durchfluss_HZ As Double
|
|
Durchfluss_NZ As Double
|
|
Durchfluss_RZ As Double
|
|
Durchfluss_HZ_NZ As Double
|
|
|
|
gezaehlteImpulse_HZ As Long
|
|
gezaehlteImpulse_NZ As Long
|
|
gezaehlteImpulse_RZ As Long
|
|
|
|
Pruefzeit_HZ As Double
|
|
Pruefzeit_NZ As Double
|
|
Pruefzeit_RZ As Double
|
|
|
|
verbleibendeImpulse_HZ As Long
|
|
verbleibendeImpulse_NZ As Long
|
|
verbleibendeImpulse_RZ As Long
|
|
|
|
AnzahlPerioden_HZ As Long
|
|
AnzahlPerioden_NZ As Long
|
|
AnzahlPerioden_RZ As Long
|
|
|
|
Periodendauer_HZ As Long
|
|
Periodendauer_NZ As Long
|
|
Periodendauer_RZ As Long
|
|
|
|
Durchfluss_ist As Double
|
|
|
|
Durchfluss_Oeffnen As Double
|
|
Durchfluss_Schliessen As Double
|
|
|
|
Anteil_HZ As Double
|
|
Anteil_NZ As Double
|
|
|
|
bln_Auf_NZ_warten As Boolean
|
|
Fehler_RZ As Double
|
|
gesamtFehler As Double
|
|
|
|
Ergebniss_Fehler_Qmax As Double
|
|
Ergebniss_Fehler_Oeffnen As Double
|
|
Ergebniss_Fehler_Schliessen As Double
|
|
Ergebniss_Fehler_Qmin As Double
|
|
|
|
MaxErlaubteAnzahlVonImpulsen_HZ As Long
|
|
MaxErlaubteAnzahlVonImpulsen_NZ As Long
|
|
MessungAbbrechenNachSekunden As Long
|
|
|
|
End Type
|
|
|
|
|
|
|
|
Private Enum enum_spalte
|
|
Ueberschrift = 0
|
|
RZ = 1
|
|
HZ1 = 2
|
|
NZ1 = 3
|
|
HZ2 = 4
|
|
NZ2 = 5
|
|
End Enum
|
|
|
|
Private Enum enum_ergbenissspalte
|
|
Label = 0
|
|
Qmax = 1
|
|
Qoeff = 2
|
|
Qschl = 3
|
|
Qmin = 4
|
|
End Enum
|
|
|
|
Private Enum enum_zeile_ereg
|
|
Funkadresse = 1
|
|
SerienNr = 2
|
|
End Enum
|
|
|
|
Private Enum enum_zeile
|
|
Ueberschrift = 0
|
|
Adresse = 1
|
|
SerienNr = 2
|
|
KndEigeneSNr = 3
|
|
Impulswertigkeit = 4
|
|
Impulse = 5
|
|
GezaehlteImpulse = 6
|
|
VerbleibeneImpulse = 7
|
|
Durchfluss_m3 = 8
|
|
Anteil = 9
|
|
Periodendauer = 10
|
|
Pruefzeit = 11
|
|
Fehler = 12
|
|
Durchfluss_HZ_NZ = 13
|
|
Fehler_HZ_NZ = 14
|
|
Durchfluss_Oeffnen = 15
|
|
Durchfluss_Schliessen = 16
|
|
|
|
Anzahl = 17
|
|
End Enum
|
|
|
|
Private Enum enum_Fortschritt
|
|
Regulieren_bei_QMax = 0
|
|
Regulieren_bei_QMax_Impulszaehlung = 1
|
|
Regulieren_bei_QMax_Regulieren = 2
|
|
|
|
Eintragen_Oeffnen_Schließen = 3
|
|
|
|
Messung_QMax = 4
|
|
Messung_QMax_Impulszaehlung = 5
|
|
Messung_QMax_Periodendauermessung = 6
|
|
|
|
Messung_Qoeff = 7
|
|
Messung_Qoeff_Durchfluss_einstellen = 8
|
|
Messung_Qoeff_Periodendauermessung = 9
|
|
|
|
Messung_Qschl = 10
|
|
Messung_Qschl_Durchfluss_einstellen = 11
|
|
Messung_Qschl_Periodendauermessung = 12
|
|
|
|
Messung_Qmin = 13
|
|
Messung_Qmin_Periodendauermessung = 14
|
|
|
|
Fertig = 15
|
|
End Enum
|
|
|
|
|
|
Private Sub cmbDaempfung_Change()
|
|
cmbDaempfung.Enabled = False
|
|
Me.MousePointer = vbHourglass
|
|
|
|
cmbDaempfung.SelStart = 0
|
|
cmbDaempfung.SelLength = Len(cmbDaempfung.text)
|
|
|
|
Dim Wert As Integer
|
|
Wert = Val(cmbDaempfung.text)
|
|
' Dämpfung
|
|
sendonly "**0@"
|
|
sendonly Trim(Wert & "T")
|
|
|
|
PrintStatus "Dämpfung " & Wert
|
|
|
|
cmbDaempfung.Enabled = True
|
|
Me.MousePointer = vbNormal
|
|
cmbDaempfung.SetFocus
|
|
End Sub
|
|
|
|
Private Sub cmbDaempfung_Click()
|
|
cmbDaempfung_Change
|
|
End Sub
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Private Sub cmdCancel_Click()
|
|
If g_Abbruch Then Unload Me
|
|
' aktuellen Schritt abbrechen
|
|
m_blnAbbruch = True
|
|
' und dann verlassen des Ablaufes
|
|
g_Abbruch = True
|
|
End Sub
|
|
|
|
Private Sub cmdSchrittAbbruch_Click()
|
|
m_blnAbbruch = True
|
|
End Sub
|
|
|
|
'Private Sub cmdTestSpeichern_Click()
|
|
'
|
|
'
|
|
' m_Messdaten(1).Ergebniss_Fehler_Oeffnen = 1.4
|
|
' m_Messdaten(2).Ergebniss_Fehler_Oeffnen = -1.4
|
|
'
|
|
' m_Messdaten(1).Durchfluss_Oeffnen = 1.3
|
|
' m_Messdaten(2).Durchfluss_Oeffnen = 1.3
|
|
'
|
|
' m_Messdaten(1).Durchfluss_Schliessen = 2.1
|
|
' m_Messdaten(2).Durchfluss_Schliessen = 2.1
|
|
'
|
|
' m_Messdaten(1).Ergebniss_Fehler_Schliessen = 0.5
|
|
' m_Messdaten(2).Ergebniss_Fehler_Schliessen = -0.5
|
|
'
|
|
' m_Messdaten(1).Ergebniss_Fehler_Qmin = -1.2
|
|
' m_Messdaten(2).Ergebniss_Fehler_Qmin = 1.2
|
|
'
|
|
' m_Messdaten(1).Ergebniss_Fehler_Qmax = 1.1
|
|
' m_Messdaten(2).Ergebniss_Fehler_Qmax = -1.1
|
|
'
|
|
' PruefdatenSpeichern
|
|
'
|
|
'End Sub
|
|
|
|
Private Sub cmdWeiter_Click()
|
|
If cmdWeiter.caption = "Beenden" Then
|
|
Unload Me
|
|
Exit Sub
|
|
Else
|
|
cmdWeiter.Enabled = False
|
|
mblnWeiter = True
|
|
End If
|
|
End Sub
|
|
|
|
Private Sub Form_Activate()
|
|
If Not m_blnActivated Then
|
|
m_blnActivated = True
|
|
|
|
|
|
If mbln_eRegister Then
|
|
InitFlexgridAblauf_eRegister
|
|
Call Ablauf_eRegister
|
|
Else
|
|
InitFlexgridAblauf
|
|
|
|
Call Ablauf
|
|
End If
|
|
|
|
End If
|
|
End Sub
|
|
|
|
|
|
Private Sub initMSFgErgebnisse()
|
|
Dim Pruefzaehler As CPruefzaehler
|
|
Dim Einbauplatz As CEinbauplatz
|
|
|
|
MSFgErgebnisse.Clear
|
|
MSFgErgebnisse.Font.Size = 10
|
|
MSFgErgebnisse.FormatString = "Fehler [%]| Qmax [m³/h]| Qoeff [m³/h]| Qschl [m³/h]| Qmin [m³/h]"
|
|
MSFgErgebnisse.Rows = 6
|
|
MSFgErgebnisse.FixedRows = 2
|
|
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
MSFgErgebnisse.TextMatrix(Einbauplatz.getNr + 1, 0) = Pruefzaehler.getAuftragPositionSerienNr.getNr
|
|
Else
|
|
MSFgErgebnisse.TextMatrix(Einbauplatz.getNr + 1, 0) = ""
|
|
End If
|
|
Next
|
|
MSFgErgebnisse.TextMatrix(5, 0) = "FG"
|
|
|
|
If m_colUniquePP.Count >= 1 Then
|
|
MSFgErgebnisse.TextMatrix(1, 1) = m_colUniquePP.Item(1).getQ
|
|
If m_colUniquePP.Count >= 2 Then
|
|
MSFgErgebnisse.TextMatrix(1, 4) = m_colUniquePP.Item(2).getQ
|
|
End If
|
|
End If
|
|
|
|
AutoSpaltenBreite MSFgErgebnisse, lblAutosize
|
|
End Sub
|
|
|
|
Private Sub AddErgebnissToMSfg(strQ As String, dblFehler1 As Double, dblFehler2 As Double, strFG As String, intSpalte As Integer)
|
|
MSFgErgebnisse.TextMatrix(1, intSpalte) = strQ
|
|
|
|
Dim Einbaulatz As CEinbauplatz
|
|
Dim Pruefzaehler As CPruefzaehler
|
|
|
|
For Each Einbaulatz In m_colEinbauplatz
|
|
Set Pruefzaehler = Einbaulatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
Select Case Einbaulatz.getNr
|
|
Case 1
|
|
MSFgErgebnisse.TextMatrix(2, intSpalte) = Format(dblFehler1, "0.00")
|
|
Case 2
|
|
MSFgErgebnisse.TextMatrix(3, intSpalte) = Format(dblFehler2, "0.00")
|
|
End Select
|
|
End If
|
|
Next
|
|
|
|
MSFgErgebnisse.TextMatrix(5, intSpalte) = strFG
|
|
AutoSpaltenBreite MSFgErgebnisse, lblAutosize
|
|
End Sub
|
|
|
|
|
|
Private Sub InitFlexgridAblauf_eRegister()
|
|
Dim Pruefpunkt As CPruefpunkt
|
|
Set Pruefpunkt = m_colUniquePP.Item(1)
|
|
|
|
msfgAblauf.Clear
|
|
msfgAblauf.Cols = 1
|
|
msfgAblauf.col = 0
|
|
msfgAblauf.CellAlignment = vbLeftJustify
|
|
|
|
msfgAblauf.Rows = 0
|
|
msfgAblauf.AddItem "Entlüften "
|
|
msfgAblauf.AddItem "eRegister Init."
|
|
msfgAblauf.AddItem "Q Öffnen "
|
|
msfgAblauf.AddItem "Q Schliessen"
|
|
msfgAblauf.AddItem "Regulieren"
|
|
msfgAblauf.AddItem "Messung Q3"
|
|
msfgAblauf.AddItem "Messung Q öffnen"
|
|
msfgAblauf.AddItem "Messung Q Schliessen"
|
|
msfgAblauf.AddItem "Messung Q = 0.150 m³/h"
|
|
msfgAblauf.AddItem "eRegister abschluss"
|
|
|
|
msfgAblauf.AddItem "fertig"
|
|
msfgAblauf.Enabled = False
|
|
|
|
AutoSpaltenBreite msfgAblauf, lblAutosize
|
|
End Sub
|
|
|
|
Private Sub InitFlexgridAblauf()
|
|
Dim Pruefpunkt As CPruefpunkt
|
|
|
|
|
|
msfgAblauf.Clear
|
|
msfgAblauf.Cols = 1
|
|
msfgAblauf.col = 0
|
|
|
|
Set Pruefpunkt = m_colUniquePP.Item(1)
|
|
|
|
msfgAblauf.CellAlignment = vbLeftJustify
|
|
|
|
msfgAblauf.Rows = 0
|
|
msfgAblauf.AddItem "Regulieren bei Qmax = " & Pruefpunkt.getQ & " m³/h" ' 0
|
|
msfgAblauf.AddItem " Impulszählung" '1
|
|
msfgAblauf.AddItem " Regulieren" '2
|
|
|
|
msfgAblauf.AddItem "Eintragen Öffnen- / Schließen " '3
|
|
|
|
msfgAblauf.AddItem "Messung bei Qmax = " & Pruefpunkt.getQ & " m³/h" '4
|
|
msfgAblauf.AddItem " Impulszählung" '5
|
|
msfgAblauf.AddItem " Periodendauermessung" '6
|
|
|
|
msfgAblauf.AddItem "Messung bei Q öffnen" '7
|
|
msfgAblauf.AddItem " Durchfluss steigend einstellen " '8
|
|
msfgAblauf.AddItem " Periodendauermessung" '9
|
|
|
|
msfgAblauf.AddItem "Messung bei Q schliessen" '10
|
|
msfgAblauf.AddItem " Durchfluss fallend einstellen " '11
|
|
msfgAblauf.AddItem " Periodendauermessung" '12
|
|
|
|
Set Pruefpunkt = m_colUniquePP.Item(2)
|
|
msfgAblauf.AddItem "Messung bei Q min = " & Pruefpunkt.getQ & " m³/h" '13
|
|
msfgAblauf.AddItem " Periodendauermessung" '14
|
|
|
|
msfgAblauf.AddItem "fertig" '15
|
|
msfgAblauf.Enabled = False
|
|
|
|
AutoSpaltenBreite msfgAblauf, lblAutosize
|
|
End Sub
|
|
|
|
|
|
|
|
Private Sub Form_Load()
|
|
Me.WindowState = vbMaximized
|
|
centerFormInScreen Me
|
|
|
|
|
|
m_blnAbbruch = False
|
|
|
|
|
|
initMSFgErgebnisse
|
|
|
|
Set m_SPS = g_App.getSPS
|
|
Set m_FMBus = g_App.getFMBus
|
|
Set m_ColPumpen = g_App.Settings.getPumpen
|
|
|
|
cmbDaempfung.Enabled = False
|
|
cmbDaempfung.Clear
|
|
Dim i As Integer
|
|
For i = 1 To 9
|
|
cmbDaempfung.AddItem i
|
|
Next
|
|
|
|
|
|
cmdWeiter.Enabled = False
|
|
|
|
If Not g_ohneSPS Then
|
|
m_SPS.setBetrieb 0
|
|
End If
|
|
|
|
Dim Einbauplatz As CEinbauplatz
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
If Not Einbauplatz.getPruefzaehler Is Nothing Then
|
|
Set m_ersterPruefzaehler = Einbauplatz.getPruefzaehler
|
|
Exit For
|
|
End If
|
|
Next
|
|
|
|
|
|
|
|
'm_blnSimulation = True
|
|
End Sub
|
|
|
|
Private Sub UpdateFlexgridMessung_eReg(Optional blnClear As Boolean = False)
|
|
Dim Einbauplatz As CEinbauplatz
|
|
Dim Pruefzaehler As CPruefzaehler
|
|
Dim VerbundzaehlerIndex As Integer
|
|
Dim Spalte_HZ As Integer
|
|
Dim Spalte_NZ As Integer
|
|
|
|
If blnClear Then
|
|
MSFlexgridMessung.Clear
|
|
End If
|
|
|
|
MSFlexgridMessung.Rows = enum_zeile.Anzahl
|
|
MSFlexgridMessung.Cols = 6
|
|
MSFlexgridMessung.FixedCols = 1
|
|
MSFlexgridMessung.FixedRows = 1
|
|
MSFlexgridMessung.FormatString = "|RZ |HZ 1|NZ 1|HZ 2|NZ 2"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile_ereg.SerienNr, enum_spalte.Ueberschrift) = "SerienNr"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile_ereg.Funkadresse, enum_spalte.Ueberschrift) = "Funkadresse"
|
|
|
|
Dim EinbauplatzNr As Integer
|
|
For EinbauplatzNr = 1 To m_colEinbauplatz.Count - 1
|
|
Set Einbauplatz = m_colEinbauplatz.Item(EinbauplatzNr)
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
|
|
If Not Pruefzaehler Is Nothing Then
|
|
MSFlexgridMessung.TextMatrix(enum_zeile_ereg.SerienNr, Einbauplatz.getNr + 1) = Pruefzaehler.getSerienNr
|
|
MSFlexgridMessung.TextMatrix(enum_zeile_ereg.Funkadresse, Einbauplatz.getNr + 1) = Einbauplatz.eRegister.m_sRadioAdressFinal
|
|
|
|
|
|
End If
|
|
Next
|
|
|
|
AutoSpaltenBreite MSFlexgridMessung, lblAutosize
|
|
' For VerbundzaehlerIndex = 1 To 2
|
|
' Select Case VerbundzaehlerIndex
|
|
' Case 1
|
|
' Spalte_HZ = enum_spalte.HZ1
|
|
' Spalte_NZ = enum_spalte.NZ1
|
|
' Case 2
|
|
' Spalte_HZ = enum_spalte.HZ2
|
|
' Spalte_NZ = enum_spalte.NZ2
|
|
' End Select
|
|
'
|
|
'
|
|
' Set Einbauplatz = m_colEinbauplatz(VerbundzaehlerIndex)
|
|
' Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
' If Not Pruefzaehler Is Nothing Then
|
|
' ' SerienNr HZ
|
|
' MSFlexgridMessung.TextMatrix(enum_zeile_ereg.SerienNr, Spalte_HZ) = Pruefzaehler.getSerienNr
|
|
' MSFlexgridMessung.TextMatrix(enum_zeile_ereg.Funkadresse, Spalte_HZ) = Einbauplatz.eRegister.m_sRadioAdressFinal
|
|
' End If
|
|
'
|
|
'
|
|
' Next
|
|
|
|
End Sub
|
|
|
|
Private Sub UpdateFlexgridMessung(Optional blnClear As Boolean = False)
|
|
Dim Einbauplatz As CEinbauplatz
|
|
Dim Pruefzaehler As CPruefzaehler
|
|
Dim VerbundzaehlerIndex As Integer
|
|
Dim Spalte_HZ As Integer
|
|
Dim Spalte_NZ As Integer
|
|
|
|
If blnClear Then
|
|
MSFlexgridMessung.Clear
|
|
End If
|
|
|
|
MSFlexgridMessung.Rows = enum_zeile.Anzahl
|
|
MSFlexgridMessung.Cols = 6
|
|
MSFlexgridMessung.FixedCols = 1
|
|
MSFlexgridMessung.FixedRows = 1
|
|
MSFlexgridMessung.FormatString = "|RZ |HZ 1|NZ 1|HZ 2|NZ 2"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Adresse, enum_spalte.Ueberschrift) = "FM85 Adresse"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.SerienNr, enum_spalte.Ueberschrift) = "SerienNr"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Impulswertigkeit, enum_spalte.Ueberschrift) = "Impulswertigkeit [1/m³]"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Impulse, enum_spalte.Ueberschrift) = "Impuls Vorwahl"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.GezaehlteImpulse, enum_spalte.Ueberschrift) = "gezählte Impulse"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.VerbleibeneImpulse, enum_spalte.Ueberschrift) = "verbleibende Impulse"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_m3, enum_spalte.Ueberschrift) = "Q [m³/h]"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Anteil, enum_spalte.Ueberschrift) = "Anteil"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Periodendauer, enum_spalte.Ueberschrift) = "Periodendauer [s/2994]"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Pruefzeit, enum_spalte.Ueberschrift) = "Prüfzeit"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Fehler, enum_spalte.Ueberschrift) = "Fehler [%]"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_HZ_NZ, enum_spalte.Ueberschrift) = "Qges HZ + NZ"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Fehler_HZ_NZ, enum_spalte.Ueberschrift) = "Fehler HZ + NZ"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Fehler_HZ_NZ, enum_spalte.Ueberschrift) = "Fehler HZ + NZ"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_Oeffnen, enum_spalte.Ueberschrift) = "Q Öffnen [m³/h]"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_Schliessen, enum_spalte.Ueberschrift) = "Q Schliessen [m³/h]"
|
|
|
|
If Not m_Refzaehler Is Nothing Then
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.SerienNr, enum_spalte.RZ) = m_Refzaehler.SerienNr
|
|
If m_DurchflussSoll > 0 Then
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Fehler, enum_spalte.RZ) = Format(m_Refzaehler.letzterFehler(m_DurchflussSoll), "0.00")
|
|
Else
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Fehler, enum_spalte.RZ) = ""
|
|
End If
|
|
End If
|
|
|
|
|
|
For VerbundzaehlerIndex = 1 To 2
|
|
Select Case VerbundzaehlerIndex
|
|
Case 1
|
|
Spalte_HZ = enum_spalte.HZ1
|
|
Spalte_NZ = enum_spalte.NZ1
|
|
Case 2
|
|
Spalte_HZ = enum_spalte.HZ2
|
|
Spalte_NZ = enum_spalte.NZ2
|
|
End Select
|
|
|
|
Set Einbauplatz = m_colEinbauplatz(VerbundzaehlerIndex)
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
' SerienNr HZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.SerienNr, Spalte_HZ) = Pruefzaehler.getSerienNr
|
|
|
|
' Kundeneigene SerienNr HZ
|
|
If Pruefzaehler.getAuftragPositionSerienNr.getKundeneigeneSerienNr <> "" Then
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.KndEigeneSNr, Spalte_HZ) = Pruefzaehler.getAuftragPositionSerienNr.getKundeneigeneSerienNr
|
|
End If
|
|
|
|
If Not Pruefzaehler.m_Verbundzaehler Is Nothing Then
|
|
|
|
|
|
' SerienNr Nebenzähler
|
|
If Pruefzaehler.m_Verbundzaehler.lngSerienNrNZ > 0 Then
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.SerienNr, Spalte_NZ) = Pruefzaehler.m_Verbundzaehler.lngSerienNrNZ
|
|
End If
|
|
|
|
' Kundeneigene SerienNr NZ
|
|
If Pruefzaehler.m_Verbundzaehler.strKundeneigeneSerienNrNZ <> "" Then
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.KndEigeneSNr, Spalte_NZ) = Pruefzaehler.m_Verbundzaehler.strKundeneigeneSerienNrNZ
|
|
End If
|
|
|
|
End If
|
|
End If
|
|
Next
|
|
|
|
AutoSpaltenBreite MSFlexgridMessung, lblAutosize
|
|
|
|
DoEvents
|
|
End Sub
|
|
|
|
|
|
Private Sub Form_Resize()
|
|
On Error Resume Next
|
|
If Me.ScaleHeight < frMain.Height + StatusBar1.Height Then Me.Height = frMain.Height + StatusBar1.Height
|
|
If Me.ScaleWidth < frMain.Width Then Me.Width = frMain.Width
|
|
|
|
frMain.Top = (Me.ScaleHeight - frMain.Height) / 2
|
|
frMain.Left = (Me.ScaleWidth - frMain.Width) / 2
|
|
|
|
|
|
' cmdWeiter.Top = Me.ScaleHeight - StatusBar1.Height - cmdWeiter.Height * 1.5
|
|
' cmdWeiter.Left = Me.ScaleWidth - cmdWeiter.Width * 1.5
|
|
End Sub
|
|
|
|
Private Sub PrintStatus(strText As String)
|
|
txtStatus.text = txtStatus.text & strText & vbCrLf
|
|
txtStatus.SelStart = Len(txtStatus.text)
|
|
DebugMsg ": " & strText
|
|
End Sub
|
|
|
|
Private Sub HighlightAblaufZeile(intIndex As Integer)
|
|
Dim i As Integer
|
|
|
|
msfgAblauf.ColWidth(0) = msfgAblauf.Width
|
|
For i = 0 To msfgAblauf.Rows - 1
|
|
msfgAblauf.RowHeight(i) = msfgAblauf.Height / msfgAblauf.Rows / 1.1
|
|
msfgAblauf.row = i
|
|
msfgAblauf.col = 0
|
|
msfgAblauf.CellFontBold = False
|
|
msfgAblauf.CellBackColor = RGB(200, 200, 200)
|
|
Next
|
|
|
|
msfgAblauf.row = intIndex
|
|
msfgAblauf.CellBackColor = vbWhite
|
|
msfgAblauf.CellFontBold = True
|
|
DoEvents
|
|
|
|
End Sub
|
|
|
|
|
|
Private Sub Ablauf_eRegister()
|
|
|
|
UpdateFlexgridMessung_eReg
|
|
|
|
|
|
MsgBox "Ablauf eRegister prüfung nicht implementiert"
|
|
|
|
End Sub
|
|
|
|
|
|
Private Sub Ablauf()
|
|
Dim lngSollPruefzeit As Long
|
|
Dim lngPruefzeitperiodendauer As Long
|
|
Dim Index As Integer
|
|
Dim Einbauplatz As CEinbauplatz
|
|
Dim Pruefzaehler As CPruefzaehler
|
|
Dim iret As Integer
|
|
|
|
m_PruefungAbbrechen = False
|
|
|
|
g_Abbruch = False
|
|
m_blnAbbruch = False
|
|
|
|
If Not g_ohneSPS Then
|
|
TestAutomatik:
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
' Test auf Automatik
|
|
If Not m_SPS.IstAutomatik Then
|
|
iret = MsgBox("Bitte SPS auf Automatik stellen!", vbOKCancel Or vbDefaultButton1)
|
|
Select Case iret
|
|
Case vbOK
|
|
GoTo TestAutomatik
|
|
Case Else
|
|
Exit Sub
|
|
End Select
|
|
End If
|
|
|
|
TestPruefbereit:
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
' Test auf Prüfbereitschaft
|
|
If Not m_SPS.IstStreckePruefbereit Then
|
|
iret = MsgBox("Bitte SPS prüfbereit machen!", vbOKCancel Or vbDefaultButton1)
|
|
Select Case iret
|
|
Case vbOK
|
|
GoTo TestPruefbereit
|
|
Case Else
|
|
Exit Sub
|
|
End Select
|
|
End If
|
|
End If
|
|
|
|
lngSollPruefzeit = g_App.Settings.GetOrSetIniWert(INISECTION, INIKEY_PRUEFZEIT_DER_IMPULSZAEHLUNG, "60")
|
|
|
|
' Neuen Prüfgang erzeugen
|
|
Set m_Pruefgang = New CPruefgang
|
|
' PruefgangNr, Datum, Prüfer, Pruefzeit und PruefstationNr werden automatisch gefüllt
|
|
|
|
m_Pruefgang.Typ = m_ersterPruefzaehler.getIdentNrObj.getTyp
|
|
m_Pruefgang.Nennweite = m_ersterPruefzaehler.getIdentNrObj.getNennweite
|
|
m_Pruefgang.Nenntemperatur = m_ersterPruefzaehler.getIdentNrObj.GetTemperatur
|
|
|
|
m_Pruefgang.LuftDruck = g_dblLuftDruck
|
|
m_Pruefgang.Lufttemperatur = g_dblLuftTemperatur
|
|
m_Pruefgang.RelativeFeuchte = g_dblLuftFeuchte
|
|
|
|
If Not g_ohneSPS Then
|
|
m_Pruefgang.Vorlauftemperatur = m_SPS.GetEinlaufTemperatur
|
|
End If
|
|
|
|
Dim Anzahl As Integer
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
Anzahl = Anzahl + 1
|
|
End If
|
|
Next
|
|
m_Pruefgang.Anzahl = Anzahl
|
|
m_Pruefgang.save
|
|
lblPruefgangNr.caption = m_Pruefgang.PruefgangNr
|
|
|
|
UpdateFlexgridMessung False
|
|
|
|
'''''''''''''''''''''''''''''''''''''''''''''''''''''
|
|
'''''' Regulieren ''''
|
|
'''''''''''''''''''''''''''''''''''''''''''''''''''''
|
|
|
|
HighlightAblaufZeile enum_Fortschritt.Regulieren_bei_QMax
|
|
|
|
Regulieren
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
|
|
'''''''''''''''''''''''''''''''''''''''''''''''''''''
|
|
'''''' Öffnen / Schliessen ermitteln ''''
|
|
'''''''''''''''''''''''''''''''''''''''''''''''''''''
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
FrameOffnenSchliessen(Einbauplatz.getNr).Visible = True
|
|
Else
|
|
FrameOffnenSchliessen(Einbauplatz.getNr).Visible = False
|
|
End If
|
|
Next
|
|
|
|
OeffnenSchliessenDurchfluss_Ermitteln
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
|
|
GoTo QoeffnenMessen
|
|
'''''''''''''''''''''''''''''''''''''''''''''''''''''
|
|
'''''' Qmax ''''
|
|
'''''''''''''''''''''''''''''''''''''''''''''''''''''
|
|
|
|
HighlightAblaufZeile enum_Fortschritt.Messung_QMax
|
|
|
|
Dim Pruefpunkt As CPruefpunkt
|
|
Set Pruefpunkt = m_colUniquePP.Item(1)
|
|
m_DurchflussSoll = Pruefpunkt.getQ
|
|
|
|
Set m_Refzaehler = New CRefzaehler
|
|
m_Refzaehler.loadForDurchfluss m_DurchflussSoll, 0
|
|
PrintStatus "Referenzzähler mit NW " & m_Refzaehler.Nennweite & " gewählt. "
|
|
SetQinSPS
|
|
WarteAufDurchflussErreicht
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
|
|
lngSollPruefzeit = g_App.Settings.GetOrSetIniWert(INISECTION, INIKEY_PRUEFZEIT_DER_IMPULSZAEHLUNG, "60")
|
|
|
|
HighlightAblaufZeile enum_Fortschritt.Messung_QMax_Impulszaehlung
|
|
Call Impulszaehlung(lngSollPruefzeit)
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
|
|
HighlightAblaufZeile enum_Fortschritt.Messung_QMax_Periodendauermessung
|
|
|
|
lngSollPruefzeit = Pruefpunkt.GetTime
|
|
m_Pruefgang.PP_Soll(1) = m_DurchflussSoll
|
|
m_Pruefgang.PP_Zeit(1) = lngSollPruefzeit
|
|
m_Pruefgang.PP_RefZSerienNr(1) = m_Refzaehler.SerienNr
|
|
|
|
Periodendauermessung lngSollPruefzeit, True, True
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
m_Pruefgang.PP_Ist(1) = m_Messdaten(1).Durchfluss_ist
|
|
m_Messdaten(1).Ergebniss_Fehler_Qmax = m_Messdaten(1).gesamtFehler
|
|
m_Messdaten(2).Ergebniss_Fehler_Qmax = m_Messdaten(2).gesamtFehler
|
|
|
|
AddErgebnissToMSfg m_DurchflussSoll & "", m_Messdaten(1).gesamtFehler, m_Messdaten(2).gesamtFehler, Pruefpunkt.getFGo & " / " & Pruefpunkt.getFGu, enum_ergbenissspalte.Qmax
|
|
|
|
'''''''''''''''''''''''''''''''''''''''''''''''''''''
|
|
'''''' Q öffnen ''''
|
|
'''''''''''''''''''''''''''''''''''''''''''''''''''''
|
|
QoeffnenMessen:
|
|
|
|
HighlightAblaufZeile enum_Fortschritt.Messung_Qoeff
|
|
Sleep 3000
|
|
|
|
If m_Messdaten(1).Durchfluss_Oeffnen > 0 Then
|
|
' erstere Einbauplatz hat Vorrang
|
|
m_DurchflussSoll = m_Messdaten(1).Durchfluss_Oeffnen
|
|
ElseIf m_Messdaten(2).Durchfluss_Oeffnen > 0 Then
|
|
m_DurchflussSoll = m_Messdaten(1).Durchfluss_Oeffnen
|
|
Else
|
|
GoTo MessungInQOeffnenUberspringen
|
|
End If
|
|
|
|
Set m_Refzaehler = New CRefzaehler
|
|
m_Refzaehler.loadForDurchfluss m_DurchflussSoll, 0
|
|
PrintStatus "Referenzzähler mit NW " & m_Refzaehler.Nennweite & " gewählt. "
|
|
SetQinSPS
|
|
|
|
For Index = 1 To 5
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Anteil, Index) = ""
|
|
Next
|
|
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
m_Messdaten(Einbauplatz.getNr).Anteil_HZ = 1
|
|
m_Messdaten(Einbauplatz.getNr).Anteil_NZ = 0
|
|
End If
|
|
Next
|
|
|
|
HighlightAblaufZeile enum_Fortschritt.Messung_Qoeff_Durchfluss_einstellen
|
|
' Durchfluss treppenfoermig fallend anfahren
|
|
DurchflussTreppenfoermigAnfahren True
|
|
|
|
m_SPS.SetQSoll m_DurchflussSoll
|
|
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
|
|
HighlightAblaufZeile enum_Fortschritt.Messung_Qoeff_Periodendauermessung
|
|
|
|
|
|
m_Messdaten(1).MaxErlaubteAnzahlVonImpulsen_NZ = g_App.Settings.GetOrSetIniWert(INISECTION, INIKEY_MAX_IMPULSE_NZ, "4")
|
|
m_Messdaten(1).MaxErlaubteAnzahlVonImpulsen_HZ = -1
|
|
m_Messdaten(2).MaxErlaubteAnzahlVonImpulsen_NZ = g_App.Settings.GetOrSetIniWert(INISECTION, INIKEY_MAX_IMPULSE_NZ, "4")
|
|
m_Messdaten(2).MaxErlaubteAnzahlVonImpulsen_HZ = -1
|
|
m_Messdaten(1).MessungAbbrechenNachSekunden = 30
|
|
m_Messdaten(2).MessungAbbrechenNachSekunden = 30
|
|
m_Messdaten(1).Anteil_HZ = 1
|
|
m_Messdaten(2).Anteil_HZ = 1
|
|
|
|
Call Periodendauermessung(lngSollPruefzeit, True, False)
|
|
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
If m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_NZ > m_Messdaten(Einbauplatz.getNr).MaxErlaubteAnzahlVonImpulsen_NZ Then
|
|
MsgBox "Zuviele Impulse (" & m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_NZ & ") am Einbauplatz vom Nebenzähler am Einbauplatz " & Einbauplatz.getNr & ". Prüfung wird abgebrochen."
|
|
GoTo PruefungsAbbruch
|
|
End If
|
|
End If
|
|
Next
|
|
|
|
|
|
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
m_Messdaten(1).Ergebniss_Fehler_Oeffnen = m_Messdaten(1).gesamtFehler
|
|
m_Messdaten(2).Ergebniss_Fehler_Oeffnen = m_Messdaten(2).gesamtFehler
|
|
AddErgebnissToMSfg m_DurchflussSoll & "", m_Messdaten(1).gesamtFehler, m_Messdaten(2).gesamtFehler, "1,5 / -1,5", enum_ergbenissspalte.Qoeff
|
|
|
|
MessungInQOeffnenUberspringen:
|
|
|
|
If Not g_ohneSPS Then
|
|
m_SPS.SetQSoll 0
|
|
m_SPS.setBetrieb 8
|
|
Sleep 500, True
|
|
m_SPS.setBetrieb 0
|
|
End If
|
|
|
|
'''''''''''''''''''''''''''''''''''''''''''''''''''''
|
|
'''''' Q schliessen ''''
|
|
'''''''''''''''''''''''''''''''''''''''''''''''''''''
|
|
HighlightAblaufZeile enum_Fortschritt.Messung_Qschl
|
|
|
|
Sleep 3000, True
|
|
HighlightAblaufZeile enum_Fortschritt.Messung_Qschl_Durchfluss_einstellen
|
|
|
|
' Durchfluss treppenfoermig fallend anfahren
|
|
If m_Messdaten(1).Durchfluss_Schliessen > 0 Then
|
|
m_DurchflussSoll = m_Messdaten(1).Durchfluss_Schliessen
|
|
ElseIf m_Messdaten(2).Durchfluss_Schliessen > 0 Then
|
|
m_DurchflussSoll = m_Messdaten(2).Durchfluss_Schliessen
|
|
End If
|
|
DurchflussTreppenfoermigAnfahren False
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
|
|
If m_Messdaten(1).Durchfluss_Schliessen > 0 Then
|
|
' erstere Einbauplatz hat Vorrang
|
|
m_DurchflussSoll = m_Messdaten(1).Durchfluss_Schliessen
|
|
ElseIf m_Messdaten(2).Durchfluss_Schliessen > 0 Then
|
|
m_DurchflussSoll = m_Messdaten(1).Durchfluss_Schliessen
|
|
Else
|
|
MsgBox "beide Durchfluss_Schliessen = 0 ==> Messung Schliessen ueberspringen"
|
|
GoTo MessungSchliessenUeberspringen
|
|
End If
|
|
|
|
Set m_Refzaehler = New CRefzaehler
|
|
m_Refzaehler.loadForDurchfluss m_DurchflussSoll, 0
|
|
PrintStatus "Referenzzähler mit NW " & m_Refzaehler.Nennweite & " gewählt. "
|
|
SetQinSPS
|
|
WarteAufDurchflussErreicht
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
|
|
Dim lngPruefzeit As Long
|
|
lngPruefzeit = g_App.Settings.GetOrSetIniWert(INISECTION, "Q_Schliessen_Pruefzeit", "60")
|
|
|
|
For Index = 1 To 5
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Anteil, Index) = ""
|
|
Next
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
m_Messdaten(Einbauplatz.getNr).Anteil_HZ = 0
|
|
m_Messdaten(Einbauplatz.getNr).Anteil_NZ = 1
|
|
End If
|
|
Next
|
|
|
|
HighlightAblaufZeile enum_Fortschritt.Messung_Qschl_Periodendauermessung
|
|
|
|
m_Messdaten(1).MaxErlaubteAnzahlVonImpulsen_HZ = g_App.Settings.GetOrSetIniWert(INISECTION, INIKEY_MAX_IMPULSE_HZ, "4")
|
|
|
|
Call Periodendauermessung(lngPruefzeit, False, True)
|
|
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
If m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_HZ > m_Messdaten(Einbauplatz.getNr).MaxErlaubteAnzahlVonImpulsen_HZ Then
|
|
MsgBox "Zuviele Impulse (" & m_Messdaten(Einbauplatz.getNr).Impulswertigkeit_HZ & ") am Einbauplatz vom Hauptzähler am Einbauplatz " & Einbauplatz.getNr & ". Prüfung wird abgebrochen."
|
|
GoTo PruefungsAbbruch
|
|
End If
|
|
End If
|
|
Next
|
|
m_Messdaten(Einbauplatz.getNr).MaxErlaubteAnzahlVonImpulsen_HZ = 0
|
|
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
|
|
|
|
m_Messdaten(1).Ergebniss_Fehler_Schliessen = m_Messdaten(1).gesamtFehler
|
|
m_Messdaten(2).Ergebniss_Fehler_Schliessen = m_Messdaten(2).gesamtFehler
|
|
AddErgebnissToMSfg m_DurchflussSoll & "", m_Messdaten(1).gesamtFehler, m_Messdaten(2).gesamtFehler, "1,5 / -1,5", enum_ergbenissspalte.Qschl
|
|
|
|
MessungSchliessenUeberspringen:
|
|
If Not g_ohneSPS Then
|
|
m_SPS.SetQSoll 0
|
|
m_SPS.setBetrieb 0
|
|
End If
|
|
|
|
cmdWeiter.caption = "Weiter mit Qmin"
|
|
cmdWeiter.Enabled = True
|
|
Do
|
|
Sleep 100, True
|
|
Loop While Not mblnWeiter
|
|
cmdWeiter.Enabled = False
|
|
|
|
'''''''''''''''''''''''''''''''''''''''''''''''''''''
|
|
'''''' Q min ''''
|
|
'''''''''''''''''''''''''''''''''''''''''''''''''''''
|
|
HighlightAblaufZeile enum_Fortschritt.Messung_Qmin
|
|
|
|
Set Pruefpunkt = m_colUniquePP.Item(2)
|
|
m_DurchflussSoll = Pruefpunkt.getQ
|
|
|
|
Set m_Refzaehler = New CRefzaehler
|
|
m_Refzaehler.loadForDurchfluss m_DurchflussSoll, 0
|
|
PrintStatus "Referenzzähler mit NW " & m_Refzaehler.Nennweite & " gewählt. "
|
|
SetQinSPS
|
|
WarteAufDurchflussErreicht
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
|
|
HighlightAblaufZeile enum_Fortschritt.Messung_Qmin_Periodendauermessung
|
|
|
|
lngPruefzeit = Pruefpunkt.GetTime
|
|
lblPruefzeitSoll.caption = lngPruefzeit
|
|
|
|
m_Pruefgang.PP_Soll(2) = m_DurchflussSoll
|
|
m_Pruefgang.PP_Zeit(2) = lngPruefzeit
|
|
Call Periodendauermessung(lngPruefzeit, False, True)
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
m_Messdaten(1).Ergebniss_Fehler_Qmin = m_Messdaten(1).gesamtFehler
|
|
m_Messdaten(2).Ergebniss_Fehler_Qmin = m_Messdaten(2).gesamtFehler
|
|
m_Pruefgang.PP_RefZSerienNr(2) = m_Refzaehler.SerienNr
|
|
|
|
If m_Messdaten(1).Durchfluss_ist > 0 Then
|
|
m_Pruefgang.PP_Ist(2) = m_Messdaten(1).Durchfluss_ist
|
|
ElseIf m_Messdaten(2).Durchfluss_ist > 0 Then
|
|
m_Pruefgang.PP_Ist(2) = m_Messdaten(2).Durchfluss_ist
|
|
End If
|
|
|
|
AddErgebnissToMSfg m_DurchflussSoll & "", m_Messdaten(1).gesamtFehler, m_Messdaten(2).gesamtFehler, Pruefpunkt.getFGo & " / " & Pruefpunkt.getFGu, enum_ergbenissspalte.Qmin
|
|
|
|
If Not g_ohneSPS Then
|
|
m_SPS.SetQSoll 0
|
|
m_SPS.setBetrieb 0
|
|
End If
|
|
|
|
HighlightAblaufZeile enum_Fortschritt.Fertig
|
|
|
|
If g_Abbruch Then GoTo PruefungsAbbruch
|
|
PruefdatenSpeichern
|
|
m_Pruefgang.save
|
|
PrintStatus "Prüfdaten wurden gespeichert. Fertig!"
|
|
|
|
cmdWeiter.caption = "Beenden"
|
|
cmdWeiter.Enabled = True
|
|
|
|
Exit Sub
|
|
PruefungsAbbruch:
|
|
|
|
If Not g_ohneSPS Then
|
|
m_SPS.SetQSoll 0
|
|
m_SPS.setBetrieb 0
|
|
End If
|
|
Unload Me
|
|
End Sub
|
|
|
|
|
|
|
|
Private Sub DurchflussTreppenfoermigAnfahren(blnSteigend As Boolean)
|
|
Dim dblQ As Double
|
|
Dim dblProzentwertStart As Double
|
|
Dim dblProzentwert As Double
|
|
Dim dblZeit_s As Double
|
|
Dim dblDauer_s As Double
|
|
Dim dblDauer_normiert As Double
|
|
Dim dblSpeed As Double
|
|
Dim lngStartZeitpunkt As Long
|
|
Dim dblQ_Ziel As Double
|
|
|
|
m_blnAbbruch = False
|
|
|
|
If Not g_ohneSPS Then
|
|
' Betrieb Start zurücksetzen
|
|
m_SPS.setBetrieb 8
|
|
m_SPS.SetQSoll 0
|
|
Sleep 500
|
|
m_SPS.setBetrieb 0
|
|
Sleep 2000, True
|
|
End If
|
|
|
|
' Dauer der Treppe in Sekunden
|
|
dblDauer_s = g_App.Settings.GetOrSetIniWert(INISECTION, "Treppendauer_s", "60")
|
|
dblQ_Ziel = m_DurchflussSoll
|
|
|
|
' Startwert in Prozent
|
|
If blnSteigend Then
|
|
dblProzentwertStart = Val(g_App.Settings.GetOrSetIniWert(INISECTION, "Q_steigend_start_Prozent", "50"))
|
|
If dblProzentwertStart < 0 Or dblProzentwertStart > 200 Then
|
|
MsgBox "falscher Wert für Q_steigend_start_Prozent=" & dblProzentwertStart
|
|
dblProzentwertStart = 50
|
|
End If
|
|
Else
|
|
' fallend
|
|
dblProzentwertStart = Val(g_App.Settings.GetOrSetIniWert(INISECTION, "Q_fallend_start_Prozent", "250"))
|
|
If dblProzentwertStart < 0 Or dblProzentwertStart > 300 Then
|
|
MsgBox "falscher Wert für Q_steigend_start_Prozent=" & dblProzentwertStart
|
|
dblProzentwertStart = 250
|
|
End If
|
|
End If
|
|
|
|
PrintStatus "Durchfluss " & Format(m_DurchflussSoll, "0.000") & "m³/h treppenförmig von " & dblProzentwertStart & "% auf 100% in " & dblDauer_s & " s " & IIf(blnSteigend, "steigend", "fallend") & " anfahren"
|
|
m_DurchflussSoll = (dblProzentwertStart / 100) * dblQ_Ziel
|
|
PrintStatus "Startwert " & Format(m_DurchflussSoll, "0.000") & "m³/h einstellen."
|
|
lblQsoll.caption = Format(m_DurchflussSoll, "0.000")
|
|
|
|
SetQinSPS
|
|
|
|
WarteAufDurchflussErreicht
|
|
|
|
lngStartZeitpunkt = GetTickCount()
|
|
dblProzentwert = dblProzentwertStart
|
|
dblSpeed = (100 - dblProzentwertStart) / dblDauer_s ' in Prozent pro s
|
|
|
|
Do
|
|
' Treppenintervall
|
|
dblZeit_s = (GetTickCount() - lngStartZeitpunkt) / 1000
|
|
|
|
dblDauer_normiert = dblZeit_s / dblDauer_s
|
|
If dblDauer_normiert < 1 And dblDauer_normiert >= 0 Then
|
|
ProgressBar1.Visible = True
|
|
ProgressBar1.Max = 100
|
|
ProgressBar1.value = dblDauer_normiert * 100
|
|
End If
|
|
|
|
dblProzentwert = dblProzentwertStart + dblSpeed * dblZeit_s
|
|
Sleep 1000, True
|
|
|
|
dblQ = (dblProzentwert / 100) * dblQ_Ziel
|
|
lblQsoll.caption = Format(dblQ, "0.000")
|
|
PrintStatus "Q=" & Format(dblQ, "0.000") & " : " & Format(dblZeit_s, "0.0 /s")
|
|
|
|
If Not g_ohneSPS Then
|
|
m_SPS.SetQSoll dblQ
|
|
End If
|
|
|
|
UpdateQist
|
|
|
|
DoEvents
|
|
|
|
If m_blnAbbruch Then Exit Do
|
|
|
|
If blnSteigend Then
|
|
If dblProzentwert >= 100 Then Exit Do
|
|
Else
|
|
If dblProzentwert <= 100 Then Exit Do
|
|
End If
|
|
Loop While True
|
|
|
|
m_DurchflussSoll = dblQ_Ziel
|
|
' Ziel erreicht
|
|
WarteAufDurchflussErreicht
|
|
ProgressBar1.Visible = False
|
|
|
|
End Sub
|
|
|
|
Private Sub UpdateQist()
|
|
If g_ohneSPS Then
|
|
Exit Sub
|
|
End If
|
|
|
|
lblQIst.caption = Format(m_SPS.getQIst, "0.0000")
|
|
|
|
If m_SPS.SolldurchflussErreicht Then
|
|
lblQIst.BackColor = vbGreen
|
|
Else
|
|
lblQIst.BackColor = vbYellow
|
|
End If
|
|
End Sub
|
|
|
|
|
|
Private Sub Regulieren()
|
|
Dim Einbauplatz As CEinbauplatz
|
|
Dim EinbauplatzNr As Integer
|
|
Dim Pruefzaehler As CPruefzaehler
|
|
Dim lngSollPruefzeit As Long
|
|
|
|
HighlightAblaufZeile enum_Fortschritt.Regulieren_bei_QMax
|
|
|
|
m_blnAbbruch = False
|
|
|
|
m_DurchflussSoll = m_colUniquePP.Item(1).getQ
|
|
lblQsoll.caption = m_DurchflussSoll
|
|
|
|
Set m_Refzaehler = New CRefzaehler
|
|
If m_Refzaehler.loadForDurchfluss(m_DurchflussSoll, 0) = False Then
|
|
MsgBox "Kein Referenzzähler für Durchfluss " & m_DurchflussSoll
|
|
Exit Sub
|
|
End If
|
|
PrintStatus "Referenzzähler mit NW " & m_Refzaehler.Nennweite & " gewählt. "
|
|
|
|
SetQinSPS
|
|
|
|
WarteAufDurchflussErreicht
|
|
PrintStatus "Solldurchfluss erreicht"
|
|
|
|
|
|
''''''''''''''''''''''''''''
|
|
' Impulszählung
|
|
''''''''''''''''''''''''''''
|
|
' todo aus Ini
|
|
m_Messdaten(1).FM85Adresse_RZ = 1
|
|
m_Messdaten(1).FM85Adresse_HZ = 1
|
|
m_Messdaten(1).FM85Adresse_NZ = 2
|
|
m_Messdaten(2).FM85Adresse_RZ = 3
|
|
m_Messdaten(2).FM85Adresse_HZ = 3
|
|
m_Messdaten(2).FM85Adresse_NZ = 4
|
|
|
|
' Referenzzähler Daten anzeigen
|
|
UpdateFlexgridMessung False ' ohne Clear
|
|
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
EinbauplatzNr = Einbauplatz.getNr
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
m_Messdaten(EinbauplatzNr).Impulswertigkeit_HZ = Einbauplatz.getPruefzaehler.GetImpulseQM
|
|
m_Messdaten(EinbauplatzNr).Impulswertigkeit_NZ = m_lngImpulswertigkeit_NZ
|
|
m_Messdaten(EinbauplatzNr).Impulswertigkeit_RZ = m_Refzaehler.ImpulseQM
|
|
Else
|
|
m_Messdaten(EinbauplatzNr).Impulswertigkeit_HZ = 0
|
|
m_Messdaten(EinbauplatzNr).Impulswertigkeit_NZ = 0
|
|
m_Messdaten(EinbauplatzNr).Impulswertigkeit_RZ = 0
|
|
Debug.Print "Kein Zaähler am Einbauplatz " & EinbauplatzNr
|
|
End If
|
|
Next
|
|
|
|
lngSollPruefzeit = g_App.Settings.GetOrSetIniWert(INISECTION, INIKEY_PRUEFZEIT_DER_IMPULSZAEHLUNG, "60")
|
|
|
|
HighlightAblaufZeile enum_Fortschritt.Regulieren_bei_QMax_Impulszaehlung
|
|
Call Impulszaehlung(lngSollPruefzeit)
|
|
If m_blnAbbruch Then Exit Sub
|
|
|
|
PrintStatus "FM85 reset"
|
|
|
|
If Not m_blnSimulation Then
|
|
' RESET
|
|
sendonly "**0@"
|
|
sendonly "R"
|
|
Sleep 3000, True
|
|
|
|
sendonly "**0@"
|
|
sendonly "1s" ' Multiplikator
|
|
' keine Doppelimpulssprerre
|
|
sendonly "G"
|
|
' Doppelimpulssperrzeit
|
|
sendonly "0000S"
|
|
End If
|
|
|
|
' FM85 K-Wert setzen
|
|
|
|
Dim VerbundzaehlerIndex As Integer
|
|
Dim m_KWert As Double
|
|
Dim TmpStr As String
|
|
|
|
|
|
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
EinbauplatzNr = Einbauplatz.getNr
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
' K Wert berechnen
|
|
|
|
PrintStatus "mit dem HZ-Anteil " & Format(m_Messdaten(EinbauplatzNr).Anteil_HZ, "0.0000") & " korrigierte Impulswertigkeit " & m_Messdaten(EinbauplatzNr).Impulswertigkeit_HZ & " des HZ: " & m_Messdaten(EinbauplatzNr).Anteil_HZ * m_Messdaten(EinbauplatzNr).Impulswertigkeit_HZ
|
|
|
|
m_KWert = GetKWert(m_Messdaten(EinbauplatzNr).Anteil_HZ * m_Messdaten(EinbauplatzNr).Impulswertigkeit_HZ, m_Refzaehler.ImpulseQM, m_Refzaehler.letzterFehler(m_DurchflussSoll))
|
|
|
|
TmpStr = ValToKString(m_KWert)
|
|
|
|
If Not m_blnSimulation Then
|
|
sendonly "**" & m_Messdaten(EinbauplatzNr).FM85Adresse_HZ & "@"
|
|
sendonly TmpStr
|
|
End If
|
|
|
|
PrintStatus "K-Wert für FM85(" & m_Messdaten(EinbauplatzNr).FM85Adresse_HZ & ") : " & TmpStr
|
|
|
|
End If
|
|
Next
|
|
|
|
AutoSpaltenBreite MSFlexgridMessung, lblAutosize
|
|
HighlightAblaufZeile enum_Fortschritt.Regulieren_bei_QMax_Regulieren
|
|
cmbDaempfung.Enabled = True
|
|
cmbDaempfung.SetFocus
|
|
|
|
PrintStatus "Bitte jetzt manuell regulieren!"
|
|
|
|
cmdWeiter.Enabled = True
|
|
cmbDaempfung.Enabled = True
|
|
cmdWeiter.caption = "Weiter (Regulieren beenden)"
|
|
''' lstAblauf.ListIndex = 2
|
|
Do While Not mblnWeiter
|
|
Sleep 100, True
|
|
Loop
|
|
|
|
cmbDaempfung.Enabled = False
|
|
|
|
PrintStatus "Regulieren beendet!"
|
|
|
|
End Sub
|
|
|
|
Private Sub Impulszaehlung(lngZaehlzeit_s As Long)
|
|
Dim lngStartzeit As Long
|
|
Dim VerbundzaehlerIndex As Integer
|
|
Dim SpaltenIndex As Integer
|
|
|
|
m_blnAbbruch = False
|
|
|
|
Wiederholung:
|
|
On Error GoTo Errorhandler
|
|
|
|
ClearFlexgridMessung
|
|
|
|
|
|
For SpaltenIndex = 1 To 5
|
|
' neu berechnet:
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.GezaehlteImpulse, SpaltenIndex) = ""
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Anteil, SpaltenIndex) = ""
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Impulse, SpaltenIndex) = ""
|
|
Next
|
|
|
|
|
|
lblPruefzeitSoll.caption = lngZaehlzeit_s
|
|
|
|
ProgressBar1.value = 0
|
|
ProgressBar1.Max = lngZaehlzeit_s * 100
|
|
ProgressBar1.Visible = True
|
|
|
|
PrintStatus "Reset alle FM85..."
|
|
If Not m_blnSimulation Then
|
|
sendonly "**0@"
|
|
sendonly "R"
|
|
Sleep 5000
|
|
End If
|
|
|
|
PrintStatus "FM85 Impulszählung für alle FM85 Eingänge starten..."
|
|
If Not m_blnSimulation Then
|
|
sendonly "**0@"
|
|
' todo Auswahl Version 9 oder Version 10
|
|
'sendonly "o"
|
|
' PZ Eingang
|
|
sendonly "Q"
|
|
' RZ Eingang
|
|
sendonly "O"
|
|
End If
|
|
|
|
PrintStatus "Impulszählung läuft " & lngZaehlzeit_s & " sec"
|
|
lngStartzeit = GetTickCount()
|
|
Do
|
|
If Not g_ohneSPS Then
|
|
UpdateQist
|
|
End If
|
|
|
|
If m_blnAbbruch Then
|
|
Exit Do
|
|
End If
|
|
|
|
m_dblPruefzeit_s = (GetTickCount() - lngStartzeit) / 1000
|
|
|
|
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Pruefzeit, enum_spalte.RZ) = Format(m_dblPruefzeit_s, "0")
|
|
|
|
If m_dblPruefzeit_s <> 0 Then
|
|
For VerbundzaehlerIndex = 1 To 2
|
|
' Haupzähler
|
|
If m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_HZ > 0 Then
|
|
' gezaehlte Impulse für HZ auslesen und darstellen
|
|
If m_blnSimulation Then
|
|
m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_HZ = 838 * m_dblPruefzeit_s / lngZaehlzeit_s
|
|
Else
|
|
m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_HZ = GetHexZahlFromFM85(m_Messdaten(VerbundzaehlerIndex).FM85Adresse_HZ, "U")
|
|
End If
|
|
End If
|
|
|
|
' Nebenzaehler
|
|
If m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_NZ > 0 Then
|
|
' gezaehlte Impulse für NZ auslesen und darstellen
|
|
If m_blnSimulation Then
|
|
m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_NZ = 154 * m_dblPruefzeit_s / lngZaehlzeit_s
|
|
Else
|
|
m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_NZ = GetHexZahlFromFM85(m_Messdaten(VerbundzaehlerIndex).FM85Adresse_NZ, "U")
|
|
End If
|
|
End If
|
|
|
|
If m_blnSimulation Then
|
|
m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_RZ = 1690 * m_dblPruefzeit_s / lngZaehlzeit_s
|
|
Else
|
|
' Referenzzähler
|
|
m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_RZ = GetHexZahlFromFM85(m_Messdaten(VerbundzaehlerIndex).FM85Adresse_RZ, "L")
|
|
End If
|
|
|
|
AktualisiereDatenFuerImpulszaehlung VerbundzaehlerIndex
|
|
|
|
If m_blnAbbruch Then
|
|
PrintStatus "Impulszählung abgebrochen"
|
|
Exit Sub
|
|
End If
|
|
Next
|
|
|
|
|
|
End If
|
|
|
|
If m_dblPruefzeit_s < lngZaehlzeit_s Then
|
|
ProgressBar1.Visible = True
|
|
ProgressBar1.value = m_dblPruefzeit_s * 100
|
|
End If
|
|
|
|
DoEvents
|
|
AutoSpaltenBreite MSFlexgridMessung, lblAutosize
|
|
|
|
Loop While lngStartzeit + 1000 * lngZaehlzeit_s > GetTickCount And m_blnAbbruch = False
|
|
|
|
|
|
' todo
|
|
'' ' Impulse für alle FM85 zwischenspeichern
|
|
'' sendonly "**0@"
|
|
'' sendonly "q"
|
|
m_dblPruefzeit_s = (GetTickCount - lngStartzeit) / 1000
|
|
|
|
|
|
For VerbundzaehlerIndex = 1 To 2
|
|
' Endgültige Ergebnisse auslesen
|
|
If m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_HZ > 0 Then
|
|
|
|
' gezaehlte Impulse für HZ auslesen und darstellen
|
|
If m_blnSimulation Then
|
|
m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_HZ = 838 * m_dblPruefzeit_s / lngZaehlzeit_s
|
|
Else
|
|
m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_HZ = GetHexZahlFromFM85(m_Messdaten(VerbundzaehlerIndex).FM85Adresse_HZ, "U")
|
|
End If
|
|
End If
|
|
|
|
' Nebenzaehler
|
|
If m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_NZ > 0 Then
|
|
' gezaehlte Impulse für NZ auslesen und darstellen
|
|
If m_blnSimulation Then
|
|
m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_NZ = 154 * m_dblPruefzeit_s / lngZaehlzeit_s
|
|
Else
|
|
m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_NZ = GetHexZahlFromFM85(m_Messdaten(VerbundzaehlerIndex).FM85Adresse_NZ, "U")
|
|
End If
|
|
End If
|
|
|
|
If m_blnSimulation Then
|
|
m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_RZ = 1690 * m_dblPruefzeit_s / lngZaehlzeit_s
|
|
Else
|
|
' Referenzzähler
|
|
m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_RZ = GetHexZahlFromFM85(m_Messdaten(VerbundzaehlerIndex).FM85Adresse_RZ, "L")
|
|
End If
|
|
AktualisiereDatenFuerImpulszaehlung VerbundzaehlerIndex
|
|
Next
|
|
PrintStatus "Impulszählung beendet."
|
|
ProgressBar1.Visible = False
|
|
Exit Sub
|
|
Errorhandler:
|
|
Dim errdesc As String
|
|
Dim errnum As Long
|
|
Dim ret As Long
|
|
|
|
errdesc = Err.Description
|
|
errnum = Err.Number
|
|
Err.Clear
|
|
|
|
ret = MsgBox("Fehler " & errnum & " in Impulszählung: " & errdesc)
|
|
Exit Sub
|
|
Resume
|
|
End Sub
|
|
|
|
Private Sub AktualisiereDatenFuerImpulszaehlung(VerbundzaehlerIndex As Integer)
|
|
Dim Spalte_HZ As Integer
|
|
Dim Spalte_NZ As Integer
|
|
|
|
Select Case VerbundzaehlerIndex
|
|
Case 1
|
|
Spalte_HZ = enum_spalte.HZ1
|
|
Spalte_NZ = enum_spalte.NZ1
|
|
Case 2
|
|
Spalte_HZ = enum_spalte.HZ2
|
|
Spalte_NZ = enum_spalte.NZ2
|
|
End Select
|
|
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Adresse, Spalte_HZ) = m_Messdaten(VerbundzaehlerIndex).FM85Adresse_HZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Adresse, Spalte_NZ) = m_Messdaten(VerbundzaehlerIndex).FM85Adresse_NZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Adresse, enum_spalte.RZ) = m_Messdaten(VerbundzaehlerIndex).FM85Adresse_RZ
|
|
|
|
If m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_HZ > 0 Then
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Impulswertigkeit, Spalte_HZ) = m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_HZ
|
|
End If
|
|
If m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_NZ > 0 Then
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Impulswertigkeit, Spalte_NZ) = m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_NZ
|
|
End If
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Impulswertigkeit, enum_spalte.RZ) = m_Refzaehler.ImpulseQM
|
|
|
|
If m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_HZ > 0 And m_dblPruefzeit_s <> 0 Then
|
|
' HZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.GezaehlteImpulse, Spalte_HZ) = m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_HZ
|
|
' Durchfluss für HZ m³/h = Impulse / [Impulse/m³] / h
|
|
m_Messdaten(VerbundzaehlerIndex).Durchfluss_HZ = (m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_HZ / m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_HZ) / (m_dblPruefzeit_s / 3600)
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_m3, Spalte_HZ) = Format(m_Messdaten(VerbundzaehlerIndex).Durchfluss_HZ, "0.000")
|
|
End If
|
|
|
|
If m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_NZ > 0 And m_dblPruefzeit_s <> 0 Then
|
|
' NZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.GezaehlteImpulse, Spalte_NZ) = m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_NZ
|
|
' Durchfluss für NZ m³/h = Impulse / [Impulse/m³] / h
|
|
m_Messdaten(VerbundzaehlerIndex).Durchfluss_NZ = (m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_NZ / m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_NZ) / (m_dblPruefzeit_s / 3600)
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_m3, Spalte_NZ) = Format(m_Messdaten(VerbundzaehlerIndex).Durchfluss_NZ, "0.000")
|
|
End If
|
|
|
|
If m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_RZ <> 0 And m_dblPruefzeit_s <> 0 Then
|
|
' Referenzzähler
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.GezaehlteImpulse, enum_spalte.RZ) = m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_RZ
|
|
' Durchfluss für RZ
|
|
m_Messdaten(VerbundzaehlerIndex).Durchfluss_RZ = (m_Messdaten(VerbundzaehlerIndex).gezaehlteImpulse_RZ / m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_RZ) / (m_dblPruefzeit_s / 3600)
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_m3, enum_spalte.RZ) = Format(m_Messdaten(VerbundzaehlerIndex).Durchfluss_RZ, "0.000")
|
|
End If
|
|
|
|
' Durchfluss HZ + NZ
|
|
m_Messdaten(VerbundzaehlerIndex).Durchfluss_HZ_NZ = m_Messdaten(VerbundzaehlerIndex).Durchfluss_HZ + m_Messdaten(VerbundzaehlerIndex).Durchfluss_NZ
|
|
If m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_HZ > 0 And m_Messdaten(VerbundzaehlerIndex).Impulswertigkeit_NZ > 0 Then
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_HZ_NZ, Spalte_HZ) = Format(m_Messdaten(VerbundzaehlerIndex).Durchfluss_HZ_NZ, "0.000")
|
|
End If
|
|
|
|
' Anteile errechnen und anzeigen
|
|
' HZ
|
|
If m_Messdaten(VerbundzaehlerIndex).Durchfluss_HZ_NZ > 0 And m_dblPruefzeit_s <> 0 Then
|
|
m_Messdaten(VerbundzaehlerIndex).Anteil_HZ = m_Messdaten(VerbundzaehlerIndex).Durchfluss_HZ / m_Messdaten(VerbundzaehlerIndex).Durchfluss_HZ_NZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Anteil, Spalte_HZ) = Format(m_Messdaten(VerbundzaehlerIndex).Anteil_HZ, "0.000000")
|
|
' NZ
|
|
m_Messdaten(VerbundzaehlerIndex).Anteil_NZ = m_Messdaten(VerbundzaehlerIndex).Durchfluss_NZ / m_Messdaten(VerbundzaehlerIndex).Durchfluss_HZ_NZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Anteil, Spalte_NZ) = Format(m_Messdaten(VerbundzaehlerIndex).Anteil_NZ, "0.000000")
|
|
' RZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Anteil, enum_spalte.RZ) = Format(m_Messdaten(VerbundzaehlerIndex).Anteil_HZ + m_Messdaten(VerbundzaehlerIndex).Anteil_NZ, "0.00")
|
|
End If
|
|
|
|
End Sub
|
|
|
|
Private Sub AktualisiereDatenFuerPeriodendauermessung(VerbundzaehlerIndex As Integer)
|
|
'VerbundzaehlerIndex = 1 oder 2
|
|
Dim Spalte_HZ As Integer
|
|
Dim Spalte_NZ As Integer
|
|
|
|
If m_dblPruefzeit_s <= 0 Then Exit Sub
|
|
|
|
Select Case VerbundzaehlerIndex
|
|
Case 1
|
|
Spalte_HZ = enum_spalte.HZ1
|
|
Spalte_NZ = enum_spalte.NZ1
|
|
Case 2
|
|
Spalte_HZ = enum_spalte.HZ2
|
|
Spalte_NZ = enum_spalte.NZ2
|
|
End Select
|
|
|
|
' Adresse FM 85
|
|
' Impulswertigkeit
|
|
' Anzahl der zu zählenden Impulse
|
|
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Impulse, Spalte_HZ) = m_Messdaten(VerbundzaehlerIndex).AnzahlPerioden_HZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Impulse, Spalte_NZ) = m_Messdaten(VerbundzaehlerIndex).AnzahlPerioden_NZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Impulse, enum_spalte.RZ) = m_Messdaten(VerbundzaehlerIndex).AnzahlPerioden_RZ
|
|
|
|
' verbleibende Impulse
|
|
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.VerbleibeneImpulse, Spalte_HZ) = m_Messdaten(VerbundzaehlerIndex).verbleibendeImpulse_HZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.VerbleibeneImpulse, Spalte_NZ) = m_Messdaten(VerbundzaehlerIndex).verbleibendeImpulse_NZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.VerbleibeneImpulse, enum_spalte.RZ) = m_Messdaten(VerbundzaehlerIndex).verbleibendeImpulse_RZ
|
|
|
|
' Prüfzeit
|
|
' Fehler RZ
|
|
|
|
' ************ nicht wichtig ****
|
|
' Q HZ = (ImpulseHZ - verblHZ) * ImpulswertigHZ / Pruefzeit
|
|
' Q NZ = (ImpulseNZ - verblNZ) * ImpulswertigNZ / Pruefzeit
|
|
' Q_REF =(ImpulseRZ - verblRZ) * ImpulswertigRZ / Pruefzeit
|
|
' Q_HZ_NZ = QHZ + QNZ
|
|
' (Fehler HZ_NZ = (Q_HZ_NZ - Q_REF) / Q_REF)
|
|
'***************************
|
|
|
|
|
|
|
|
End Sub
|
|
|
|
Private Sub WarteAufDurchflussErreicht()
|
|
If g_ohneSPS Then
|
|
Exit Sub
|
|
End If
|
|
|
|
Sleep 2000, True
|
|
lblQIst.BackColor = vbYellow
|
|
Do
|
|
If m_blnAbbruch Then
|
|
lblQIst.BackColor = &H8000000F
|
|
Exit Sub
|
|
End If
|
|
lblQIst.caption = Format(m_SPS.getQIst, "0.0000")
|
|
DoEvents
|
|
Loop While Not m_SPS.SolldurchflussErreicht
|
|
lblQIst.BackColor = vbGreen
|
|
End Sub
|
|
|
|
|
|
Private Sub SetQinSPS()
|
|
PrintStatus "Nächster Durchfluss: " & m_DurchflussSoll
|
|
lblQsoll.caption = Format(m_DurchflussSoll, "0.000")
|
|
|
|
If g_ohneSPS Then
|
|
Exit Sub
|
|
End If
|
|
|
|
' Betrieb Start zurücksetzen
|
|
m_SPS.setBetrieb 8
|
|
Sleep 500
|
|
m_SPS.setBetrieb 0
|
|
|
|
' Durchlauf auswählen
|
|
m_SPS.setBehaelter 1
|
|
|
|
m_SPS.SetQSoll 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
|
|
m_SPS.SetServoStellung 50
|
|
|
|
' Vorwahl Referenzzaehler
|
|
m_SPS.SetMID m_Refzaehler.EinbauplatzNr
|
|
m_SPS.SetQDiff 0
|
|
|
|
' Durchfluss starten
|
|
m_SPS.setBetrieb 2
|
|
End Sub
|
|
|
|
|
|
Private Sub sendonly(text)
|
|
m_FMBus.send (text)
|
|
m_FMBus.receive (500)
|
|
End Sub
|
|
|
|
Private Function GetHexZahlFromFM85(EinbauplatzNr As Integer, strSende As String) As Long
|
|
Dim strAntwortAdressierung As String
|
|
Dim strAntwort As String
|
|
Dim Versuche As Long
|
|
|
|
On Error GoTo Errorhandler
|
|
|
|
Versuche = 0
|
|
startagain1:
|
|
If EinbauplatzNr > 0 Then
|
|
' FM85P mit entspr. Adresse ansprechen
|
|
m_FMBus.send "**" & EinbauplatzNr & "@"
|
|
strAntwortAdressierung = m_FMBus.receive(700)
|
|
If InStr(1, strAntwortAdressierung, EinbauplatzNr) = 0 Then
|
|
PrintStatus "FM85P-" & EinbauplatzNr & " antwortete bei Adressierung '" & strAntwortAdressierung & "'"
|
|
If Versuche < 10 Then
|
|
Versuche = Versuche + 1
|
|
GoTo startagain1
|
|
End If
|
|
If EinbauplatzNr > 0 Then
|
|
LogIntoDB "FM85P-" & EinbauplatzNr & " antwortete mit '" & strAntwort & "'", "FM85 RZ Prüf"
|
|
End If
|
|
End If
|
|
End If
|
|
Versuche = 0
|
|
|
|
startagain2:
|
|
m_FMBus.send strSende
|
|
strAntwort = m_FMBus.receive(700)
|
|
|
|
If IsNumeric("&H" & strAntwort) Then
|
|
GetHexZahlFromFM85 = CLng("&H" & strAntwort)
|
|
'PrintStatus "Anwort vom FM85: " & strAntwort & " = " & GetHexZahlFromFM85
|
|
Else
|
|
If EinbauplatzNr > 0 Then
|
|
PrintStatus "FM85P-" & EinbauplatzNr & " antwortete mit '" & strAntwort & "'"
|
|
End If
|
|
|
|
If InStr(1, strAntwort, "MESSERGEBNIS LIEGT NICHT VOR") > 0 Then
|
|
GetHexZahlFromFM85 = -1
|
|
Exit Function
|
|
End If
|
|
|
|
If Versuche < 10 Then
|
|
Versuche = Versuche + 1
|
|
GoTo startagain2
|
|
End If
|
|
If EinbauplatzNr > 0 Then
|
|
LogIntoDB "FM85P-" & EinbauplatzNr & " antwortete mit '" & strAntwort & "'", "FM85 RZ Prf"
|
|
End If
|
|
GetHexZahlFromFM85 = -1
|
|
End If
|
|
Exit Function
|
|
Errorhandler:
|
|
LogIntoDB "Fehler " & Err.Number & " in GetHexZahlFromFM85 (RZ Prf):" & Err.Description, "Prg Fehler!"
|
|
GetHexZahlFromFM85 = -1
|
|
End Function
|
|
|
|
|
|
Private Sub Form_Unload(Cancel As Integer)
|
|
If MsgBox("Beenden?", vbYesNo) = vbYes Then
|
|
Cancel = False
|
|
m_blnAbbruch = True
|
|
Else
|
|
Cancel = True
|
|
End If
|
|
End Sub
|
|
|
|
|
|
Private Function GetKWert(dblImpulswertigkeitPZ As Double, dblImpulswertigkeitRZ As Double, dblletzterFehlerRZ As Double) As Double
|
|
' K Wert bestimmen
|
|
GetKWert = dblImpulswertigkeitPZ / dblImpulswertigkeitPZ
|
|
PrintStatus "PZ-Impulse/m³ = " & dblImpulswertigkeitPZ
|
|
PrintStatus "RZ-Impulse/m³ = " & dblImpulswertigkeitRZ
|
|
PrintStatus "interpolierter Fehler RZ: " & dblletzterFehlerRZ & " % "
|
|
|
|
PrintStatus "unkorrigierter K Wert: " & dblImpulswertigkeitRZ & "/" & dblImpulswertigkeitPZ & " = " & dblImpulswertigkeitRZ / dblImpulswertigkeitPZ
|
|
GetKWert = dblImpulswertigkeitRZ * (1 + dblletzterFehlerRZ / 100) / dblImpulswertigkeitPZ
|
|
PrintStatus "mit RZ Fehler korrigierter K Wert: K = K' * (1 + Frz/100) = " & GetKWert
|
|
End Function
|
|
|
|
|
|
Private Sub OeffnenSchliessenDurchfluss_Ermitteln()
|
|
Dim strTemp As String
|
|
Dim Einbauplatz As CEinbauplatz
|
|
Dim Pruefzaehler As CPruefzaehler
|
|
Dim VerbundzaehlerIndex As Integer
|
|
|
|
Dim Spalte_HZ As Integer
|
|
Dim Spalte_NZ As Integer
|
|
|
|
HighlightAblaufZeile 3
|
|
m_blnAbbruch = False
|
|
|
|
If Not g_ohneSPS Then
|
|
m_SPS.SetQSoll 0
|
|
m_SPS.setBetrieb 0
|
|
End If
|
|
|
|
m_DurchflussSoll = CDbl(g_App.Settings.GetOrSetIniWert(INISECTION, "Durchfluss_Oeffnen_Schliessen", "3,9"))
|
|
|
|
m_Refzaehler.loadForDurchfluss m_DurchflussSoll, 1
|
|
SetQinSPS
|
|
|
|
For VerbundzaehlerIndex = 1 To 2
|
|
Set Einbauplatz = m_colEinbauplatz.Item(VerbundzaehlerIndex)
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
frmOeffnenSchliessen.Enabled = True
|
|
frmOeffnenSchliessen.Visible = True
|
|
End If
|
|
Next
|
|
|
|
PrintStatus "Bitte ermitteln sie jetzt die Öffnen- und Schließen-Durchflüsse und tragen Sie sie ein!"
|
|
mblnWeiter = False
|
|
cmdWeiter.Enabled = True
|
|
cmdWeiter.caption = "Weiter (Öff/Schl eintragen)"
|
|
|
|
If txtDurchflussOeffnen(2).Visible Then
|
|
txtDurchflussOeffnen(2).SetFocus
|
|
End If
|
|
If txtDurchflussOeffnen(1).Visible Then
|
|
txtDurchflussOeffnen(1).SetFocus
|
|
End If
|
|
|
|
Do While Not mblnWeiter
|
|
If m_blnAbbruch Then Exit Sub
|
|
UpdateQist
|
|
Sleep 100, True
|
|
Loop
|
|
PrintStatus "Öffnen/Schließen Phase beendet."
|
|
|
|
|
|
''''''''''''''''' '''''''''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''''''''
|
|
''''''''''''''''' Öffnen / Schliessen Durchflüsse speichern '''''''''''''''''''''''''''''''''''
|
|
''''''''''''''''' '''''''''''''''''''''''''''''''''''''' ''''''''''''''''''''''''''''''''''''''
|
|
|
|
For VerbundzaehlerIndex = 1 To 2
|
|
Set Einbauplatz = m_colEinbauplatz.Item(VerbundzaehlerIndex)
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
Select Case VerbundzaehlerIndex
|
|
Case 1
|
|
Spalte_HZ = enum_spalte.HZ1
|
|
Spalte_NZ = enum_spalte.NZ1
|
|
Case 2
|
|
Spalte_HZ = enum_spalte.HZ2
|
|
Spalte_NZ = enum_spalte.NZ2
|
|
End Select
|
|
|
|
strTemp = Replace(txtDurchflussOeffnen(VerbundzaehlerIndex).text, ".", ",")
|
|
If IsNumeric(strTemp) Then
|
|
m_Messdaten(VerbundzaehlerIndex).Durchfluss_Oeffnen = CDbl(strTemp)
|
|
End If
|
|
|
|
strTemp = Replace(txtDurchflussSchliessen(VerbundzaehlerIndex).text, ".", ",")
|
|
If IsNumeric(strTemp) Then
|
|
m_Messdaten(VerbundzaehlerIndex).Durchfluss_Schliessen = CDbl(strTemp)
|
|
End If
|
|
|
|
' Anzeigen
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_Oeffnen, Spalte_HZ) = Format(m_Messdaten(VerbundzaehlerIndex).Durchfluss_Oeffnen, "0.000")
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_Schliessen, Spalte_HZ) = Format(m_Messdaten(VerbundzaehlerIndex).Durchfluss_Schliessen, "0.000")
|
|
|
|
If MSFgErgebnisse.TextMatrix(1, 2) = "" Then
|
|
MSFgErgebnisse.TextMatrix(1, 2) = Format(m_Messdaten(VerbundzaehlerIndex).Durchfluss_Oeffnen, "0.000")
|
|
End If
|
|
|
|
If MSFgErgebnisse.TextMatrix(1, 3) = "" Then
|
|
MSFgErgebnisse.TextMatrix(1, 3) = Format(m_Messdaten(VerbundzaehlerIndex).Durchfluss_Schliessen, "0.000")
|
|
End If
|
|
End If
|
|
Next
|
|
|
|
frmOeffnenSchliessen.Enabled = False
|
|
frmOeffnenSchliessen.Visible = False
|
|
|
|
If Not g_ohneSPS Then
|
|
m_SPS.SetQSoll 0
|
|
m_SPS.setBetrieb 0
|
|
End If
|
|
End Sub
|
|
|
|
Private Sub Periodendauermessung(lngPruefzeit_s As Long, bln_HZ_Messen As Boolean, bln_NZ_Messen As Boolean)
|
|
Dim dblPruefvolumen_m3 As Double
|
|
Dim Pruefzaehler As CPruefzaehler
|
|
Dim Einbauplatz As CEinbauplatz
|
|
Dim lngStartzeit As Long
|
|
Dim verbleibendeImpulseGesamt As Long
|
|
Dim Spalte_HZ As Integer
|
|
Dim SpaltenIndex As Integer
|
|
Dim Spalte_NZ As Integer
|
|
Dim bln_Auf_NZ_warten As Boolean
|
|
Dim intCountWiederholung As Integer
|
|
|
|
m_blnAbbruch = False
|
|
intCountWiederholung = -1
|
|
Wiederholung:
|
|
|
|
intCountWiederholung = intCountWiederholung + 1
|
|
ClearFlexgridMessung
|
|
|
|
If Not m_blnSimulation Then
|
|
PrintStatus "Reset alle FM85..."
|
|
sendonly "**0@"
|
|
sendonly "R"
|
|
Sleep 5000, True
|
|
End If
|
|
|
|
m_Messdaten(1).Durchfluss_ist = 0
|
|
m_Messdaten(2).Durchfluss_ist = 0
|
|
|
|
dblPruefvolumen_m3 = m_DurchflussSoll * lngPruefzeit_s / 3600 ' m³ = (m³/h) / (3600 s/h)
|
|
PrintStatus "Prüfvolumen " & Format(dblPruefvolumen_m3, "0.000") & " m³"
|
|
|
|
lblPruefzeitSoll = Format(lngPruefzeit_s, "0")
|
|
|
|
' Periodenzahl für alle RZ festlegen
|
|
m_Messdaten(1).AnzahlPerioden_RZ = m_Refzaehler.ImpulseQM * dblPruefvolumen_m3 ' Anteil = 1
|
|
m_Messdaten(2).AnzahlPerioden_RZ = m_Refzaehler.ImpulseQM * dblPruefvolumen_m3 ' Anteil = 1
|
|
PrintStatus "Periodendauermessung für alle RZ starten mit " & m_Messdaten(1).AnzahlPerioden_RZ & " Impulsen"
|
|
sendonly "**0@"
|
|
|
|
m_Messdaten(1).Impulswertigkeit_RZ = m_Refzaehler.ImpulseQM
|
|
m_Messdaten(2).Impulswertigkeit_RZ = m_Refzaehler.ImpulseQM
|
|
' todo: ersten Zähler (ebp 1 oder 2) verwenden
|
|
sendonly Hex(m_Messdaten(1).AnzahlPerioden_RZ) & "M"
|
|
|
|
ProgressBar1.value = 0
|
|
ProgressBar1.Max = lngPruefzeit_s * 100
|
|
ProgressBar1.Visible = True
|
|
|
|
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
|
|
m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_HZ = 0
|
|
m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_RZ = 0
|
|
m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_NZ = 0
|
|
|
|
If Not Pruefzaehler Is Nothing Then
|
|
If bln_HZ_Messen Then
|
|
If bln_NZ_Messen = False Then m_Messdaten(Einbauplatz.getNr).Anteil_HZ = 1
|
|
|
|
' für den Hauptzähler soll eine Periodendauermessung durchgeführt werden
|
|
m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_HZ = m_Messdaten(Einbauplatz.getNr).Impulswertigkeit_HZ * dblPruefvolumen_m3 * m_Messdaten(Einbauplatz.getNr).Anteil_HZ
|
|
PrintStatus "Periodendauermessung für HZ starten mit FM85-" & m_Messdaten(Einbauplatz.getNr).FM85Adresse_HZ & " mit " & m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_HZ & " Impulsen"
|
|
sendonly "**" & m_Messdaten(Einbauplatz.getNr).FM85Adresse_HZ & "@"
|
|
sendonly Hex(m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_HZ) & "H"
|
|
Else
|
|
' ggf. Impulse zählen
|
|
m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_HZ = 0
|
|
If m_Messdaten(Einbauplatz.getNr).MaxErlaubteAnzahlVonImpulsen_HZ > -1 Then
|
|
' für den Hauptzähler eine Impulszählung zur Kontrolle starten
|
|
sendonly "**" & m_Messdaten(Einbauplatz.getNr).FM85Adresse_HZ & "@"
|
|
sendonly "Q"
|
|
End If
|
|
End If
|
|
|
|
If bln_NZ_Messen Then
|
|
m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_NZ = m_Messdaten(Einbauplatz.getNr).Impulswertigkeit_NZ * dblPruefvolumen_m3 * m_Messdaten(Einbauplatz.getNr).Anteil_NZ
|
|
sendonly "**" & m_Messdaten(Einbauplatz.getNr).FM85Adresse_NZ & "@"
|
|
PrintStatus "Periodendauermessung für NZ starten mit FM85-" & m_Messdaten(Einbauplatz.getNr).FM85Adresse_NZ & " mit " & m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_NZ & " Impulsen"
|
|
sendonly Hex(m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_NZ) & "H"
|
|
Else
|
|
m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_NZ = 0
|
|
If m_Messdaten(Einbauplatz.getNr).MaxErlaubteAnzahlVonImpulsen_NZ > -1 Then
|
|
' für den Nebenzaehler eine Impulszählung zur Kontrolle starten
|
|
sendonly "**" & m_Messdaten(Einbauplatz.getNr).FM85Adresse_NZ & "@"
|
|
sendonly "Q"
|
|
End If
|
|
End If
|
|
|
|
''AktualisiereDatenFuerPeriodendauermessung (Einbauplatz.getNr)
|
|
|
|
If m_Messdaten(Einbauplatz.getNr).MaxErlaubteAnzahlVonImpulsen_HZ > -1 Or m_Messdaten(Einbauplatz.getNr).MaxErlaubteAnzahlVonImpulsen_NZ > -1 Then
|
|
AktualisiereDatenFuerImpulszaehlung Einbauplatz.getNr
|
|
End If
|
|
End If ' Not Pruefzaehler Is Nothing
|
|
Next
|
|
|
|
' Startzeit festlegen
|
|
lngStartzeit = GetTickCount()
|
|
Do
|
|
If Not g_ohneSPS Then
|
|
UpdateQist
|
|
End If
|
|
|
|
m_dblPruefzeit_s = (GetTickCount - lngStartzeit) / 1000
|
|
|
|
|
|
verbleibendeImpulseGesamt = 0
|
|
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
Select Case Einbauplatz.getNr
|
|
Case 1
|
|
Spalte_HZ = enum_spalte.HZ1
|
|
Spalte_NZ = enum_spalte.NZ1
|
|
Case 2
|
|
Spalte_HZ = enum_spalte.HZ2
|
|
Spalte_NZ = enum_spalte.NZ2
|
|
End Select
|
|
|
|
|
|
' HZ
|
|
If bln_HZ_Messen Then
|
|
' Verbleibemde Hauptzähler Impulse für Periodendauermessung ablesen
|
|
If m_blnSimulation Then
|
|
m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_HZ = m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_HZ * (lngPruefzeit_s - m_dblPruefzeit_s) / lngPruefzeit_s * m_Messdaten(Einbauplatz.getNr).Anteil_HZ
|
|
Else
|
|
m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_HZ = GetHexZahlFromFM85(m_Messdaten(Einbauplatz.getNr).FM85Adresse_HZ, "I")
|
|
End If
|
|
Else
|
|
m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_HZ = 0
|
|
If m_blnSimulation Then
|
|
m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_NZ = 1
|
|
Else
|
|
m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_HZ = GetHexZahlFromFM85(m_Messdaten(Einbauplatz.getNr).FM85Adresse_HZ, "U")
|
|
End If
|
|
' hauptzähler Impulse überwachen?
|
|
If m_Messdaten(Einbauplatz.getNr).MaxErlaubteAnzahlVonImpulsen_HZ > -1 Then
|
|
' HZ Impulse amzeigen
|
|
If m_blnSimulation Then
|
|
m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_HZ = 1
|
|
Else
|
|
m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_HZ = GetHexZahlFromFM85(m_Messdaten(Einbauplatz.getNr).FM85Adresse_HZ, "U")
|
|
End If
|
|
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.GezaehlteImpulse, Spalte_HZ) = m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_HZ
|
|
' HZ Impulse überprüfen
|
|
If m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_HZ > m_Messdaten(Einbauplatz.getNr).MaxErlaubteAnzahlVonImpulsen_HZ Then
|
|
' erst eine einstellbare Zeit nur Impulse zählen, erst dann Konsequenzen ziehen
|
|
If m_dblPruefzeit_s > m_Messdaten(Einbauplatz.getNr).MessungAbbrechenNachSekunden Then
|
|
If intCountWiederholung < 1 Then
|
|
' Periodendauermessung komplett neu starten
|
|
GoTo Wiederholung
|
|
Else
|
|
' Messung beenden
|
|
Exit Do
|
|
End If
|
|
End If
|
|
End If
|
|
End If
|
|
|
|
End If
|
|
|
|
' NZ
|
|
If bln_NZ_Messen Then
|
|
' Nebenzähler messen
|
|
If m_blnSimulation Then
|
|
m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_NZ = m_Messdaten(Einbauplatz.getNr).Impulswertigkeit_NZ * dblPruefvolumen_m3 * (lngPruefzeit_s - m_dblPruefzeit_s) / lngPruefzeit_s * m_Messdaten(Einbauplatz.getNr).Anteil_NZ
|
|
Else
|
|
m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_NZ = GetHexZahlFromFM85(m_Messdaten(Einbauplatz.getNr).FM85Adresse_NZ, "I")
|
|
End If
|
|
|
|
If m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_NZ - m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_NZ > 1 Then
|
|
' Es gab zwei Impulse vom NZ
|
|
If m_Messdaten(Einbauplatz.getNr).bln_Auf_NZ_warten = False Then
|
|
PrintStatus "Es gab 2 Impulse vom NZ " & Einbauplatz.getNr & ". Nun muss auch auf alle NZ-Impulse gewartet werden."
|
|
End If
|
|
' gezählte Impulse beim NZ >= 2 => Es läuft Wasser durch den NZ => Auf NZ Impulse warten
|
|
m_Messdaten(Einbauplatz.getNr).bln_Auf_NZ_warten = True
|
|
Else
|
|
' gezählte Impulse beim NZ noch < 2 => Es läuft KEIN Wasser durch den NZ, NICHT auf NZ Impulse warten
|
|
m_Messdaten(Einbauplatz.getNr).bln_Auf_NZ_warten = True
|
|
End If
|
|
Else
|
|
|
|
If m_Messdaten(Einbauplatz.getNr).MaxErlaubteAnzahlVonImpulsen_NZ > -1 Then
|
|
' NZ Impulse amzeigen
|
|
|
|
If m_blnSimulation Then
|
|
m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_NZ = 5
|
|
Else
|
|
m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_NZ = GetHexZahlFromFM85(m_Messdaten(Einbauplatz.getNr).FM85Adresse_NZ, "U")
|
|
End If
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.GezaehlteImpulse, Spalte_NZ) = m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_NZ
|
|
|
|
' HZ Impulse überprüfen
|
|
If m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_NZ > m_Messdaten(Einbauplatz.getNr).MaxErlaubteAnzahlVonImpulsen_NZ Then
|
|
' erst eine einstellbare Zeit nur Nebenzähler Impulse zählen, erst dann Konsequenzen ziehen
|
|
If m_dblPruefzeit_s > m_Messdaten(Einbauplatz.getNr).MessungAbbrechenNachSekunden Then
|
|
If intCountWiederholung < 1 Then
|
|
' Periodendauermessung komplett neu starten
|
|
GoTo Wiederholung
|
|
Else
|
|
' Messung beenden
|
|
Exit Do
|
|
End If
|
|
End If
|
|
End If
|
|
End If
|
|
End If 'bln_NZ_Messen / Else
|
|
|
|
' RZ
|
|
If m_blnSimulation Then
|
|
m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_RZ = m_Messdaten(Einbauplatz.getNr).Impulswertigkeit_RZ * dblPruefvolumen_m3 * (lngPruefzeit_s - m_dblPruefzeit_s) / lngPruefzeit_s
|
|
Else
|
|
m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_RZ = GetHexZahlFromFM85(m_Messdaten(Einbauplatz.getNr).FM85Adresse_RZ, "J")
|
|
End If
|
|
' Verbleibende Impulse
|
|
verbleibendeImpulseGesamt = verbleibendeImpulseGesamt + m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_HZ + IIf(m_Messdaten(Einbauplatz.getNr).bln_Auf_NZ_warten, m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_NZ, 0) + m_Messdaten(Einbauplatz.getNr).verbleibendeImpulse_RZ
|
|
AktualisiereDatenFuerPeriodendauermessung (Einbauplatz.getNr)
|
|
|
|
If m_Messdaten(Einbauplatz.getNr).Durchfluss_ist = 0 And m_dblPruefzeit_s > lngPruefzeit_s / 2 Then
|
|
' Ist-Durchfluss nach halber Prüfzeit
|
|
If Not g_ohneSPS Then
|
|
m_Messdaten(Einbauplatz.getNr).Durchfluss_ist = m_SPS.getQIst
|
|
End If
|
|
End If
|
|
End If
|
|
|
|
Next
|
|
|
|
If Int(m_dblPruefzeit_s * 100) < ProgressBar1.Max Then
|
|
ProgressBar1.value = Int(m_dblPruefzeit_s * 100)
|
|
End If
|
|
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Pruefzeit, enum_spalte.RZ) = Int(m_dblPruefzeit_s)
|
|
|
|
DoEvents
|
|
|
|
If m_blnAbbruch Then
|
|
If m_blnSimulation Then
|
|
m_Messdaten(1).gesamtFehler = Round((Rnd(1) * 3 - 1), 1)
|
|
m_Messdaten(2).gesamtFehler = Round((Rnd(1) * 3 - 1), 1)
|
|
End If
|
|
|
|
Exit Sub
|
|
End If
|
|
|
|
Loop While verbleibendeImpulseGesamt > 0
|
|
|
|
PrintStatus "verbleibende Impulse =0"
|
|
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
Select Case Einbauplatz.getNr
|
|
Case 1
|
|
Spalte_HZ = enum_spalte.HZ1
|
|
Spalte_NZ = enum_spalte.NZ1
|
|
Case 2
|
|
Spalte_HZ = enum_spalte.HZ2
|
|
Spalte_NZ = enum_spalte.NZ2
|
|
End Select
|
|
|
|
' Hauptzähler
|
|
If bln_HZ_Messen = True Then
|
|
If m_blnSimulation Then
|
|
m_Messdaten(Einbauplatz.getNr).Periodendauer_HZ = m_dblPruefzeit_s * 500000 / 167 '* 0.995
|
|
Else
|
|
m_Messdaten(Einbauplatz.getNr).Periodendauer_HZ = GetHexZahlFromFM85(m_Messdaten(Einbauplatz.getNr).FM85Adresse_HZ, "X")
|
|
End If
|
|
|
|
PrintStatus "Periodendauer HZ " & Einbauplatz.getNr & " = " & m_Messdaten(Einbauplatz.getNr).Periodendauer_HZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Periodendauer, Spalte_HZ) = m_Messdaten(Einbauplatz.getNr).Periodendauer_HZ
|
|
|
|
m_Messdaten(Einbauplatz.getNr).Pruefzeit_HZ = m_Messdaten(Einbauplatz.getNr).Periodendauer_HZ * 167 / 500000 'Quarzzeitbasis 1/2994 s
|
|
PrintStatus "Pruefzeit HZ " & Einbauplatz.getNr & " = " & m_Messdaten(Einbauplatz.getNr).Pruefzeit_HZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Pruefzeit, Spalte_HZ) = Format(m_Messdaten(Einbauplatz.getNr).Pruefzeit_HZ, "0.0")
|
|
|
|
If (m_Messdaten(Einbauplatz.getNr).Impulswertigkeit_HZ) * m_Messdaten(Einbauplatz.getNr).Pruefzeit_HZ <> 0 Then
|
|
m_Messdaten(Einbauplatz.getNr).Durchfluss_HZ = 3600 * m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_HZ / (m_Messdaten(Einbauplatz.getNr).Impulswertigkeit_HZ * m_Messdaten(Einbauplatz.getNr).Pruefzeit_HZ)
|
|
PrintStatus "Durchfluss HZ " & Einbauplatz.getNr & " = " & m_Messdaten(Einbauplatz.getNr).Durchfluss_HZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_m3, Spalte_HZ) = Format(m_Messdaten(Einbauplatz.getNr).Durchfluss_HZ, "0.000")
|
|
Else
|
|
PrintStatus "Durchfluss HZ " & Einbauplatz.getNr & " konnte nicht berechnet werden"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_m3, Spalte_HZ) = "?"
|
|
End If
|
|
Else
|
|
If m_Messdaten(Einbauplatz.getNr).MaxErlaubteAnzahlVonImpulsen_HZ > -1 Then
|
|
' Hauptzähler Impulse überprüfen
|
|
m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_HZ = GetHexZahlFromFM85(m_Messdaten(Einbauplatz.getNr).FM85Adresse_HZ, "U")
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.GezaehlteImpulse, Spalte_HZ) = m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_HZ
|
|
End If
|
|
|
|
m_Messdaten(Einbauplatz.getNr).Periodendauer_HZ = 0
|
|
m_Messdaten(Einbauplatz.getNr).Pruefzeit_HZ = 0
|
|
m_Messdaten(Einbauplatz.getNr).Durchfluss_HZ = 0
|
|
End If
|
|
|
|
' Nebenzähler
|
|
If bln_NZ_Messen Then
|
|
If m_blnSimulation Then
|
|
m_Messdaten(Einbauplatz.getNr).Periodendauer_NZ = m_dblPruefzeit_s * 500000 / 167 * (1 + 0) ' simulierter Fehler
|
|
Else
|
|
m_Messdaten(Einbauplatz.getNr).Periodendauer_NZ = GetHexZahlFromFM85(m_Messdaten(Einbauplatz.getNr).FM85Adresse_NZ, "X")
|
|
End If
|
|
PrintStatus "Periodendauer NZ " & Einbauplatz.getNr & " : " & m_Messdaten(Einbauplatz.getNr).Periodendauer_NZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Periodendauer, Spalte_NZ) = m_Messdaten(Einbauplatz.getNr).Periodendauer_NZ
|
|
|
|
m_Messdaten(Einbauplatz.getNr).Pruefzeit_NZ = m_Messdaten(Einbauplatz.getNr).Periodendauer_NZ * 167 / 500000 'Quarzzeitbasis 1/2994 s
|
|
PrintStatus "Pruefzeit NZ " & Einbauplatz.getNr & " : " & m_Messdaten(Einbauplatz.getNr).Pruefzeit_NZ & " s"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Pruefzeit, Spalte_NZ) = Format(m_Messdaten(Einbauplatz.getNr).Pruefzeit_NZ, "0.00")
|
|
|
|
If (m_Messdaten(Einbauplatz.getNr).Impulswertigkeit_NZ * m_Messdaten(Einbauplatz.getNr).Pruefzeit_NZ) <> 0 Then
|
|
m_Messdaten(Einbauplatz.getNr).Durchfluss_NZ = 3600 * m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_NZ / (m_Messdaten(Einbauplatz.getNr).Impulswertigkeit_NZ * m_Messdaten(Einbauplatz.getNr).Pruefzeit_NZ)
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_m3, Spalte_NZ) = Format(m_Messdaten(Einbauplatz.getNr).Durchfluss_NZ, "0.000")
|
|
PrintStatus "Durchfluss NZ : " & Format(m_Messdaten(Einbauplatz.getNr).Durchfluss_NZ, "0.000") & " m³/h"
|
|
Else
|
|
PrintStatus "Durchfluss NZ " & Einbauplatz.getNr & " konnte nicht berechnet werden."
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_m3, Spalte_NZ) = "?"
|
|
m_Messdaten(Einbauplatz.getNr).Durchfluss_NZ = 0
|
|
End If
|
|
Else
|
|
m_Messdaten(Einbauplatz.getNr).Periodendauer_NZ = 0
|
|
m_Messdaten(Einbauplatz.getNr).Pruefzeit_NZ = 0
|
|
m_Messdaten(Einbauplatz.getNr).Durchfluss_NZ = 0
|
|
|
|
If m_Messdaten(Einbauplatz.getNr).MaxErlaubteAnzahlVonImpulsen_NZ > -1 Then
|
|
' Nebenzähler Impulse überprüfen
|
|
If m_blnSimulation Then
|
|
m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_NZ = 1
|
|
Else
|
|
m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_NZ = GetHexZahlFromFM85(m_Messdaten(Einbauplatz.getNr).FM85Adresse_NZ, "U")
|
|
End If
|
|
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.GezaehlteImpulse, Spalte_NZ) = m_Messdaten(Einbauplatz.getNr).gezaehlteImpulse_NZ
|
|
End If
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Periodendauer, Spalte_NZ) = ""
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Pruefzeit, Spalte_NZ) = ""
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_m3, Spalte_NZ) = ""
|
|
End If
|
|
|
|
' Referenzzähler
|
|
' Periodendauer
|
|
If m_blnSimulation Then
|
|
m_Messdaten(Einbauplatz.getNr).Periodendauer_RZ = m_dblPruefzeit_s * 500000 / 167
|
|
Else
|
|
m_Messdaten(Einbauplatz.getNr).Periodendauer_RZ = GetHexZahlFromFM85(m_Messdaten(Einbauplatz.getNr).FM85Adresse_NZ, "Y")
|
|
End If
|
|
PrintStatus "Periodendauer RZ" & Einbauplatz.getNr & " = " & m_Messdaten(Einbauplatz.getNr).Periodendauer_RZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Periodendauer, enum_spalte.RZ) = m_Messdaten(Einbauplatz.getNr).Periodendauer_RZ
|
|
|
|
' Prüfzeit
|
|
m_Messdaten(Einbauplatz.getNr).Pruefzeit_RZ = m_Messdaten(Einbauplatz.getNr).Periodendauer_RZ * 167 / 500000 'Quarzzeitbasis 1/2994 s
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Pruefzeit, enum_spalte.RZ) = Format(m_Messdaten(1).Pruefzeit_RZ, "0.000")
|
|
PrintStatus "Pruefzeit RZ: " & Format(m_Messdaten(Einbauplatz.getNr).Pruefzeit_RZ, "0.000") & "s"
|
|
|
|
' Durchfluss HZ + NZ
|
|
m_Messdaten(Einbauplatz.getNr).Durchfluss_HZ_NZ = m_Messdaten(Einbauplatz.getNr).Durchfluss_HZ + m_Messdaten(Einbauplatz.getNr).Durchfluss_NZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_HZ_NZ, Spalte_HZ) = Format(m_Messdaten(Einbauplatz.getNr).Durchfluss_HZ_NZ, "0.000")
|
|
PrintStatus "Durchfluss_HZ+NZ_" & Einbauplatz.getNr & " = " & Format(m_Messdaten(Einbauplatz.getNr).Durchfluss_HZ_NZ, "0.000") & "m³/h"
|
|
|
|
' Fehler RZ
|
|
m_Messdaten(Einbauplatz.getNr).Fehler_RZ = m_Refzaehler.letzterFehler(m_DurchflussSoll)
|
|
PrintStatus "Fehler des RZ bei " & m_DurchflussSoll & "m³/h =" & Format(m_Messdaten(Einbauplatz.getNr).Fehler_RZ, "0.00") & " %"
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Fehler, enum_spalte.RZ) = Format(m_Messdaten(Einbauplatz.getNr).Fehler_RZ, "0.00") & " %"
|
|
|
|
If (m_Messdaten(Einbauplatz.getNr).Impulswertigkeit_RZ) * m_Messdaten(Einbauplatz.getNr).Pruefzeit_RZ <> 0 Then
|
|
m_Messdaten(Einbauplatz.getNr).Durchfluss_RZ = 3600 * m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_RZ / (m_Messdaten(Einbauplatz.getNr).Impulswertigkeit_RZ * m_Messdaten(Einbauplatz.getNr).Pruefzeit_RZ)
|
|
PrintStatus "Durchfluss RZ (unkorrigiert) : " & Format(m_Messdaten(Einbauplatz.getNr).Durchfluss_RZ, "0.00000") & " m³/h"
|
|
m_Messdaten(Einbauplatz.getNr).Durchfluss_RZ = 3600 * (m_Messdaten(Einbauplatz.getNr).AnzahlPerioden_RZ / m_Messdaten(Einbauplatz.getNr).Impulswertigkeit_RZ) / m_Messdaten(Einbauplatz.getNr).Pruefzeit_RZ / (1 + m_Messdaten(Einbauplatz.getNr).Fehler_RZ / 100)
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_m3, enum_spalte.RZ) = Format(m_Messdaten(Einbauplatz.getNr).Durchfluss_RZ, "0.000")
|
|
PrintStatus "Durchfluss RZ (korrigiert) : " & Format(m_Messdaten(Einbauplatz.getNr).Durchfluss_RZ, "0.00000") & " m³/h"
|
|
Else
|
|
PrintStatus "Durchfluss RZ konnte nicht berechnet werden."
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_m3, enum_spalte.RZ) = "?"
|
|
m_Messdaten(Einbauplatz.getNr).Durchfluss_RZ = 0
|
|
End If
|
|
|
|
If m_Messdaten(Einbauplatz.getNr).Durchfluss_RZ > 0 Then
|
|
m_Messdaten(Einbauplatz.getNr).gesamtFehler = 100 * (m_Messdaten(Einbauplatz.getNr).Durchfluss_HZ_NZ - m_Messdaten(Einbauplatz.getNr).Durchfluss_RZ) / m_Messdaten(Einbauplatz.getNr).Durchfluss_RZ
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Fehler_HZ_NZ, Spalte_HZ) = Format(m_Messdaten(Einbauplatz.getNr).gesamtFehler, "0.000")
|
|
PrintStatus "Fehler des Verbundzaehlers: " & Format(m_Messdaten(Einbauplatz.getNr).gesamtFehler, "0.000") & " %"
|
|
Else
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Fehler_HZ_NZ, Spalte_HZ) = "?"
|
|
End If
|
|
End If
|
|
Next
|
|
|
|
AutoSpaltenBreite MSFlexgridMessung, lblAutosize
|
|
End Sub
|
|
|
|
|
|
Public Sub ClearFlexgridMessung()
|
|
Dim i As Integer
|
|
For i = 1 To 5
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_HZ_NZ, i) = ""
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Durchfluss_m3, i) = ""
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Fehler, i) = ""
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Fehler_HZ_NZ, i) = ""
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Periodendauer, i) = ""
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.Pruefzeit, i) = ""
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.VerbleibeneImpulse, i) = ""
|
|
MSFlexgridMessung.TextMatrix(enum_zeile.GezaehlteImpulse, i) = ""
|
|
Next
|
|
End Sub
|
|
|
|
|
|
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
|
|
Private Sub PruefdatenSpeichern()
|
|
Dim Einbauplatz As CEinbauplatz
|
|
Dim Pruefzaehler As CPruefzaehler
|
|
Dim AuftragpositionSerienNr As CAuftragPositionSerienNr
|
|
|
|
For Each Einbauplatz In m_colEinbauplatz
|
|
Set Pruefzaehler = Einbauplatz.getPruefzaehler
|
|
If Not Pruefzaehler Is Nothing Then
|
|
|
|
Set AuftragpositionSerienNr = New CAuftragPositionSerienNr
|
|
AuftragpositionSerienNr.load Pruefzaehler.getSerienNr
|
|
|
|
AuftragpositionSerienNr.setPruefgangNr m_Pruefgang.PruefgangNr
|
|
AuftragpositionSerienNr.setEinbauplatzNr Einbauplatz.getNr
|
|
AuftragpositionSerienNr.setAnlageDatum Now()
|
|
|
|
AuftragpositionSerienNr.setAnlageMitarbeiterNr g_App.Mitarbeiter.getNr
|
|
' Metrologische Klasse unter der diese Prüfung durchgeführt wurde
|
|
If Pruefzaehler.getPruefklasseKZ <> "" Then
|
|
AuftragpositionSerienNr.setMetrolog Pruefzaehler.getPruefklasseKZ
|
|
Else
|
|
AuftragpositionSerienNr.setMetrolog Pruefzaehler.getPruefpunkte.getPruefklasseKZ
|
|
End If
|
|
|
|
'Angaben für Änderung löschen
|
|
AuftragpositionSerienNr.setAenderungDatum Empty
|
|
AuftragpositionSerienNr.setAenderungMitarbeiterNr Empty
|
|
' Setzen der neuen Werte: PgangDatum, PgangNr, Einbauplatz, AnlageDatum, MitarbeiterNr
|
|
AuftragpositionSerienNr.setPruefgangDatum m_Pruefgang.Datum
|
|
AuftragpositionSerienNr.setWiederholungen AuftragpositionSerienNr.getWiederholungen + 1
|
|
|
|
AuftragpositionSerienNr.setStatusFertigung 25
|
|
FehlerSpeichern m_Messdaten(Einbauplatz.getNr).Ergebniss_Fehler_Qmax, Pruefzaehler, m_Pruefgang, 1
|
|
FehlerSpeichern m_Messdaten(Einbauplatz.getNr).Ergebniss_Fehler_Qmin, Pruefzaehler, m_Pruefgang, 2
|
|
|
|
' Überprüfen auf Fehlergrenzen
|
|
' 1. Qmax
|
|
If Not GrenzwertUeberschritten(m_colUniquePP.Item(1).getFGo, m_Messdaten(Einbauplatz.getNr).Ergebniss_Fehler_Qmax, m_colUniquePP.Item(1).getFGu) Then
|
|
' 2. Qmin
|
|
If Not GrenzwertUeberschritten(m_colUniquePP.Item(2).getFGo, m_Messdaten(Einbauplatz.getNr).Ergebniss_Fehler_Qmin, m_colUniquePP.Item(2).getFGu) Then
|
|
If Not GrenzwertUeberschritten(1.5, m_Messdaten(Einbauplatz.getNr).Ergebniss_Fehler_Oeffnen, -1.5) Then
|
|
' 3. Qoeffnen
|
|
If Not GrenzwertUeberschritten(1.5, m_Messdaten(Einbauplatz.getNr).Ergebniss_Fehler_Schliessen, -1.5) Then
|
|
' 4. Schliessen
|
|
AuftragpositionSerienNr.setStatusFertigung 30
|
|
End If
|
|
End If
|
|
End If
|
|
End If
|
|
|
|
AuftragpositionSerienNr.save True
|
|
If VerbundzaehlerSpeichern(Pruefzaehler.getSerienNr, m_Pruefgang.PruefgangNr, m_Messdaten(Einbauplatz.getNr).Durchfluss_Oeffnen, m_Messdaten(Einbauplatz.getNr).Ergebniss_Fehler_Oeffnen, m_Messdaten(Einbauplatz.getNr).Durchfluss_Schliessen, m_Messdaten(Einbauplatz.getNr).Ergebniss_Fehler_Schliessen, Pruefzaehler.m_Verbundzaehler.lngSerienNrNZ, False, Pruefzaehler.m_Verbundzaehler.strKundeneigeneSerienNrNZ, Pruefzaehler.getAuftragPosition) Then
|
|
|
|
End If
|
|
End If
|
|
Next
|
|
|
|
End Sub
|
|
|
|
|
|
|
|
Private Function FehlerSpeichern(Fehler As Double, Pruefzaehler As CPruefzaehler, Pruefgang As CPruefgang, PruefpunktNr As Integer)
|
|
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
|
|
|
|
Set rs = New CRecordset
|
|
sSQL = "SELECT * from Prueffehler where PruefgangNr=" & PruefgangNr & " and SerienNr=" & SerienNr & ";"
|
|
rs.openRS (sSQL)
|
|
Debug.Print sSQL
|
|
|
|
If rs.EOF Then
|
|
rs.addNew
|
|
End If
|
|
|
|
Call rs.setValue("SerienNr", SerienNr)
|
|
Call rs.setValue("PruefgangNr", PruefgangNr)
|
|
|
|
Feldname = "PP" & CStr(PruefpunktNr) & "_Fehler"
|
|
|
|
Debug.Print "Feldname=" & Feldname & "; Fehler=" & Fehler
|
|
|
|
Call rs.setValue(Feldname, Fehler)
|
|
Call rs.setValue("PruefDatum", Now)
|
|
|
|
Call rs.update
|
|
FehlerSpeichern = True
|
|
Exit Function
|
|
FehlerSpeichernError:
|
|
ErrorMsg ("FehlerSpeichern fehlgeschlagen: " & Err.Description)
|
|
End Function
|
|
|
|
|
|
Private Function VerbundzaehlerSpeichern(SerienNr As Long, PruefgangNr As Long, dblPP_Oeffnen As Double, dblPP_OeffnenFehler As Double, dblPP_Schliessen As Double, dblPP_SchliessenFehler As Double, strSerienNrNebenzaehler As String, bPruefNZ As Boolean, Optional strKundeneigeneSerienNrNZ As String = "", Optional objAuftragPosition As CAuftragPosition) As Boolean
|
|
On Error GoTo VerbundzaehlerSpeichernError
|
|
Dim rs As CRecordset
|
|
Dim Feldname As String
|
|
Dim sSQL As String
|
|
|
|
Set rs = New CRecordset
|
|
|
|
sSQL = "SELECT * from Verbundzaehler where PruefgangNr=" & PruefgangNr & " and SerienNr=" & SerienNr & ";"
|
|
rs.openRS sSQL, False
|
|
|
|
If rs.EOF Then
|
|
sSQL = "SELECT * from Verbundzaehler where PruefgangNr=0 and SerienNr=" & SerienNr & ";"
|
|
rs.openRS sSQL, False
|
|
If rs.EOF Then
|
|
rs.addNew
|
|
End If
|
|
End If
|
|
|
|
Call rs.setValue("SerienNr", SerienNr)
|
|
Call rs.setValue("PruefgangNr", PruefgangNr)
|
|
|
|
|
|
Call rs.setValue("PP_Oeffnen", dblPP_Oeffnen)
|
|
Call rs.setValue("PP_OeffnenFehler", Round(dblPP_OeffnenFehler, 3))
|
|
|
|
|
|
|
|
Call rs.setValue("PP_Schliessen", dblPP_Schliessen)
|
|
Call rs.setValue("PP_SchliessenFehler", Round(dblPP_SchliessenFehler, 3))
|
|
|
|
|
|
If Val(strSerienNrNebenzaehler) <> 0 Then
|
|
Call rs.setValue("SerienNrNebenzaehler", strSerienNrNebenzaehler)
|
|
Call rs.setValue("Pruefnebenzaehler", bPruefNZ)
|
|
End If
|
|
|
|
If strKundeneigeneSerienNrNZ <> "" Then
|
|
Call rs.setValue("KundeneigeneSerNrNbZ", strKundeneigeneSerienNrNZ)
|
|
End If
|
|
|
|
|
|
Call rs.setValue("PrueferNr", g_App.Mitarbeiter.getNr)
|
|
Call rs.setValue("Datum", Now())
|
|
|
|
' neu RH 17.11.2010
|
|
Call rs.setValue("Info_FertigungsauftragNr", objAuftragPosition.GetFertigungsauftragNr)
|
|
|
|
Call rs.update
|
|
VerbundzaehlerSpeichern = True
|
|
Exit Function
|
|
VerbundzaehlerSpeichernError:
|
|
ErrorMsg ("VerbundzaehlerSpeichern fehlgeschlagen: " & Err.Description)
|
|
VerbundzaehlerSpeichern = False
|
|
End Function
|
|
|
|
|
|
Private Sub txtDurchflussOeffnen_KeyPress(Index As Integer, KeyAscii As Integer)
|
|
If KeyAscii = 13 Then
|
|
txtDurchflussSchliessen(Index).SetFocus
|
|
End If
|
|
End Sub
|
|
|
|
Private Sub txtDurchflussSchliessen_KeyPress(Index As Integer, KeyAscii As Integer)
|
|
If KeyAscii = 13 Then
|
|
cmdWeiter.Default = True
|
|
End If
|
|
End Sub
|