Attribute VB_Name = "SPS_Bearbeitung" Option Explicit Dim adresse As String Dim AdressenANAein As Integer Dim AdressenANAaus As Integer Dim Artikelnummer(7) As Long Dim aktEinbauort As String Dim aktBMKZählerNr As Integer Dim Byteneu As Integer Dim Bitneu As Integer Dim bytenr As String Dim bitnr As String Dim dummy As String Dim Einzelteil As EplHandle Dim Funktion As String Dim h_Bauteil As EplHandle Dim h_symbol As EplHandle Dim h_command As EplHandle Dim h_iter_project As EplHandle Dim h_ret As EplHandle Dim iter_Bauteile As EplHandle Dim iter_Einzelteile As EplHandle Dim iter_parts As EplHandle Dim iter_delete As EplHandle Dim part As EplHandle Dim LastErr As String Dim nme As String Dim Pos As Integer Dim pos1 As Integer Dim pos2 As Integer Dim Präfix As String Dim seite As String Dim SPSDaten As Recordset Dim SPSAdressen As Recordset Dim SPSStart As Recordset Dim Startadresse As Integer Dim StartadresseANA As Integer Dim Liste_Filter As String Dim Liste_Sortier As String Dim Kopf_Filter As String Dim Kopf_Sortier As String Dim x As Integer Dim restwert As Integer Dim Reservezähler As Integer Dim SPSLöschliste As EplHandle Dim iter_Seiten As EplHandle Dim h_Seite As EplHandle Dim erzeugtesteil As EplHandle Dim einbauort As String Dim Zählernr As String Dim rec As Recordset Dim rec2 As Recordset Function Vielfachesvon(Zahl As Integer, übergabewert As Integer, Optional Fehlwert As Integer) As Boolean If übergabewert / Zahl = Round(übergabewert / Zahl) Then Vielfachesvon = True If übergabewert Mod Zahl > 0 Then Fehlwert = Zahl - (übergabewert Mod Zahl) Else Fehlwert = 0 End If End Function Sub nichtinstanziierteSPS_Klemmen_löschen() Dim nme As String Dim Makros As EplHandle Dim Makro As EplHandle Dim Makroname As String Dim GruppeNr As String Dim UnteranlageNr As String Dim Makrostatus As Boolean Dim Seiten As EplHandle Dim seite As EplHandle Dim Bauteile As EplHandle Dim Bauteil As EplHandle Dim Einzelteile As EplHandle Dim Einzelteil As EplHandle Dim Klemmen As EplHandle Dim Klemme As EplHandle Dim erzeugtesteil As EplHandle Dim löschenSPSKlemme As EplHandle Dim löschenKlemme As EplHandle Dim h_command As EplHandle Dim LastErr As Long Dim h_ret As EplHandle Dim a As Boolean Dim h_symbol As EplHandle Dim freeNr As Integer ' ' Die Prozedur liest alle in der Eplan-Stammdatenbank (Makros) und legt diese, ' wenn es sich um ein gruppenabhängiges Makro handelt, in der Monforts-Stammdatenbank ab. ' Anschließend werden diese und die unter der Tabelle "Fragen" hinterlegten Makros ' abgeglichen. Das Ergebnis wird in einem separaten Fenster angezeigt. ' If frm_Makrohandling.chk_SPS_Klemmen = 0 And frm_Makrohandling.chk_normale_KLemmen = 0 Then MessageBox eplansteuerung.hwnd, "Bitte geben Sie an welche Bauteiltypen bearbeitet werden sollen.", "Info", MB_OK Exit Sub End If With ObjEpl ' ' Statusanzeige am Monitor .EPLAN_Status1 0, 0, "Datenbank wird geöffnet" ' ' Datenbank aufrufen h_command = .eplan.createCommand(epl_s, "EPLAN.EPLAN21.DATABASE.OPEN") .eplan.setParam epl_s, h_command, PARAM_OPENDB_DBNAME, ftfrmOpenGetIni(" ", "paths", "Leerprojekt", "Fahrplan01.ini") .eplan.setParam epl_s, h_command, PARAM_OPENDB_RESDBNAME, ftfrmOpenGetIni(" ", "paths", "Stammdatenbank", "Fahrplan01.ini") .eplan.setParam epl_s, h_command, PARAM_OPENDB_MACRODBNAME, ftfrmOpenGetIni(" ", "paths", "Makrodatenbank", "Fahrplan01.ini") .eplan.setParam epl_s, h_command, PARAM_OPENDB_RESDBFLAG, "0" .eplan.setParam epl_s, h_command, PARAM_OPENDB_MACRODBFLAG, "0" h_ret = .eplan.executeCommand(epl_s, h_command) LastErr = .eplan.LastError ' ' Fehlerreaktion If h_ret = -1 Then MessageBox eplansteuerung.hwnd, "Fehler beim Öffnen der Datenbank von EPLAN 21" + vbNewLine + "Verbindungen und Sperrungen entfernen!", "Fehlermeldung", MB_OK Exit Sub End If ' ' Handle der Datenbank lesen h_database = .eplan.getHandleParam(epl_s, h_command, PARAM_OPENDB_DBHANDLE) .eplan.closeObject epl_s, h_command ' ' Statusanzeige am Monitor .EPLAN_Status1 0, 0, "Makros aus EPLAN21 werden eingelesen." Makros = .eplan.openIterator(epl_s, h_database, ITERTYPE_MACROS) Makro = .eplan.First(epl_s, Makros) .EPLAN_Status1 .eplan.Count(epl_s, Makros), 0 ' ' Schleife über alle EPLAN-Makros Do While Makro <> -1 Makroname = .eplan.getProperty(epl_s, Makro, 5) Dim test As String ' ' Makrostatus gibt an, ob ein Makro von der Namensgebung ok ist, es sich also nicht um irgendein ' "Schmiermakro" handelt. Zulässige Makros haben einen 5 stelligen Code am Anfang des Names. ' Die ersten 3 Zeichen sind entweder die Gruppennummer oder die Kürzel "WT_" für allgemeine Makros ' der Warentransportantriebe oder "Lü_" für Umwälzlüfter. GruppeNr = Val(Left(Makroname, 3)) UnteranlageNr = Val(Mid(Makroname, 4, 2)) ' ' Wenn Gruppennummer und Unteranlage01 lesbar werden die Daten des Makros ' in der Monforts-Stammdatenbank abgelegt. If GruppeNr > 0 And UnteranlageNr > 0 Then Makrostatus = True ElseIf Left(Makroname, 3) = "WT_" And UnteranlageNr > 0 Then Makrostatus = True ElseIf Left(Makroname, 3) = "LÜ_" And UnteranlageNr > 0 Then Makrostatus = True Else Makrostatus = False End If If Makrostatus = True Then eplansteuerung.TB_Status.text = "Makro " & Makroname & " wird bearbeitet." eplansteuerung.TB_Status.Refresh 'Debug.Print .eplan.getProperty(epl_s, Makro, 5) Print #FileNr, Print #FileNr, .eplan.getProperty(epl_s, Makro, 5) ' ' Die Seiten-Property wird nachher benötigt. Deshalb wird das Handle der Seite gebildet. Seiten = .eplan.openIterator(epl_s, Makro, ITERTYPE_PAGES) seite = .eplan.First(epl_s, Seiten) ' Iterator über alle Bauteile einer Seite Bauteile = .eplan.openIterator(epl_s, Makro, ITERTYPE_DEVICETAGS) Bauteil = .eplan.First(epl_s, Bauteile) ' Bauteil leer???? If Bauteil <> -1 Then .EPLAN_Status2 .eplan.Count(epl_s, Bauteile), 0 ' Schleife über alle Bauteile While Bauteil <> -1 .EPLAN_Status2 0, 1 ' Kontrolle, ob Bauteil eine SPS-Klemme ist (anhand des Anlagenkennzeichens). .trans.commit If frm_Makrohandling.chk_SPS_Klemmen Then Einzelteile = .eplan.openIterator(epl_s, Bauteil, ITERTYPE_COMPONENT_PART) Einzelteil = .eplan.First(epl_s, Einzelteile) ' Leeren Löschiterator bilden löschenSPSKlemme = .eplan.createEmptyIterator(epl_s, OBJECTTYPE_INSTANCE) ' Schleife über alle Einzelteile While Einzelteil <> -1 ' Instanziiert (nur diese sollen abgesetzt und gelöscht werden) und ' Adresse<>"" (es ist eine Klemme und kein Kasten) If .eplan.getProperty(epl_s, Einzelteil, 13353) <> "" Then If .eplan.getProperty(epl_s, Einzelteil, 1750) = False Then If .eplan.getProperty(epl_s, Einzelteil, 13353) <> "" And .eplan.getProperty(epl_s, Einzelteil, 768) <> "051" Then h_ret = .eplan.setProperty(epl_s, Einzelteil, 768, "051") End If h_command = .eplan.createCommand(epl_s, "EPLAN.EPLAN21.ELEMENT.CREATE_AND_INSTANTIATE") h_ret = .eplan.setHandleParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_PROJECT, Makro) h_ret = .eplan.setHandleParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_PAGE, seite) h_ret = .eplan.setHandleParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_COMPONENT, Einzelteil) h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_X_POS, "40000") h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_Y_POS, "40000") h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_CREATE_ONLY, "0") h_ret = .eplan.executeCommand(epl_s, h_command) If h_ret <> -1 Then erzeugtesteil = .eplan.getHandleParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_RESULT) h_ret = .eplan.Insert(epl_s, löschenSPSKlemme, erzeugtesteil) End If End If .eplan.closeObject epl_s, h_command End If h_command = .eplan.createCommand(epl_s, "EPLAN.EPLAN21.OBJECT.DELETE") .eplan.setHandleParam epl_s, h_command, PARAM_OBJECT_DELETE_OBJECTS, löschenSPSKlemme h_ret = .eplan.setParam(epl_s, h_command, PARAM_OBJECT_DELETE_DELETEMODE, "1") h_ret = .eplan.executeCommand(epl_s, h_command) Einzelteil = .eplan.Next(epl_s, Einzelteile) Wend ElseIf frm_Makrohandling.chk_normale_KLemmen Then Klemmen = .eplan.openIterator(epl_s, Bauteil, ITERTYPE_TERMINALS) Klemme = .eplan.First(epl_s, Klemmen) Print #FileNr, While Klemme <> -1 h_symbol = .eplan.getPropertyUser(epl_s, Klemme, PROPERTY_COMP_VERBINDER_IND_LEISTE) Print #FileNr, "Klemmleiste: " & .eplan.getProperty(epl_s, h_symbol, 5), " Ort: " & .eplan.getProperty(epl_s, h_symbol, 768), " Anlage: " & .eplan.getProperty(epl_s, h_symbol, 769) If .eplan.getProperty(epl_s, h_symbol, 768) <> "" Then .eplan.setProperty epl_s, h_symbol, 768, "" Print #FileNr, "Neu! Klemmleiste: " & .eplan.getProperty(epl_s, h_symbol, 5), " Ort: " & .eplan.getProperty(epl_s, h_symbol, 768), " Anlage: " & .eplan.getProperty(epl_s, h_symbol, 769) End If Print #FileNr, " Klemme: " & .eplan.getProperty(epl_s, Klemme, 5) Print #FileNr, " Beschreibung: " & .eplan.getProperty(epl_s, Klemme, 6), " Ort: " & .eplan.getProperty(epl_s, Klemme, 768), " Anlage: " & .eplan.getProperty(epl_s, Klemme, 769), " instanziiert: " & .eplan.getProperty(epl_s, Klemme, 1750) Klemme = .eplan.Next(epl_s, Klemmen) Wend End If .trans.start 0 Bauteil = .eplan.Next(epl_s, Bauteile) Wend End If End If h_ret = .eplan.setProperty(epl_s, Makro, 190, "1") eplansteuerung.Fortschritt.Value = eplansteuerung.Fortschritt.Value + 1 eplansteuerung.anzahlFortschritt.text = Format(eplansteuerung.Fortschritt.Value) + " von " + Format(eplansteuerung.Fortschritt.Max) eplansteuerung.anzahlFortschritt.Refresh Makro = .eplan.Next(epl_s, Makros) Loop .eplan.clearAllHandles epl_s .EPLAN_Status2 0, 0 .EPLAN_Status1 0, 0, "Funktion beendet" End With End Sub Sub sps_Symboliste_erzeugen() Dim fg As Integer Dim fh As Integer Dim textzeile As String Dim dataQ As Recordset Dim dataZ As Recordset Dim hilfstext As String Dim Pos As Integer Dim AdrAlt As String Dim NByte As Integer Dim NBit As Integer ' ' Vorgehensweise beim Erzeugen der Zuweisungsliste für Step 7: ' 1. Die Original-Zuweisungsliste von Step 7 wird gelesen und in der StammDB gespeichert (SPS-Adressliste) ' 2. In der ProjektDB wird die zur symbolischen Adresse gehörende absolute Adresse gespeichert. ' Dazu wird erst die komplette Symbolik überprüft und die absolute Adresse zugewiesen. ' Wenn dies nicht erfolgreich war, wird nur nach der reinen Symbolik (ohne vorangehendes BMK) gesucht. ' Wurde dann noch keine passende Symbolik gefunden wird eine Fehlermeldung in der Protokolldatei generiert. ' 3. In die nicht benutzten E/As werden jetzt die Merker >300 eingetragen. ' 4. Zuweisungsliste für Step 7 wird als ASCII-datei erzeugt und im Projektverzeichnis hinterlegt. ' Screen.MousePointer = 11 fg = FreeFile ' Öffnen der Original-Liste aus der S7-Bib Open sps_sym & Left(frm_SPS.CB_S7_BIBLI.text, 2) & ".asc" For Input As #fg 'ff = FreeFile '' Öffnen der Protokolldatei 'Open SPS_Protokoll For Output As #ff fh = FreeFile ' Öffnen der Projekt-Symboldatei Open SPS_Liste For Output As #fh textzeile = "1" ' Löschen der temorären Datenbanktabellen sqlstr = "DELETE " + _ "FROM SPS_Adressliste;" löschenVonMehrerenDatensätzen sqlstr, db, True sqlstr = "DELETE " + _ "FROM sel_SPS_Adressen_neu;" löschenVonMehrerenDatensätzen sqlstr, db, True ' Öffnen der temorären Datenbanktabellen sqlstr = "SELECT SPS_Adressliste.*, sel_SPS_Adressen_neu.abs_Adresse_neu, sel_SPS_Adressen_neu.sym_Adresse as sy,sel_SPS_Adressen_neu.BMK_eplan " + _ "FROM SPS_Adressliste LEFT JOIN sel_SPS_Adressen_neu ON SPS_Adressliste.sym_Adresse = sel_SPS_Adressen_neu.sym_Adresse;" Set dataZ = db.OpenRecordset(sqlstr) sqlstr = "SELECT SPSKonfig.SymbolischeAdresse, SPSKonfig.FunktionstextBMK, SPSKonfig.einaus, SPSKonfig.adresseneubyte, SPSKonfig.adresseneubit " + _ "From SPSKonfig " + _ "WHERE SPSKonfig.adresseneubyte<>0;" Set dataQ = db.OpenRecordset(sqlstr) ObjEpl.EPLAN_Status1 LängeErmitteln(sps_sym & Left(frm_SPS.CB_S7_BIBLI.text, 2) & ".asc"), 0, "Einlesen der SPS Zuweisungsliste" ' Lesen der Original-Liste aus der S7-Bib und Eintrag der Daten in eine temporäre Datenbanktabelle Do While Not EOF(fg) Line Input #fg, textzeile With dataZ ObjEpl.EPLAN_Status1 0, 1 .AddNew !kennung = Left(textzeile, 4) !sym_adresse = Mid(textzeile, 5, 24) !sy = Mid(textzeile, 5, 24) !abs_adresse = Mid(textzeile, 29, 12) !Datentyp = Mid(textzeile, 41, 10) !Funktion = Mid(textzeile, 51, 80) .Update End With Loop ObjEpl.EPLAN_Status1 0, 0 ' Tauschen der Adressen With dataQ If .RecordCount > 0 Then .MoveLast .MoveFirst ObjEpl.EPLAN_Status1 .RecordCount, 0, "Adressen tauschen" While Not .EOF ObjEpl.EPLAN_Status1 0, 1 ' Kontrolle 1: Ist SPS-Klemme eine Reserve-Klemme? If InStr(1, !funktionstextbmk, "Reserve", vbBinaryCompare) = 0 Then sqlstr = "SELECT SPS_Adressliste.*, sel_SPS_Adressen_neu.abs_Adresse_neu,sel_SPS_Adressen_neu.sym_Adresse as sy " + _ "FROM SPS_Adressliste LEFT JOIN sel_SPS_Adressen_neu ON SPS_Adressliste.sym_Adresse = sel_SPS_Adressen_neu.sym_Adresse " + _ "WHERE sel_SPS_Adressen_neu.sym_Adresse = '" & !symbolischeAdresse & "_" & !funktionstextbmk & "'" Set dataZ = db.OpenRecordset(sqlstr) ' Kontrolle 2: ist der Komplette Symbol-Ausdruck vorhanden (BMK + "_" + Symbolik) Select Case dataZ.RecordCount ' vorhanden Case 1 dataZ.Edit If !einaus = "E" Or !einaus = "A" Then dataZ!abs_adresse_neu = !einaus & " " & !adresseneubyte & "." & !adresseneubit ElseIf !einaus = "PEW" Or !einaus = "PAW" Then dataZ!abs_adresse_neu = !einaus & " " & !adresseneubyte Else Print #FileNr, "Variable 'einaus' in DB nicht ok" End If dataZ.Update ' mehrdeutig Case Is > 1 Print #FileNr, "Eintrag " & !symbolischeAdresse & "_" & !funktionstextbmk&; Tab(40); " nicht eindeutig! " & dataZ.RecordCount & " mal vorhanden!" ' nicht vorhanden. ' Jetzt wird Kontrolle 3 durchgeführt: Suche nur nach dem Symbol Case Is = 0 Print #FileNr, "Eintrag " & !symbolischeAdresse & "_" & !funktionstextbmk & " nicht vorhanden!" sqlstr = "SELECT SPS_Adressliste.*, sel_SPS_Adressen_neu.abs_Adresse_neu, sel_SPS_Adressen_neu.sym_Adresse as sy " + _ "FROM SPS_Adressliste LEFT JOIN sel_SPS_Adressen_neu ON SPS_Adressliste.sym_Adresse = sel_SPS_Adressen_neu.sym_Adresse " + _ "WHERE sel_SPS_Adressen_neu.sym_Adresse like '*_" & !funktionstextbmk & "*'" Set dataZ = db.OpenRecordset(sqlstr) Select Case dataZ.RecordCount ' vorhanden. BMK wird zwar eingetragen, jedoch auch eine fehlermeldung herausgegeben. Case 1 dataZ.Edit If !einaus = "E" Or !einaus = "A" Then dataZ!abs_adresse_neu = !einaus & " " & !adresseneubyte & "." & !adresseneubit ElseIf !einaus = "PEW" Or !einaus = "PAW" Then dataZ!abs_adresse_neu = !einaus & " " & !adresseneubyte Else Print #FileNr, "Variable 'einaus' in DB nicht ok" End If dataZ.Update ' mehrdeutig Case Is > 1 Print #FileNr, " Eintrag ??????" & "_" & !funktionstextbmk&; Tab(40); " nicht eindeutig! " & dataZ.RecordCount & " mal vorhanden!" ' nicht vorhanden. Fehlermeldung wird generiert Case Is = 0 Print #FileNr, " Eintrag ??????_" & !funktionstextbmk&; Tab(40); " nicht vorhanden! " End Select End Select End If .MoveNext Wend End If End With ObjEpl.EPLAN_Status1 0, 0 ' In die Projektliste wird jetzt für alle nicht vorhandenen E/As ein Merkerbit bzw. Wort eingetragen sqlstr = "SELECT SPS_Adressliste.*, sel_SPS_Adressen_neu.abs_Adresse_neu " + _ "FROM SPS_Adressliste LEFT JOIN sel_SPS_Adressen_neu ON SPS_Adressliste.sym_Adresse = sel_SPS_Adressen_neu.sym_Adresse " + _ "Where sel_SPS_Adressen_neu.abs_Adresse_neu Is Null And SPS_Adressliste.abs_Adresse Like 'E*' Or " + _ "sel_SPS_Adressen_neu.abs_Adresse_neu Is Null And SPS_Adressliste.abs_Adresse Like 'A*' Or " + _ "sel_SPS_Adressen_neu.abs_Adresse_neu Is Null And SPS_Adressliste.abs_Adresse Like 'PEW*' Or " + _ "sel_SPS_Adressen_neu.abs_Adresse_neu Is Null And SPS_Adressliste.abs_Adresse Like 'PAW*' or " + _ "sel_SPS_Adressen_neu.abs_Adresse_neu Is Null And SPS_Adressliste.abs_Adresse Like 'PED*' Or " + _ "sel_SPS_Adressen_neu.abs_Adresse_neu Is Null And SPS_Adressliste.abs_Adresse Like 'PAD*' " + _ "ORDER BY SPS_Adressliste.abs_Adresse;" Set dataQ = db.OpenRecordset(sqlstr) ' Die oben selektiierte Tabelle enthält alle nicht benutzten E/As NByte = 299 NBit = 7 With dataQ If .RecordCount > 0 Then .MoveLast .MoveFirst ObjEpl.EPLAN_Status1 .RecordCount, 0, "Merker eintragen" While Not .EOF ObjEpl.EPLAN_Status1 0, 1 .Edit ' Selektion digitale E/As If Left(!abs_adresse, 2) = "E " Or Left(!abs_adresse, 2) = "A " Then !abs_adresse_neu = "M " & NByte & "." & NBit NBit = NBit + 1 If NBit > 7 Then NByte = NByte + 1 NBit = 0 End If ' Selektion analoge E/As als Wort ElseIf Left(!abs_adresse, 3) = "PEW" Or Left(!abs_adresse, 3) = "PAW" Or Left(!abs_adresse, 2) = "EW" Or Left(!abs_adresse, 2) = "AW" Then NByte = NByte + 2 !abs_adresse_neu = "MW " & NByte ' Selektion analoge E/As als Doppelwort ElseIf Left(!abs_adresse, 3) = "PED" Or Left(!abs_adresse, 3) = "PAD" Then NByte = NByte + 4 !abs_adresse_neu = "MD " & NByte End If .Update .MoveNext Wend End If End With ObjEpl.EPLAN_Status1 0, 0 ' ' Neue Zuweisungsliste wird erzeugt sqlstr = "SELECT SPS_Adressliste.*, sel_SPS_Adressen_neu.abs_Adresse_neu " + _ "FROM SPS_Adressliste LEFT JOIN sel_SPS_Adressen_neu ON SPS_Adressliste.sym_Adresse = sel_SPS_Adressen_neu.sym_Adresse " + _ "ORDER BY SPS_Adressliste.sym_Adresse;" Set dataQ = db.OpenRecordset(sqlstr) With dataQ If .RecordCount > 0 Then .MoveLast .MoveFirst ObjEpl.EPLAN_Status1 .RecordCount, 0, "Liste wird erzeugt" While Not .EOF ObjEpl.EPLAN_Status1 0, 1 If Len(!abs_adresse_neu) > 0 Then hilfstext = !abs_adresse_neu Else hilfstext = !abs_adresse Print #fh, !kennung; !sym_adresse; Tab(29); hilfstext; Tab(41); !Datentyp; Tab(51); !Funktion .MoveNext Wend End If End With ObjEpl.EPLAN_Status1 0, 0, "Zuweisungsliste wurde erzeugt" Screen.MousePointer = 1 Close fg Close fh End Sub Function SPSDatenAusProjektLesen() As Boolean Dim origZähler As Integer With ObjEpl ' ' Datensätze löschen und Recordset vorbereiten sqlstr = "delete SPSKonfig.* FROM SPSKonfig;" löschenVonMehrerenDatensätzen sqlstr, db, True sqlstr = "select SPSKonfig.* FROM SPSKonfig;" Set SPSDaten = db.OpenRecordset(sqlstr) ' .EPLAN_Status1 0, 0, "Daten werden ausgelesen." ' ' Handle auf erste Schaltplanseite bilden iter_Seiten = .eplan.openIterator(epl_s, h_project, ITERTYPE_PAGES) h_Seite = .eplan.First(epl_s, iter_Seiten) Do While h_Seite <> -1 If .eplan.getProperty(epl_s, h_Seite, 3001) = "1" Then Exit Do h_Seite = .eplan.Next(epl_s, iter_Seiten) Loop ' Überschrift für Protokoll-Datei Print #FileNr, "Beim Einlesen der SPS aus EPLAN sind folgende Fehler erkannt worden:" Print #FileNr, ' ' Iterator über alle Bauteile des Projektes öffnen iter_Bauteile = .eplan.openIterator(epl_s, h_project, ITERTYPE_DEVICETAGS) h_Bauteil = .eplan.First(epl_s, iter_Bauteile) .EPLAN_Status1 .eplan.Count(epl_s, iter_Bauteile), 0 ' Schleife über alle Bauteile Do While h_Bauteil <> -1 .EPLAN_Status1 0, 1 ' Kontrolle des Anlagenkennzeichen. If .eplan.getProperty(epl_s, h_Bauteil, 768) = "051" Then ' Bildung Iterator über alle Einzelteile. iter_Einzelteile = .eplan.openIterator(epl_s, h_Bauteil, ITERTYPE_COMPONENT_PART) Einzelteil = .eplan.First(epl_s, iter_Einzelteile) If .eplan.Count(epl_s, iter_Einzelteile) > 0 Then .EPLAN_Status2 .eplan.Count(epl_s, iter_Einzelteile), 0 ' Schleife über alle Einzelteile Do While Einzelteil <> -1 .EPLAN_Status2 0, 1 ' Kontrolle, ob Einzelteil instanziiert (1750) und abs.Adresse vorhanden ist. If .eplan.getProperty(epl_s, Einzelteil, 1750) = "1" And Len(.eplan.getProperty(epl_s, Einzelteil, 13353)) > 0 Then ' Es handelt sich um eine SPS-Klemme ' Die Eigenschaften der SPS-Klemme werden gelesen. adresse = .eplan.getProperty(epl_s, Einzelteil, 13353) Funktion = .eplan.getProperty(epl_s, Einzelteil, 1003) seite = .eplan.getProperty(epl_s, Einzelteil, 1910) origZähler = .eplan.getProperty(epl_s, Einzelteil, 1108) ' Kontrolle, ob eine Funktion unter EPLAN eingetragen wurde. If Funktion = "" Then SPSDatenAusProjektLesen = True Print #FileNr, "BMK: " & .eplan.getProperty(epl_s, h_Bauteil, 5) & _ " - Adresse: " & .eplan.getProperty(epl_s, Einzelteil, 13353) & _ " ist ohne Angabe einer Funktion." End If If seite <> "" Then ' neuen Datensatz ablegen SPSDaten.AddNew SPSDaten!einbauort = .eplan.getProperty(epl_s, Einzelteil, 769) SPSDaten!symbolischeAdresse = .eplan.getProperty(epl_s, Einzelteil, 1094) ' Kontrolle, ob ein angeschlossenes BMK unter ELAN eingetragen wurde. If .eplan.getProperty(epl_s, Einzelteil, 1094) = "" Then SPSDatenAusProjektLesen = True Print #FileNr, "BMK: " & .eplan.getProperty(epl_s, h_Bauteil, 5) & _ " - Adresse: " & .eplan.getProperty(epl_s, Einzelteil, 13353) & _ " ist ohne Angabe eines angeschlossenen BMKs." End If ' digitaler Eingang If Left(adresse, 1) = "E" Then SPSDaten!einaus = "E" SPSDaten!adressealtbit = Right(adresse, 1) SPSDaten!adressealtbyte = Mid(adresse, 2, Len(adresse) - 2) SPSDaten!BMKZählerNr = 2 ' Kontrolle, ob die Kartenzugehörigkeit stimmt. If origZähler <> 2 Then Print #FileNr, "Der Eingang " & adresse & " liegt auf der Karte A00" & origZähler & ". Richtig: A002" ' digitaler Ausgang ElseIf Left(adresse, 1) = "A" Then SPSDaten!einaus = "A" SPSDaten!adressealtbit = Right(adresse, 1) SPSDaten!adressealtbyte = Mid(adresse, 2, Len(adresse) - 2) SPSDaten!BMKZählerNr = 1 ' Kontrolle, ob die Kartenzugehörigkeit stimmt. If origZähler <> 1 Then Print #FileNr, "Der Ausgang " & adresse & " liegt auf der Karte A00" & origZähler & ". Richtig: A001" ' analoger Eingang ElseIf Left(adresse, 3) = "PEW" Then SPSDaten!einaus = "PEW" SPSDaten!adressealtbyte = Right(adresse, Len(adresse) - 3) h_symbol = .eplan.getPropertyUser(epl_s, Einzelteil, PROPERTY_COMP_IND_SYMBOL) dummy = .eplan.getProperty(epl_s, h_symbol, 5) ' analoger Ausgang ElseIf Left(adresse, 3) = "PAW" Then SPSDaten!einaus = "PAW" SPSDaten!adressealtbyte = Right(adresse, Len(adresse) - 3) h_symbol = .eplan.getPropertyUser(epl_s, Einzelteil, PROPERTY_COMP_IND_SYMBOL) dummy = .eplan.getProperty(epl_s, h_symbol, 5) End If ' Kontrolle, ob die Kartenzugehörigkeit der analogen Ein- Ausgänge stimmt. If Left(adresse, 3) = "PAW" Or Left(adresse, 3) = "PEW" Then Select Case dummy Case "SPS_AA_U" SPSDaten!BMKZählerNr = 3 If origZähler <> 3 Then Print #FileNr, "Der analoge Ausgang Spannung " & adresse & " liegt auf der Karte A00" & origZähler & ". Richtig: A003" Case "SPS_AA_I" SPSDaten!BMKZählerNr = 4 If origZähler <> 4 Then Print #FileNr, "Der analoge Ausgang Strom " & adresse & " liegt auf der Karte A00" & origZähler & ". Richtig: A004" Case "SPS_AE_PTC" SPSDaten!BMKZählerNr = 7 If origZähler <> 7 Then Print #FileNr, "Der analoge Eingang PT100 " & adresse & " liegt auf der Karte A00" & origZähler & ". Richtig: A007" Case "SPS_AE_U" SPSDaten!BMKZählerNr = 5 If origZähler <> 5 Then Print #FileNr, "Der analoge Eingang Spannung " & adresse & " liegt auf der Karte A00" & origZähler & ". Richtig: A005" Case "SPS_AE_I" SPSDaten!BMKZählerNr = 6 If origZähler <> 6 Then Print #FileNr, "Der analoge Eingang Strom " & adresse & " liegt auf der Karte A00" & origZähler & ". Richtig: A006" End Select dummy = "" End If Pos = InStr(1, seite, "/", vbTextCompare) SPSDaten!GruppeNr = Left(seite, Pos - 1) SPSDaten!seite = Right(seite, Len(seite) - Pos) SPSDaten!funktionstextbmk = .deutscherText(Funktion) SPSDaten.Update End If ElseIf Len(.eplan.getProperty(epl_s, Einzelteil, 13353)) > 0 Then ' es extistiert eine nicht instanziierte SPS-Klemme. Dies wird jetzt ' gelöscht. Auch schon vorhandene Reserveklemmen werden gelöscht. h_command = .eplan.createCommand(epl_s, "EPLAN.EPLAN21.ELEMENT.CREATE_AND_INSTANTIATE") h_ret = .eplan.setHandleParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_PROJECT, h_project) h_ret = .eplan.setHandleParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_PAGE, h_Seite) h_ret = .eplan.setHandleParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_COMPONENT, Einzelteil) h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_X_POS, "40000") h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_Y_POS, "40000") h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_CREATE_ONLY, "0") h_ret = .eplan.executeCommand(epl_s, h_command) ' zu löschende SPS-Klemme in Iterator einfügen If h_ret <> -1 Then 'Löschliste erzeugen SPSLöschliste = .eplan.createEmptyIterator(epl_s, ITERTYPE_INSTANCES) erzeugtesteil = .eplan.getHandleParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_RESULT) h_ret = .eplan.Insert(epl_s, SPSLöschliste, erzeugtesteil) ' Löschliste löschen h_command = .eplan.createCommand(epl_s, "EPLAN.EPLAN21.OBJECT.DELETE") h_ret = .eplan.setHandleParam(epl_s, h_command, PARAM_OBJECT_DELETE_OBJECTS, SPSLöschliste) h_ret = .eplan.setParam(epl_s, h_command, PARAM_OBJECT_DELETE_DELETEMODE, "1") h_ret = .eplan.executeCommand(epl_s, h_command) h_ret = .eplan.closeObject(epl_s, SPSLöschliste) Else Print #FileNr, "Instanzierung einer SPS-Klemme" & _ " (" & .eplan.getProperty(epl_s, Einzelteil, 13353) & ") fehlgeschlagen." End If End If ' Verweis auf das nächste Einzelteil Einzelteil = .eplan.Next(epl_s, iter_Einzelteile) Loop End If ' Verweis auf das nächste Bauteil. h_Bauteil = .eplan.Next(epl_s, iter_Bauteile) Loop .EPLAN_Status1 0, 0 .EPLAN_Status2 0, 0 ' Die Datenbanktabelle für die vorwählbaren Reserveklemmen wird angelegt ' Öffnen DB-Tabelle mit allen vorhandenen Einbauorten sqlstr = "SELECT SPSKonfig.Einbauort " & _ "From SPSKonfig " & _ "GROUP BY SPSKonfig.Einbauort " & _ "ORDER BY SPSKonfig.Einbauort" Set rec = db.OpenRecordset(sqlstr) ' Öffnen DB-Tabelle mit Reserveklemmen sqlstr = "select spsReserveklemmen.* " & _ "from spsreserveklemmen" Set SPSDaten = db.OpenRecordset(sqlstr) ' Falls neuer Ort mit SPS-Klemmen hinzugekommen ist, so wird für ihn auch ' die Möglichkeit der Eingabe von Reserveklemmen geschaffen. If rec.RecordCount > 0 Then While Not rec.EOF dummy = "0" If SPSDaten.RecordCount > 0 Then SPSDaten.MoveLast SPSDaten.FindFirst "ort='" & rec!einbauort & "'" If SPSDaten.NoMatch Then dummy = "1" Else dummy = "1" End If If dummy = "1" Then SPSDaten.AddNew SPSDaten!ort = rec!einbauort SPSDaten.Update End If rec.MoveNext Wend End If ' Falls aus Ort SPS-Karte gelöscht wurde, so werden auch die Reserveklemmen gelöscht. If SPSDaten.RecordCount > 0 Then While Not SPSDaten.EOF dummy = "0" If rec.RecordCount > 0 Then rec.MoveLast rec.FindFirst "einbauort='" & SPSDaten!ort & "'" If rec.NoMatch Then dummy = "1" Else dummy = "1" End If If dummy = "1" Then SPSDaten.Delete SPSDaten.MoveNext Else SPSDaten.MoveNext End If Wend End If Print #FileNr, End With End Function Function ReserveklemmenAnlegen() Dim intByte As Integer Dim intBit As Integer Dim intmaxbyte As Integer Dim intmaxBit As Integer Dim i As Integer Dim rec As Recordset Dim rec2 As Recordset Dim EATyp As String ' Anlegend der Reserveklemmen. ' Zuerst werden die einzelnen SPS-Kästen untersucht, ob SPS-Klemmen gelöscht wurden. Dazu wird von der Startadressse bis zur ' letzten angelegten Klemme nichtexistierende Adressen gesucht und angelegt. ' Dann werden anhand der eingestellten Vorwahl die Reserveklemmen angelegt ' Anschließend werden die Module aufgefüllt. Reservezähler = 1 ' Überschrift Protokolldatei Print #FileNr, "Anlegen der Reserveklemmen." Print #FileNr, ' Kontrolle der digitalen Reserveklemmen im Gesamtverbund (wenn z.B. eine SPS-Klemme herausgelöscht wurde.) sqlstr = "SELECT SPSKonfig.Einbauort, SPSKonfig.BMKZählerNr, spskonfig.einaus, Count(SPSKonfig.Einbauort) AS Anzahl " & _ "From SPSKonfig " & _ "Where SPSKonfig.BMKZählerNr = 1 " & _ "Or SPSKonfig.BMKZählerNr = 2 " & _ "GROUP BY SPSKonfig.Einbauort, SPSKonfig.BMKZählerNr, spskonfig.einaus;" Set SPSAdressen = db.OpenRecordset(sqlstr, dbOpenSnapshot, dbForwardOnly) If SPSAdressen.RecordCount > 0 Then While Not SPSAdressen.EOF ObjEpl.EPLAN_Status1 0, 0, "Reserveklemmen für " & SPSAdressen!einbauort & " werden generiert" ' Lesen der Startadresse für die Baugruppe dieses Einbauortes sqlstr = "select sps_startadressen.startadresse " & _ "from sps_startadressen " & _ "where sps_startadressen.einbauort='" & SPSAdressen!einbauort & "'" Set rec = db.OpenRecordset(sqlstr) If rec.RecordCount > 0 Then intByte = rec!Startadresse intBit = 0 ' Lesen der letzen Adresse sqlstr = "SELECT Max(SPSKonfig.adresseneubyte) AS Max " & _ "From SPSKonfig " & _ "WHERE SPSKonfig.Einbauort='" & SPSAdressen!einbauort & "' " & _ "AND SPSKonfig.BMKZählerNr=" & SPSAdressen!BMKZählerNr Set rec = db.OpenRecordset(sqlstr) If rec.RecordCount > 0 Then intmaxbyte = rec!Max sqlstr = "SELECT Max(SPSKonfig.adresseneubit) AS Max " & _ "From SPSKonfig " & _ "WHERE SPSKonfig.Einbauort='" & SPSAdressen!einbauort & "' " & _ "AND SPSKonfig.BMKZählerNr=" & SPSAdressen!BMKZählerNr & " " & _ "AND SPSKonfig.adresseneubyte=" & intmaxbyte Set rec = db.OpenRecordset(sqlstr) If rec.RecordCount > 0 Then intmaxBit = rec!Max End If End If End If If intmaxbyte >= intByte And intBit <> intmaxBit And intmaxbyte < 150 Then If intByte - intmaxbyte > 10 Then Print #FileNr, "Für den Einbauort " & SPSAdressen!einbauort & " wurden keine Reserveklemmen eingefügt!" Print #FileNr, "Bitte erst neu adressieren." Else ' Schleife über alle Adressen von der Startadresse bis zur letzten Adresse i = 0 Do ' Kontrolle ob gesuchte Addresse vorhanden sqlstr = "SELECT SPSKonfig.* " & _ "From SPSKonfig " & _ "WHERE SPSKonfig.Einbauort='" & SPSAdressen!einbauort & "' " & _ "AND SPSKonfig.BMKZählerNr=" & SPSAdressen!BMKZählerNr & " " & _ "AND SPSKonfig.adresseneubyte=" & intByte & _ "AND SPSKonfig.adresseneubit=" & intBit Set rec = db.OpenRecordset(sqlstr) ' Anlegen einer neuen Adresse If rec.RecordCount = 0 Then rec.AddNew rec!einbauort = SPSAdressen!einbauort rec!einaus = SPSAdressen!einaus rec!BMKZählerNr = SPSAdressen!BMKZählerNr rec!adressealtbit = intBit rec!adressealtbyte = intByte rec!adresseneubit = intBit rec!adresseneubyte = intByte rec!funktionstextbmk = "Reserve " & Reservezähler rec!symbolischeAdresse = "zz1" rec.Update i = i + 1 Reservezähler = Reservezähler + 1 End If ' Adresse auf nächstes Bit stellen intBit = intBit + 1 If intBit = 8 Then intBit = 0 intByte = intByte + 1 End If Loop Until intByte = intmaxbyte And intBit = intmaxBit End If ' ' Anlegen von Reserveklemmen nach Vorgabe sqlstr = "select spsreserveklemmen.dig" & SPSAdressen!einaus & " as AnzahlRes " & _ "from spsreserveklemmen " & _ "where spsreserveklemmen.ort='" & SPSAdressen!einbauort & "'" Set rec2 = db.OpenRecordset(sqlstr, dbOpenSnapshot, dbForwardOnly) If rec2.RecordCount > 0 Then If rec2!anzahlres - i > 0 Then Do intBit = intBit + 1 If intBit = 8 Then intBit = 0 intByte = intByte + 1 End If rec.AddNew rec!einbauort = SPSAdressen!einbauort rec!einaus = SPSAdressen!einaus rec!BMKZählerNr = SPSAdressen!BMKZählerNr rec!adressealtbit = intBit rec!adressealtbyte = intByte rec!adresseneubit = intBit rec!adresseneubyte = intByte rec!funktionstextbmk = "Reserve " & Reservezähler rec!symbolischeAdresse = "zz1" rec.Update i = i + 1 Reservezähler = Reservezähler + 1 ' Adresse auf nächstes Bit stellen Loop Until rec2!anzahlres = i End If End If End If SPSAdressen.MoveNext Wend End If ' Kontrolle der analogen Reserveklemmen im Gesamtverbund (wenn z.B. eine SPS-Klemme herausgelöscht wurde.) sqlstr = "SELECT SPSKonfig.Einbauort, SPSKonfig.BMKZählerNr, spskonfig.einaus, Count(SPSKonfig.Einbauort) AS Anzahl " & _ "From SPSKonfig " & _ "Where SPSKonfig.BMKZählerNr = 3 " & _ "Or SPSKonfig.BMKZählerNr = 4 " & _ "Or SPSKonfig.BMKZählerNr = 5 " & _ "Or SPSKonfig.BMKZählerNr = 6 " & _ "Or SPSKonfig.BMKZählerNr = 7 " & _ "GROUP BY SPSKonfig.Einbauort, SPSKonfig.BMKZählerNr, spskonfig.einaus;" Set SPSAdressen = db.OpenRecordset(sqlstr, dbOpenSnapshot, dbForwardOnly) If SPSAdressen.RecordCount > 0 Then While Not SPSAdressen.EOF ObjEpl.EPLAN_Status1 0, 0, "Reserveklemmen für " & SPSAdressen!einbauort & " werden generiert" ' Lesen der Startadresse für die Baugruppe dieses Einbauortes sqlstr = "SELECT Min(SPSKonfig.adresseneubyte) AS [Min], Max(spskonfig.adresseneubyte) AS [Max] " & _ "From SPSKonfig " & _ "WHERE SPSKonfig.Einbauort='" & SPSAdressen!einbauort & "' " & _ "AND SPSKonfig.BMKZählerNr=" & SPSAdressen!BMKZählerNr Set rec = db.OpenRecordset(sqlstr) If rec.RecordCount > 0 Then If Val(rec!Min) > 0 Then intByte = rec!Min Else intByte = 0 If Val(rec!Max) > 0 Then intmaxbyte = rec!Max Else intmaxbyte = 0 intBit = 0 intmaxBit = 0 End If If intmaxbyte >= intByte And intByte > 0 And intmaxbyte > 0 And intmaxbyte < 150 Then ' Schleife über alle Adressen von der Startadresse bis zur letzten Adresse Do ' Kontrolle ob gesuchte Addresse vorhanden sqlstr = "SELECT SPSKonfig.* " & _ "From SPSKonfig " & _ "WHERE SPSKonfig.Einbauort='" & SPSAdressen!einbauort & "' " & _ "AND SPSKonfig.BMKZählerNr=" & SPSAdressen!BMKZählerNr & " " & _ "AND SPSKonfig.adresseneubyte=" & intByte & _ "AND SPSKonfig.adresseneubit=" & intBit Set rec = db.OpenRecordset(sqlstr) ' Anlegen einer neuen Adresse If rec.RecordCount = 0 Then rec.AddNew rec!einbauort = SPSAdressen!einbauort rec!einaus = SPSAdressen!einaus rec!BMKZählerNr = SPSAdressen!BMKZählerNr rec!adressealtbit = intBit rec!adressealtbyte = intByte rec!adresseneubit = intBit rec!adresseneubyte = intByte rec!funktionstextbmk = "Reserve " & Reservezähler rec!symbolischeAdresse = "zz1" rec.Update Reservezähler = Reservezähler + 1 End If ' Adresse auf nächstes Bit stellen intByte = intByte + 2 Loop Until intByte = intmaxbyte And intBit = intmaxBit End If SPSAdressen.MoveNext Wend End If ' Reserveklemmen anlegen um die Module aufzufüllen ' Anzahl Klemmen pro SPS-Kasten lesen sqlstr = "SELECT SPSKonfig.Einbauort, SPSKonfig.BMKZählerNr, spskonfig.einaus, Count(SPSKonfig.Einbauort) AS Anzahl " & _ "From SPSKonfig " & _ "Where SPSKonfig.BMKZählerNr = 1 " & _ "Or SPSKonfig.BMKZählerNr = 2 " & _ "Or SPSKonfig.BMKZählerNr = 3 " & _ "Or SPSKonfig.BMKZählerNr = 4 " & _ "Or SPSKonfig.BMKZählerNr = 5 " & _ "Or SPSKonfig.BMKZählerNr = 6 " & _ "Or SPSKonfig.BMKZählerNr = 7 " & _ "GROUP BY SPSKonfig.Einbauort, SPSKonfig.BMKZählerNr, spskonfig.einaus;" Set SPSAdressen = db.OpenRecordset(sqlstr, dbOpenSnapshot, dbForwardOnly) sqlstr = "SELECT spskonfig.* from SPSkonfig" Set datatemp = db.OpenRecordset(sqlstr) With SPSAdressen If .RecordCount > 0 Then While Not .EOF Select Case !BMKZählerNr 'digitale E/A bearbeiten Case 1, 2 ' letzte Adresse lesen sqlstr = "SELECT Max(SPSKonfig.adresseneubyte) AS Max " & _ "From SPSKonfig " & _ "WHERE SPSKonfig.Einbauort='" & SPSAdressen!einbauort & "' " & _ "AND SPSKonfig.BMKZählerNr=" & SPSAdressen!BMKZählerNr Set rec = db.OpenRecordset(sqlstr) If rec.RecordCount > 0 Then intmaxbyte = rec!Max sqlstr = "SELECT Max(SPSKonfig.adresseneubit) AS Max " & _ "From SPSKonfig " & _ "WHERE SPSKonfig.Einbauort='" & SPSAdressen!einbauort & "' " & _ "AND SPSKonfig.BMKZählerNr=" & SPSAdressen!BMKZählerNr & " " & _ "AND SPSKonfig.adresseneubyte=" & intmaxbyte Set rec = db.OpenRecordset(sqlstr) If rec.RecordCount > 0 Then intmaxBit = rec!Max End If End If intmaxBit = intmaxBit + 1 If intmaxBit > 7 Then intmaxBit = 0 intmaxbyte = intmaxbyte + 1 End If ' digitalen E/A anlegen in Datenbank Vielfachesvon 4, !anzahl, restwert For x = 0 To restwert - 1 datatemp.AddNew datatemp!einbauort = !einbauort datatemp!einaus = SPSAdressen!einaus datatemp!BMKZählerNr = !BMKZählerNr datatemp!adressealtbit = intmaxBit datatemp!adressealtbyte = intmaxbyte datatemp!adresseneubit = intmaxBit datatemp!adresseneubyte = intmaxbyte datatemp!funktionstextbmk = "Reserve " & Reservezähler datatemp!symbolischeAdresse = "zzz" datatemp.Update Reservezähler = Reservezähler + 1 intmaxBit = intmaxBit + 1 If intmaxBit > 7 Then intmaxBit = 0 intmaxbyte = intmaxbyte + 1 End If Next ' analoge Ausgänge bearbeiten Case 3, 4 ' letzte Adresse lesen sqlstr = "SELECT Max(spskonfig.adresseneubyte) AS [Max] " & _ "From SPSKonfig " & _ "WHERE SPSKonfig.Einbauort='" & SPSAdressen!einbauort & "' " & _ "AND SPSKonfig.BMKZählerNr=" & SPSAdressen!BMKZählerNr Set rec = db.OpenRecordset(sqlstr) If Val(rec!Max) > 0 Then intmaxbyte = Val(rec!Max) + 2 Else intmaxbyte = 998 Vielfachesvon 2, !anzahl, restwert For x = 0 To restwert - 1 datatemp.AddNew datatemp!einbauort = !einbauort datatemp!einaus = "PAW" datatemp!BMKZählerNr = !BMKZählerNr datatemp!adressealtbit = 0 datatemp!adressealtbyte = intmaxbyte datatemp!adresseneubit = 0 datatemp!adresseneubyte = intmaxbyte datatemp!funktionstextbmk = "Reserve " & Reservezähler datatemp!symbolischeAdresse = "zz1" datatemp.Update Reservezähler = Reservezähler + 1 intmaxbyte = intmaxbyte + 2 Next ' analoge Eingänge bearbeiten Case 5, 6, 7 ' Letzte Adresse lesen sqlstr = "SELECT Max(spskonfig.adresseneubyte) AS [Max] " & _ "From SPSKonfig " & _ "WHERE SPSKonfig.Einbauort='" & SPSAdressen!einbauort & "' " & _ "AND SPSKonfig.BMKZählerNr=" & SPSAdressen!BMKZählerNr Set rec = db.OpenRecordset(sqlstr) If Val(rec!Max) > 0 Then intmaxbyte = Val(rec!Max) + 2 Else intmaxbyte = 998 Vielfachesvon 2, !anzahl, restwert For x = 0 To restwert - 1 datatemp.AddNew datatemp!einbauort = !einbauort datatemp!einaus = "PEW" datatemp!BMKZählerNr = !BMKZählerNr datatemp!adressealtbit = 0 datatemp!adressealtbyte = intmaxbyte datatemp!adresseneubit = 0 datatemp!adresseneubyte = intmaxbyte datatemp!funktionstextbmk = "Reserve " & Reservezähler datatemp!symbolischeAdresse = "zz1" datatemp.Update Reservezähler = Reservezähler + 1 Next End Select .MoveNext Wend End If End With End Function Function AdressenÄndern(beibehalten As Boolean) ' ' Prozedur zum tauschen der absoluten Adressen der SPS. Die aus Eplan gelesenen Adressen ' werden entsprechend der dem Einbauort vorgegebenen Startadressen angepaßt. ' Ziel : Projektdatenbank, Tabelle SPSKonfig ' ' Definition der Artikelnummern der SPS-Module Artikelnummer(1) = 7963876 'digitales Ausgangsmodul ' Artikelnummer(2) = 7963863 'digitales Eingangsmodul ' Artikelnummer(3) = 7963922 'analoges Ausgangsmodul Spannung Artikelnummer(4) = 7963935 'analoges Ausgangsmodul Strom ' Artikelnummer(5) = 7963892 'analoges Eingangsmodul Spannung Artikelnummer(6) = 7963919 'analoges Eingangsmodul Strom Artikelnummer(7) = 7963948 'Analoges Eingangsmodul PT100 ' ' Öffnen Zieltabelle sqlstr = "SELECT SPSKonfig.* " + _ "From SPSKonfig " + _ "Where SPSKonfig.bmkzählernr <> 0 " + _ "ORDER BY SPSKonfig.Einbauort, SPSKonfig.BMKZählerNr, SPSKonfig.SymbolischeAdresse, SPSKonfig.FunktionstextBMK;" Set SPSAdressen = db.OpenRecordset(sqlstr) ' ' Überschrift Protokolldatei Print #FileNr, "Ändern der SPS-Adressen" If Not beibehalten Then Print #FileNr, "Einstellung: Adressen werden nicht geändert!" Else Print #FileNr, "Einstellung: Adressen werden neu numeriert!" End If Print #FileNr, With SPSAdressen If .RecordCount <> 0 Then While Not .EOF ' ' Es werden in diesem Programmteil nur die digitalen Ein/Ausgänge verarbeitet. ' ' Änderung des Einbauortes? If aktEinbauort <> !einbauort Then aktEinbauort = !einbauort ' ' Lesen der Startadresse sqlstr = "SELECT SPS_Startadressen.Startadresse, sps_startadressen.startadresseanalog From SPS_Startadressen WHERE (((SPS_Startadressen.Einbauort)='" + aktEinbauort + "'));" Set SPSStart = odb.OpenRecordset(sqlstr, dbOpenSnapshot, dbForwardOnly) If SPSStart.RecordCount > 0 Then Startadresse = SPSStart!Startadresse StartadresseANA = SPSStart!startadresseanalog Else MessageBox eplansteuerung.hwnd, "Der Einbauort " & aktEinbauort & " ist dem SPS-Bearbeitungssystem unbekannt" + vbCr + vbCr + vbCr + vbCr + "Die kann zu Fehlern wie Doppelbelegungen von Adressen führen!" + vbCr + vbCr + "Der Administrator muß den fehlenden Ort incl. der Startadresse einpflegen." + vbCr + vbCr + vbCr + "Eine Protokolldatei der Doppelbelegungen wird im Anschluß der Bearbeitung erstellt.", "Fehlermeldung", MB_OK + MB_ICONHAND End If AdressenANAein = StartadresseANA AdressenANAaus = StartadresseANA Byteneu = Startadresse Bitneu = 0 End If ' ' Änderung der BMK-Zähler Nummer? Wenn ja, dann wurde der SPS-Klemmentyp geändert und es muß die Analogstartadresse ' neu festgelegt werden. If aktBMKZählerNr <> !BMKZählerNr Then aktBMKZählerNr = !BMKZählerNr If Vielfachesvon(4, AdressenANAein - StartadresseANA) = False Then AdressenANAein = AdressenANAein + 2 End If If Vielfachesvon(4, AdressenANAaus - StartadresseANA) = False Then AdressenANAaus = AdressenANAaus + 2 End If Byteneu = Startadresse Bitneu = 0 End If ' ' Bearbeitung der Ein/Ausgänge .Edit If Not beibehalten Then Byteneu = !adressealtbyte Bitneu = !adressealtbit AdressenANAaus = !adressealtbyte AdressenANAein = !adressealtbyte End If Select Case aktBMKZählerNr Case 1, 2 ' Klemmennummerzuordnung der digitalen Ein/Ausgänge !adresseneubyte = Byteneu !adresseneubit = Bitneu Bitneu = Bitneu + 1 If Bitneu = 8 Then Bitneu = 0 Byteneu = Byteneu + 1 End If Select Case aktBMKZählerNr Case 1 'digitaler Eingang !Artikelnummer = Artikelnummer(1) Case 2 'digitaler Ausgang !Artikelnummer = Artikelnummer(2) End Select Case 3, 4 ' Klemmennummerzuordnung der analoger Ausgänge !adresseneubyte = AdressenANAaus AdressenANAaus = AdressenANAaus + 2 Select Case aktBMKZählerNr Case 3 ' analoger Ausgang Spannung !Artikelnummer = Artikelnummer(3) Case 4 ' analoger Ausgang Strom !Artikelnummer = Artikelnummer(4) End Select Case 5, 6, 7 ' Klemmennummerzuordnung der analoger Eingänge !adresseneubyte = AdressenANAein AdressenANAein = AdressenANAein + 2 Select Case aktBMKZählerNr Case 5 ' analoger Eingang (PT100) !Artikelnummer = Artikelnummer(5) Case 6 ' analoger Eingang Spannung !Artikelnummer = Artikelnummer(6) Case 7 ' analoger Eingang Strom !Artikelnummer = Artikelnummer(7) End Select End Select .Update .MoveNext Wend End If End With End Function Sub KlemmenZuordnen() Dim altEB As String sqlstr = "SELECT SPSKonfig.Einbauort, SPSKonfig.BMKZählerNr, SPSKonfig.adresseneubyte, SPSKonfig.adresseneubit, " & _ "SPSKonfig.Klemmeneu1, SPSKonfig.Klemmeneu2, SPSKonfig.Klemmeneu3, SPSKonfig.Klemmeneu4, SPSKonfig.AnzahlModuleproBMK " & _ "From SPSKonfig " & _ "ORDER BY SPSKonfig.Einbauort, SPSKonfig.BMKZählerNr, SPSKonfig.adresseneubyte, SPSKonfig.adresseneubit;" Set SPSAdressen = db.OpenRecordset(sqlstr) ' ' Überschrift Protokolldatei Print #FileNr, "Die Klemmennummern werden zugeordnet" Print #FileNr, With SPSAdressen If .RecordCount > 0 Then While Not .EOF If altEB <> !einbauort Then altEB = !einbauort sqlstr = "SELECT SPS_Startadressen.Startadresse, sps_startadressen.startadresseanalog From SPS_Startadressen WHERE (((SPS_Startadressen.Einbauort)='" + SPSAdressen!einbauort + "'));" Set SPSStart = odb.OpenRecordset(sqlstr, dbOpenSnapshot, dbForwardOnly) If SPSStart.RecordCount > 0 Then StartadresseANA = SPSStart!startadresseanalog End If End If ' ' Berechnung der Modulanzahl sqlstr = "SELECT Count(spskonfig.Einbauort) AS Anzahl " + _ "From SPSKonfig " + _ "WHERE SPSKonfig.Einbauort='" + !einbauort + "' AND SPSKonfig.BMKZählerNr=" + Format(!BMKZählerNr) 'Debug.Print sqlstr Set datatemp = db.OpenRecordset(sqlstr, dbOpenSnapshot, dbForwardOnly) .Edit Select Case !BMKZählerNr Case 1, 2 ' Klemmennummerzuordnung der digitalen Ein/Ausgänge !AnzahlModuleProBMK = Format(Round((datatemp!anzahl / 4) + 0.4999)) Select Case !adresseneubit Case 0, 4 !Klemmeneu1 = 1 !Klemmeneu2 = 3 Case 1, 5 !Klemmeneu1 = 5 !Klemmeneu2 = 7 Case 2, 6 !Klemmeneu1 = 2 !Klemmeneu2 = 4 Case 3, 7 !Klemmeneu1 = 6 !Klemmeneu2 = 8 End Select Case 3, 4 ' Klemmennummerzuordnung der analoger Ausgänge !AnzahlModuleProBMK = Format(Round((datatemp!anzahl / 2) + 0.4999)) If Vielfachesvon(4, !adresseneubyte - StartadresseANA) Then !Klemmeneu1 = 1 !Klemmeneu2 = 2 !klemmeneu3 = 3 !klemmeneu4 = 4 Else !Klemmeneu1 = 5 !Klemmeneu2 = 6 !klemmeneu3 = 7 !klemmeneu4 = 8 End If Case 5, 6, 7 ' Klemmennummerzuordnung der analoger Eingänge !AnzahlModuleProBMK = Format(Round((datatemp!anzahl / 2) + 0.4999)) If Vielfachesvon(4, !adresseneubyte - StartadresseANA) Then !Klemmeneu1 = 1 !Klemmeneu2 = 2 !klemmeneu3 = 3 !klemmeneu4 = 4 Else !Klemmeneu1 = 5 !Klemmeneu2 = 6 !klemmeneu3 = 7 !klemmeneu4 = 8 End If End Select .Update .MoveNext Wend End If End With End Sub Function ModulNummerEintragen() sqlstr = "SELECT SPSKonfig.* " + _ "From SPSKonfig " + _ "ORDER BY SPSKonfig.Einbauort, SPSKonfig.BMKZählerNr, SPSKonfig.adresseneubyte, SPSKonfig.adresseneubit;" Set datatemp = db.OpenRecordset(sqlstr) Dim AlterEinbauort As String Dim AnzahlKlemmenAufModul As Integer Dim AlteSPSKarte As Integer Dim ersteAnalagKlemme As Boolean Dim Nr As Integer With datatemp If .RecordCount > 0 Then While Not .EOF ' Kontrolle, ob Einbauortwechsel If AlterEinbauort <> !einbauort Then AlterEinbauort = !einbauort AnzahlKlemmenAufModul = -1 ersteAnalagKlemme = False Nr = 2 AlteSPSKarte = !BMKZählerNr End If AnzahlKlemmenAufModul = AnzahlKlemmenAufModul + 1 ' Kontrolle, ob Spskartenwechsel If AlteSPSKarte <> !BMKZählerNr Then AlteSPSKarte = !BMKZählerNr Nr = Nr + 1 AnzahlKlemmenAufModul = 0 End If Select Case !BMKZählerNr Case 1, 2 ' Digitalmodul voll (4 SPS-Klemmen) If AnzahlKlemmenAufModul = 4 Then Nr = Nr + 1 AnzahlKlemmenAufModul = 0 End If Case 3, 4, 5, 6, 7 ' Abfrage ob aktuelle Klemme ist analog. Dann muss ' für das zweite Powermodul ein Platz reserviert werden. If ersteAnalagKlemme = False Then Nr = Nr + 1 ersteAnalagKlemme = True End If ' Analogmodul voll (2 SPS-Klemmen) If AnzahlKlemmenAufModul = 2 Then Nr = Nr + 1 AnzahlKlemmenAufModul = 0 End If End Select .Edit !modulnr = Nr .Update .MoveNext Wend End If End With End Function Function KontrolleDoppelbelegung() ' ' Kontrolle der SPS-Daten auf Doppelbelegung sqlstr = "SELECT [einaus], [adresseneubit], [adresseneubyte], [Einbauort], [SymbolischeAdresse], [FunktionstextBMK] " + _ "From SPSKonfig " + _ "WHERE [einaus] In (SELECT [einaus] FROM [SPSKonfig] As Tmp GROUP BY [einaus],[adresseneubit],[adresseneubyte] HAVING Count(*)>1 And [adresseneubit] = [SPSKonfig].[adresseneubit] And [adresseneubyte] = [SPSKonfig].[adresseneubyte]) " + _ "ORDER BY [einaus], [adresseneubit], [adresseneubyte];" Set SPSDaten = db.OpenRecordset(sqlstr, dbOpenDynaset, dbForwardOnly) ' ' Überschrift Protokolldatei Print #FileNr, "Kontrolle der Doppelbelegungen" Print #FileNr, With SPSDaten If .RecordCount > 0 Then MessageBox eplansteuerung.hwnd, "Es haben sich Doppelbelegungen von Adressen ergeben." + vbCr + "Dies kann zwei Gründe haben:" + vbCr + vbCr + " 1. Ein Einbauort ist dem System unbekannt (Administrator muß neuen Einbauort incl Startadresse einpfegen." + vbCr + " 2. Der vom System zur Verfügung gestellter Adressbereich ist zu klein. System anpassen (neue Startadresse vergeben [Administartor])" + vbCr + vbCr + vbCr + "Im Projektverzeichnis wird eine Protokolldatei angelegt.", "ACHTUNG Doppelbelegung", MB_OK + MB_ICONHAND Print #FileNr, "Doppelbelegungen von SPS-Adressen"; Tab(40); Projektname; Tab(65); "Datum= " & Date While Not .EOF If !einaus = "E" Or !einaus = "A" Then If dummy <> !einaus + " " & !adresseneubyte & "." & !adresseneubit Then Print #FileNr, dummy = !einaus + " " & !adresseneubyte & "." & !adresseneubit Else If dummy <> !einaus + " " & !adresseneubyte Then Print #FileNr, dummy = !einaus + " " & !adresseneubyte End If Print #FileNr, !einbauort; Tab(5); dummy; Tab(20); !symbolischeAdresse + "_" + !funktionstextbmk .MoveNext Wend End If End With End Function Function ReserveKlemmenInsProjekt() With ObjEpl ' Überschrift Protokolldatei Print #FileNr, "Schreiben von Reserveklemmen ins Projekt" Print #FileNr, ' Erzeugen der Reserveklemmen im Projekt .EPLAN_Status1 0, 0, "Reserveklemmen werden im Projekt angelegt." ' Zugriff auf alle Bauteile des Projektes iter_Bauteile = .eplan.openIterator(epl_s, h_project, ITERTYPE_DEVICETAGS) h_Bauteil = .eplan.First(epl_s, iter_Bauteile) .EPLAN_Status1 .eplan.Count(epl_s, iter_Bauteile), 0 ' Schleife über alle Bauteile Do While h_Bauteil <> -1 .EPLAN_Status1 0, 1 ' ' Wenn das Anlagenkennzeichen 051 gefunden wird handelt es sich um eine SPS-Klemme/Kasten If .eplan.getProperty(epl_s, h_Bauteil, 768) = "051" Then ' Kontrolle, ob es sich um eine SPS-Karte handelt. If .eplan.getProperty(epl_s, h_Bauteil, 1121) = "1" Then ' ' Zugriff auf alle Einzelteile eines Bauteils. iter_Einzelteile = .eplan.openIterator(epl_s, h_Bauteil, ITERTYPE_COMPONENT_PART) Einzelteil = .eplan.First(epl_s, iter_Einzelteile) ' Schleife über alle Einzelteile While Einzelteil <> -1 ' Kontrolle, obe es sich um einen SPS-kasten handelt. If .eplan.getProperty(epl_s, Einzelteil, 6) = "SPS-Kasten" Then einbauort = .eplan.getProperty(epl_s, h_Bauteil, 769) Zählernr = .eplan.getProperty(epl_s, h_Bauteil, 1108) ' Lesen der Reserveklemmen aus der Datenbank sqlstr = "SELECT SPSKonfig.* " + _ "From SPSKonfig " + _ "WHERE (((SPSKonfig.FunktionstextBMK)like'Reserve*') AND ((SPSKonfig.Einbauort)='" & einbauort & "') AND ((SPSKonfig.BMKZählerNr)=" & Zählernr & "));" Set datatemp = db.OpenRecordset(sqlstr, dbOpenSnapshot, dbForwardOnly) ' Kontrolle, ob Reserveklemmen vorhanden sind If datatemp.RecordCount > 0 Then 'Schleife über alle Reserveklemmen While Not datatemp.EOF ' Command erzeugen, um nichtinstanziierte SPS-Klemme zu erzeugen. h_command = .eplan.createCommand(epl_s, "EPLAN.EPLAN21.ELEMENT.CREATE_AND_INSTANTIATE") h_ret = .eplan.setHandleParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_PROJECT, h_project) h_ret = .eplan.setHandleParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_PARENT, Einzelteil) h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_CREATE_ONLY, "1") h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_SYMFILE, "special_mon") h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_SYMVAR, "0") Select Case Zählernr ' digitaler Ausgang Case 1 h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_BOXTYPE, "2") h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_SYMNR, "59") ' digitaler Eingang Case 2 h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_BOXTYPE, "1") h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_SYMNR, "14") ' analoger Ausgang Spannung Case 3 h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_BOXTYPE, "4") h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_SYMNR, "64") ' analoger Ausgang Strom Case 4 h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_BOXTYPE, "4") h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_SYMNR, "60") ' analoger Eingang Spannung Case 5 h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_BOXTYPE, "3") h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_SYMNR, "63") ' analoger Eingang Strom Case 6 h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_BOXTYPE, "3") h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_SYMNR, "62") ' analoger Eingang PT100 Case 7 h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_BOXTYPE, "3") h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_SYMNR, "61") End Select h_ret = .eplan.setParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_PLCTYPE, "1") h_ret = .eplan.executeCommand(epl_s, h_command) If h_ret = -1 Then Print #FileNr, "Fehler beim Anlegen einer Reserveklemme." Else ' lesen des Handles der erzeugten Reserveklemme. h_symbol = .eplan.getHandleParam(epl_s, h_command, PARAM_ELEMENT_CREATE_AND_INSTANTIATE_RESULTCOMPONENT) If h_symbol = -1 Then Print #FileNr, "Fehler beim Lesen des Handles der zuletzt erzeugten Reserveklemme." Else h_ret = .eplan.setProperty(epl_s, h_symbol, 1078, datatemp!modulnr & "/" & datatemp!Klemmeneu1) h_ret = .eplan.setProperty(epl_s, h_symbol, 1134, datatemp!modulnr & "/" & datatemp!Klemmeneu2) h_ret = .eplan.setProperty(epl_s, h_symbol, 1135, datatemp!modulnr & "/" & datatemp!klemmeneu3) h_ret = .eplan.setProperty(epl_s, h_symbol, 1136, datatemp!modulnr & "/" & datatemp!klemmeneu4) h_ret = .eplan.setProperty(epl_s, h_symbol, 1003, "@V=00@01=;DE=" & datatemp!funktionstextbmk) Select Case Zählernr Case 1, 2: h_ret = .eplan.setProperty(epl_s, h_symbol, 13353, datatemp!einaus & datatemp!adresseneubyte & "." & datatemp!adresseneubit) Case 3, 4, 5, 6, 7: h_ret = .eplan.setProperty(epl_s, h_symbol, 13353, datatemp!einaus & Format(datatemp!adresseneubyte)) End Select End If End If datatemp.MoveNext Wend End If End If Einzelteil = .eplan.Next(epl_s, iter_Einzelteile) Wend End If End If h_Bauteil = .eplan.Next(epl_s, iter_Bauteile) Loop End With End Function Function DatenInsProjektSchreiben() With ObjEpl ' Daten werden jetzt wieder ins Projekt zurückgeschrieben. .EPLAN_Status1 0, 0, "Daten werden ins Projekt zurückgeschrieben." ' Zugriff auf alle Bauteile des Projektes iter_Bauteile = .eplan.openIterator(epl_s, h_project, ITERTYPE_DEVICETAGS) h_Bauteil = .eplan.First(epl_s, iter_Bauteile) ' Überschrift Protokolldatei Print #FileNr, "Schreiben der Daten zurück ins Projekt" .EPLAN_Status1 .eplan.Count(epl_s, iter_Bauteile), 0 ' Schleife über alle Bauteile Do While h_Bauteil <> -1 .EPLAN_Status1 0, 1 ' ' Wenn das Anlagenkennzeichen 051 gefunden wird handelt es sich um eine SPS-Klemme If .eplan.getProperty(epl_s, h_Bauteil, 768) = "051" Then ' ' Zugriff auf alle Einzelteile des Bauteils iter_Einzelteile = .eplan.openIterator(epl_s, h_Bauteil, ITERTYPE_COMPONENT_PART) Einzelteil = .eplan.First(epl_s, iter_Einzelteile) .EPLAN_Status2 .eplan.Count(epl_s, iter_Einzelteile), 0 ' Schleife über alle Einzelteile eines Bauteils Do While Einzelteil <> -1 .EPLAN_Status2 0, 1 adresse = .eplan.getProperty(epl_s, Einzelteil, 13353) Funktion = .eplan.getProperty(epl_s, Einzelteil, 1003) ' lesen des deutschen Textes aus der Funktion If Len(Funktion) > 0 Then Funktion = .deutscherText(Funktion) ' Kontrolle ob Adresse und Funktionstext gültig If Len(adresse) > 3 And Len(Funktion) > 0 Then If Left(adresse, 1) = "P" Then Präfix = Left(adresse, 3) bytenr = Right(adresse, Len(adresse) - 3) ' Selektion des Datensatzes sqlstr = "SELECT spskonfig.* From spskonfig WHERE spskonfig.FunktionstextBMK='" + Funktion + "' and spskonfig.einaus='" + Präfix + "' and spskonfig.adressealtbyte=" + bytenr Set SPSDaten = db.OpenRecordset(sqlstr) If SPSDaten.RecordCount <> 0 Then h_ret = .eplan.setProperty(epl_s, Einzelteil, 1078, SPSDaten!modulnr & "/" & SPSDaten!Klemmeneu1) h_ret = .eplan.setProperty(epl_s, Einzelteil, 1134, SPSDaten!modulnr & "/" & SPSDaten!Klemmeneu2) h_ret = .eplan.setProperty(epl_s, Einzelteil, 1135, SPSDaten!modulnr & "/" & SPSDaten!klemmeneu3) h_ret = .eplan.setProperty(epl_s, Einzelteil, 1136, SPSDaten!modulnr & "/" & SPSDaten!klemmeneu4) h_ret = .eplan.setProperty(epl_s, Einzelteil, 13353, SPSDaten!einaus + Format(SPSDaten!adresseneubyte)) ' ' Kennung eintragen, daß der Datensatz gelesen wurde SPSDaten.Edit SPSDaten!symbol = "X" SPSDaten.Update Else ' iter_delete = .eplan.createEmptyIterator(epl_s, ITERTYPE_COMPONENT_PART) ' h_ret = .eplan.Insert(epl_s, iter_delete, Einzelteil) ' ' h_command = .eplan.createCommand(epl_s, "EPLAN.EPLAN21.OBJECT.DELETE") ' h_ret = .eplan.setHandleParam(epl_s, h_command, PARAM_OBJECT_DELETE_OBJECTS, iter_delete) ' h_ret = .eplan.SetParam(epl_s, h_command, PARAM_OBJECT_DELETE_DELETEMODE, "1") ' h_ret = .eplan.executeCommand(epl_s, h_command) End If Else Präfix = Left(adresse, 1) bitnr = Right(adresse, 1) bytenr = Mid(adresse, 2, Len(adresse) - 3) sqlstr = "SELECT spskonfig.* From spskonfig WHERE spskonfig.FunktionstextBMK='" + Funktion + "' and spskonfig.einaus='" + Präfix + "' and spskonfig.adressealtbyte=" + bytenr + " and spskonfig.adressealtbit=" + bitnr Set SPSDaten = db.OpenRecordset(sqlstr) If SPSDaten.RecordCount <> 0 Then h_ret = .eplan.setProperty(epl_s, Einzelteil, 1078, SPSDaten!modulnr & "/" & SPSDaten!Klemmeneu1) h_ret = .eplan.setProperty(epl_s, Einzelteil, 1134, SPSDaten!modulnr & "/" & SPSDaten!Klemmeneu2) h_ret = .eplan.setProperty(epl_s, Einzelteil, 13353, SPSDaten!einaus + Format(SPSDaten!adresseneubyte) + "." + Format(SPSDaten!adresseneubit)) ' ' Kennung eintragen, daß der Datensatz gelesen wurde SPSDaten.Edit SPSDaten!symbol = "X" SPSDaten.Update Else ' iter_delete = .eplan.createEmptyIterator(epl_s, ITERTYPE_COMPONENT_PART) ' h_ret = .eplan.Insert(epl_s, iter_delete, Einzelteil) ' ' h_command = .eplan.createCommand(epl_s, "EPLAN.EPLAN21.OBJECT.DELETE") ' h_ret = .eplan.setHandleParam(epl_s, h_command, PARAM_OBJECT_DELETE_OBJECTS, iter_delete) ' h_ret = .eplan.SetParam(epl_s, h_command, PARAM_OBJECT_DELETE_DELETEMODE, "1") ' h_ret = .eplan.executeCommand(epl_s, h_command) End If End If ' ' zugriff auf Artikel des Einzelteils iter_parts = .eplan.openIterator(epl_s, h_Bauteil, ITERTYPE_PARTS) part = .eplan.Count(epl_s, iter_parts) If SPSDaten.RecordCount > 0 Then If part > 0 Then part = .eplan.First(epl_s, iter_parts) If Val(SPSDaten!Artikelnummer) > 0 Then h_ret = .eplan.setProperty(epl_s, part, 8001, SPSDaten!Artikelnummer) If Val(SPSDaten!AnzahlModuleProBMK) > 0 Then h_ret = .eplan.setProperty(epl_s, part, 8002, SPSDaten!AnzahlModuleProBMK) Else part = .eplan.createCommand(epl_s, "EPLAN.EPLAN21.PART.CREATE") h_ret = .eplan.setHandleParam(epl_s, part, PARAM_PART_CREATE_COMPONENT, h_Bauteil) If Val(SPSDaten!AnzahlModuleProBMK) > 0 Then h_ret = .eplan.setParam(epl_s, part, PARAM_PART_CREATE_COUNT, SPSDaten!AnzahlModuleProBMK) If Val(SPSDaten!Artikelnummer) > 0 Then h_ret = .eplan.setParam(epl_s, part, PARAM_PART_CREATE_NUMBER, SPSDaten!Artikelnummer) h_ret = .eplan.executeCommand(epl_s, part) End If End If End If ' Verweis auf das nächste Einzelteil Einzelteil = .eplan.Next(epl_s, iter_Einzelteile) Loop End If ' Verweis auf das nächste Bauteil. h_Bauteil = .eplan.Next(epl_s, iter_Bauteile) Loop .EPLAN_Status1 0, 0 .EPLAN_Status2 0, 0 End With End Function Function AuswertelistenErzeugen() With ObjEpl ' ' SPS-Übersichtsliste digitale E/A Liste_Filter = "5:[12]" Liste_Sortier = "13353" Kopf_Filter = ";1108<13350>: [12]" Kopf_Sortier = "769" .Auswerteliste_generieren epl_s, h_project, False, True, "MON_SPS_DIA_digital", Liste_Filter, Liste_Sortier, Kopf_Filter, Kopf_Sortier, "1101" ' SPS-Übersichtsliste analoge E/A Liste_Filter = "5:[12]" Liste_Sortier = "13353" Kopf_Filter = ";1108<13350>: [34567]" Kopf_Sortier = "769" .Auswerteliste_generieren epl_s, h_project, False, True, "MON_SPS_DIA_analog", Liste_Filter, Liste_Sortier, Kopf_Filter, Kopf_Sortier, "1102" End With End Function