Twincat3, Solution für mehrere Maschinen mit gemeinsamen FBs

alb

Level-1
Beiträge
68
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

ich habe eine Reihe von ähnlichen Maschinen. Die Steuerungen sind so strukturiert, dass etwa 90% der FBs gleich sind. Die Unterschiede zwischen den Maschinen stecken in den restlichen 10 %. Bisher hat jede Maschine ihre eigene Solution. Es wird aber langsam sehr aufwendig die Änderungen an den gemeinsamen 90 % in die diversen Einzel-Solutions zu übertragen. Besonders ungünstig ist folgendes Szenario:

Änderung an Maschine A. Projektdatei von A wird auf dem Server abgelegt. Bevor sich eine Gelegenheit ergibt, die Änderungen auf die Maschinen B und C zu übertragen, haben B und C bereits ihre eigenen Änderungen entwickelt. Dann sitzt man mit dem Projektvergleichstool und vergleicht A mit B und C, B mit C und A, C mit A und B. Dabei muss man jedes Mal prüfen, ob die Änderungen den maschinenspezifischen Teil betreffen (kein Problem) oder den allgemeinen Teil (übertragen, aufspielen, testen, freigeben). Das Skaliert sehr schlecht!

Mein erster Ansatz war es, die gemeinsamen FBs in eine Library zu packen, welche dann in die einzelnen Projekte eingebunden wird. Nachteil ist aber, dass bei Änderungen an der Library kein Onlinechange mehr möglich ist. Das würde die Entwicklungsarbeit sehr behindern.

Ich könnte mir Folgendes vorstellen:

Eine Solution mit mehreren Projekten. Ein Projekt pro Maschine, dass die Hardware und die Maschinenspezifischen FBs enthält. Ein Projekt mit den allgemeinen FBs. Alles in einer Solution. Das Szenario sähe jetzt so aus: Änderung an Maschine A, Vergleich mit der letzten Version auf dem Server. Im Projektvergleich sieht man direkt, ob sich die Änderungen auf das maschinenspezifische Projekt beschränken (-> einfach einchecken), oder ob allgemeine Programmteile betroffen sind (-> erstmal Nebenversion, einchecken nach Test auf den anderen Maschinen). Man musste nur noch einen Projektvergleich machen und könnte sich darauf verlassen, dass der allgemeine Teil wirklich immer gleich ist.

Problem: FBs aus anderen Projekten können nicht genutzt werden. Was im Allgemeinen auch irgendwie sinnvoll ist ;-)

Mit dem Beckhoff Variantenmanagement habe ich schon etwas herumexperimentiert, bin damit aber noch nicht richtig warm geworden. Das führt bei mir zu eher unübersichtlichen Konstrukten. Kann aber auch sein, dass ich das System ungeschickt benutze.

Wie handhabt ihr das? Da es immer viele Wege zum Ziel gibt, schreibe ich mal noch ein paar Worte zu meinen Randbedingungen und Überlegungen:
  • Versionsverwaltung mit Git.
  • Es sind Entwicklungsmaschinen, an denen häufiger Anpassungen vorgenommen werden. Know-How-Protection und Zugriffsschutz spielen keine große Rolle.
  • Entwicklung und Tests meist lokal an den Maschinen während Wartungs- und Stillstandszeiten.
  • Es sollte möglichst einfach und übersichtlich funktionieren. Besonders wichtig wäre mir, dass es für den Entwickler immer offensichtlich ist, ob er einen maschinenspezifischem FB oder an einem allgemeinen FB vor sich hat.
  • Bisher werden Änderungen an den gemeinsamen Programmteilen bei Gelegenheit auf die anderen Maschinen übertragen, getestet und dann freigegeben.
Bin für alle Tipps und Denkanstöße dankbar.

Lieben Gruß
alb
 
Es wird aber langsam sehr aufwendig die Änderungen an den gemeinsamen 90 % in die diversen Einzel-Solutions zu übertragen.
Willst Du denn bei jeder FB-Änderung die Änderung in alle Maschinen weltweit einspielen??? Wie behältst Du da den Überblick, welche Programmversion tatsächlich in der Maschine Nr. xyz ist? Nach Auslieferung einer Maschine sollte das Programm nicht mehr von irgendwelchen sich später ändernden/weiterentwickelten Software-Teilen abhängig sein, sondern es sollte ein eigenständiges Projekt werden.

Harald
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Irgend einen Tod wirst du wohl sterben müssen. Ich bevorzuge die Variante:
Allgemeine FB's welche nicht für jede Maschine geändert werden müssen werden in ein oder mehreren Librarys gehalten, welche mit Git verwaltet werden.
Wenn eine Maschine hochgerüstet werden soll wird die entsprechende Lib installiert und hochgerüstet, anschließend neu eingespielt. Da jede Änderung innerhalb der Lib die Version erhöht, ist in Git alles sauber dokumentiert und kein Stand geht verloren.

-Stirni
 
Ich betreue ein Projekt mit ca. 30 Anlagen, es gibt nur ein Programm, das über eine sehr große Parameterdatei (DB) die spezifischen Funktionen an- oder abschaltet.
Leider gibt es 30 Hardwarekonfigurationen.
 
Ich würde das Variantenmanagement empfehlen, aber da bist Du ja nicht so wirklich glücklich mit. Was meinst Du mit unübersichtlichen Konstrukten? Ja, das mit den Pragmas ist zunächst etwas gewöhnungsbedürftig, aber bei entsprechender Kommentierung sollte das gehen. Das Variantenmanagement hat ja auch den Vorteil, dass Du, im gewissen Rahmen, sogar unterschiedliche Hardware in einem Projekt haben kannst und unterschiedliche Verknüpfungen.
Ich kann es gerade leider nicht nachprüfen, aber ich meine, dass bei Änderungen an einer Bibliothek sehr wohl ein Online-Change möglich ist. Ist dieser nicht möglich, wäre er auch nicht möglich, wären die Änderungen direkt im Projekt ausgeführt worden.
 
Mein erster Ansatz war es, die gemeinsamen FBs in eine Library zu packen, welche dann in die einzelnen Projekte eingebunden wird. Nachteil ist aber, dass bei Änderungen an der Library kein Onlinechange mehr möglich ist. Das würde die Entwicklungsarbeit sehr behindern.
[...]
  • Entwicklung und Tests meist lokal an den Maschinen während Wartungs- und Stillstandszeiten.
Widerspricht sich irgendwie.... erstens glaube ich auch nicht, daß pauschal eine Änderung an der Library ein Onlinechange unmöglich macht und zweitens: Die Anlage steht doch in der Regel, wie Du schreibst...

  • Besonders wichtig wäre mir, dass es für den Entwickler immer offensichtlich ist, ob er einen maschinenspezifischem FB oder an einem allgemeinen FB vor sich hat.
Das ist doch ein Thema für die Namensgebung... Entweder die FBs enstprechend benennen oder in einen gemeinsamen Ordner packen im Projekt.

  • Bisher werden Änderungen an den gemeinsamen Programmteilen bei Gelegenheit auf die anderen Maschinen übertragen, getestet und dann freigegeben.
"Eigentlich" müßte ich doch Änderungen sowieso zuerst an allen Maschinen testen, bevor ich sie als allgemeingültig für alle Maschinen erkläre. An einer Anlage ändern und hoffen, daß sie dann an den beiden anderen Anlagen auch funktioniert, finde ich gewagt.

Wenn die Maschinen sich doch so ähnlich sind, bin ich auch fast bei @Ludewig : Mach ein Projekt draus und parametrier die Anlagen.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

Onlinechange mit geänderten Bibliotheken ist tatsächlich möglich. Da habe ich bei meinem ursprünglichen Versuchen wohl irgendetwas Komisches getrieben. Danke für den Hinweis, das hilft mir sehr, denn ich hätte mich hier verrannt.
Die Variante: Ein Projekt pro Maschine, gemeinsame Teile in Library + Versionsverwaltungssystem erscheint mir erstmal als die flexibelste und beherrschbarste Lösung. Das Beckhoff Variantenmanagement werde ich mir trotzdem nochmal genauer ansehen.

Harald:
Das Einspielen in Maschinen weltweit ist kein Thema. Wie gesagt: Es geht um 6 bis 10 Maschinen in für den Eigenbedarf. Änderungen und Weiterentwicklungen gemeinsamer Programmteile auf alle Maschinen zu übertragen ist aber tatsächlich mein Ziel. Ich erhoffe mir davon, dass der Pflegeaufwand langfristig geringer wird, als wenn sich die Steuerungen immer mehr auseinander entwickeln. Wie man da das am besten macht und den Überblick behält, ist Teil meiner Frage ;-)

JSEngeneering:
Das ist nicht direkt ein Widerspruch. Ein Neustart wäre möglich da nichts Kritisches läuft. Es kann aber trotzdem aufwendig sein, die Maschine nach Neustart wieder in den Zustand zu bringen, den ich für meine Entwicklungsarbeit brauche.
Änderungen an Maschine A zu entwickelt und zu vertrauen, dass diese an Maschine B funktionieren halte ich auch für gewagt. Ziel muss es sein, immer einen genauen Überblick zu behalten, was in welcher Variante wo läuft, was sich beim Hochrüsten auf eine neuere Version ändert und was wie weit erprobt ist.
Derzeit halte ich die Variante Library + Versionsverwaltung für vielversprechend, zeigen wirds die Praxis.

Strike:
"Einen Tod muss man sterben", Die die Aussage passt. So iss es leider oft im Leben ;-)

Danke für alle Antworten!

Gruß Alb
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Library + Versionsverwaltung ist wirklich sehr gut. So machen wir das auch.

Wir haben eigentlich die komplette Logik in den Libraries. Im eigentlichen Programm ist nur die Instanziierung aller Objekt, das Initialisieren und Treiben aller Objekte. So kann man alle Logik Bausteine mit Unit Tests komplett testen.
 
Außerdem bieten Bibliotheken die Möglichkeit sie an eine fixe Version zu binden. Du kannst also die neue verwenden wenn gewünscht, wenn die Maschine aber z.B. keine Probleme macht, kannst du auf dem alten Stand bleiben. Die Änderungen kannst du dann gemütlich bei einer Revision nachziehen und musst nicht bei der nächsten kleinen Störung ein riesen Update mit einspielen.

Ich denke eine Kombination aus Bibliotheken und Varianten Management macht Sinn.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Wie behältst Du da den Überblick, welche Programmversion tatsächlich in der Maschine Nr. xyz ist?

BOSCH macht das sehr gut vor mit ihren Peripherals und Objekten im OpconPlus (Nexeed).
Dort sind alle Objekte in einem separatem Std-Ordner. In diesem Ordner können auch
mehrere Versionen des gleichen Objektes sein. Inwieweit man das für sich nachbauen kann,
dieses Prinzip, weiß ich nicht, aber es ist der einzig sinnvolle Ansatz und bei OpConPlus
perfekt gelöst.


1643364432433.png
 
@Hack und IBFS:
So langsam wird der Thread inhaltlich interessant, auf genau solche Dankanstöße habe ich gehofft.

Hack, wenn ich dich richtig verstehe, meinst du Folgendes: Im Projekt Library markieren, Rechtsklick Properties, bei Resolution anstatt * eine Versionsnummer einstellen (* bedeutet, immer neueste Version verwenden). Jetzt verwendet das entsprechende Projekt eine feste Version. Änderungen an der Lib betreffen das Projekt nicht, bis dort die neue Lib eingestellt wird. Das ist praktisch.
Ich sehe da noch folgenden Stolperstein: Die Versionsnummern werden in Twincat von Hand eingegeben. Wenn man seine lokale Änderung zentral ablegt, darf man nicht vergessen, die Nummer zu erhöhen. B.z.w es darf nicht passieren das zwei Entwickler gleichzeitig von v1.1 auf v2.2 gehen. Das wird bei mir nicht lange dauern :rolleyes:

IBFS, interessantes Beispiel wie so etwas in "Vollausbaustufe" aussieht. Man kann vermuten, dass die Leute von Bosch so ein System gebaut haben, weil sie vorher einige Ärgernisse und Lehrgelderfahrungen hatten ;-)
 
Ja, genau so kannst du eine fixe Version wählen. Meines Wissens gibt es keine automatischen Versionsnummern, müsste man sonst nochmals klären.
Ich würde das so verhindern, dass ich nicht für jede Änderung eine Version machen. Sondern gewisse Releases mache. Jemand muss das ganz ja auch testen. Wenn Entwickler A was ändert und Entwickler B zur gleichen Zeit weiß ja kein Mensch ob das zusammen funktioniert.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich sehe da noch folgenden Stolperstein: Die Versionsnummern werden in Twincat von Hand eingegeben. Wenn man seine lokale Änderung zentral ablegt, darf man nicht vergessen, die Nummer zu erhöhen. B.z.w es darf nicht passieren das zwei Entwickler gleichzeitig von v1.1 auf v2.2 gehen. Das wird bei mir nicht lange dauern
Ich denke mit einer Kombination aus Versionverwaltung (z.B. GIT), mehreren nach Funktionalität aufgeteilten eigenen Bibliotheken und dem verwenden des Varianten Management sollte dies am Schluss selten der Fall sein. Wichtig ist dabei der richtige gleich konsequente Umgang mit der Versionverwaltung,.. also verwenden von Main/Master und Branches, Tags, usw... und das dies alle Immer gleich machen!

kleines Beispiel
Entwickler A ändert FB_XYZ und setzt neue Version (1.0 -> 1.1) in Branch A. Pusht Branch A auf den Server
Entwickler B ändert FB_123 und setzt gleiche Version (1.0 -> 1.1) wie Entwickler A in seinem Branch B. Pusht Branch B auf den Server
Entwickler A nimmt seinen Branch und will diesen ins Main Mergen, Fetch/Checkout von Main, Kontrolle in History, Merge mit Branch A, Commit, tagt auf V1.1, pusht.
Entwickler B nimmt seinen Branch und will diesen ins Main Mergen, Fetch/Checkout von Main, Kontrolle in History, sieht neuen Tag von Entwicler A, ändert seinen Branch bzw. Version auf 1.2, Merge mit Branch B, Commit, tagt auf V1.2, pusht.

Wichtig Dies ist nur einer von n Anwendungsfällen wie man mit einer Versionverwaltung und Aufteilung von Forks, Branches, usw, arbeiten kann. Interessant für dich/euch wäre wohl auch das Thema Pull Request was z.B. sicher bei GIT Repos auf Azure DevOps untersützt wird. Siehe auch diese Seite auf der Bergiffe wie Fork, Branch, usw. erklärt sind,.. https://docs.microsoft.com/de-de/azure/devops/repos/get-started/key-concepts-repos?view=azure-devops
 
Hallo,

@Brro87:

Die geschickte Verwendung von Git ist ein wichtiges Thema. Da sind wir noch in der Einarbeitung. Danke für das Beispiel! Mein bisheriger Kenntnisstand dazu: Es gibt eine unüberschaubare Vielzahl von Branchingmodellen und Workflows, von einfach bis sehr komplex. Diese haben, je nach Anwendungsfall, alle ihre Vor- und Nachteile. Das war im Forum schon einmal Thema, und ein User hatte eine Modellbeschreibung verlinkt, mit der er gut zurechtkommt:


So würde ich erstmal anfangen, bin da aber noch vollkommen unerfahren und versteh erstmal nur die Hälfte ;-). Verwendet ihr ein Standardschema, was irgendwo beschrieben ist?

@Alle: Evtl. sollte man zum Thema Git-Workflow mal einen eigenen Thread aufmachen, damit es nicht zu übersichtlich wird. Besteht da Interesse? Ich muss selber erstmal ein paar Hausaufgaben machen, bis sich da konkrete Fragen ergeben.

Zum Thema Library

Ich bin auf die erste Stelle gestoßen, wo das Konzept mit meinem Programmierstil kollidiert. Konfigurationsdaten behandle ich folgendermaßen:

Die Daten stecken in Structs. Anstatt einer globalen Konfigvariablenliste gibt es ein Programm "Configdaten" darin sind die Struct-Instanzen der einzelnen Anlagenteile als Output-variablendas deklariert (dadurch schreibgeschützt). Beim Start wird dieses Programm einmal ausgeführt und schreibt die Daten in die Struckts. Man kann in dem Programm übersichtlich und flexibel initialisieren (struckt in struct, aus datei, hartgecoded). Zugreifen kann man kann genauso wie auf eine globale Variablenliste. Ggf. sind die Structs als Array deklariert für "ConfigAnlagenteil[1..n]".
Der FB, der für den Anlagenteil zuständig ist, kriegt nicht die Configdaten übergeben, sondern nur die Nummer des Anlagenteils. Ab da „weiß“ er selber, wo er hingucken muss.
Ich würde das Konzept ungern verwerfen, denn es hat meiner Meinung nach viele gute Eigenschaften.

Problem: Das Programm Configdaten ist anlagenspezifisch, die FBs in der Library „kennen“ es also nicht. Mähhhh!

Mein Ansatz:
Anstatt der Library gibt es im Projekt einen Ordner für FBs die zum Projekt gehören, aber auch in anderen Projekten verwendet werden. Git wird so konfiguriert, dass es den Inhalt dieses Ordnert in den verschiedenen Solutions gleich hält.
 
Zurück
Oben