Offcanvas Section

You can publish whatever you want in the Offcanvas Section. It can be any module or particle.

By default, the available module positions are offcanvas-a and offcanvas-b but you can add as many module positions as you want from the Layout Manager.

You can also add the hidden-phone module class suffix to your modules so they do not appear in the Offcanvas Section when the site is loaded on a mobile device.

+49 (0) 162 576 18 05

ChatGPT generiert lupenreinen Code in den gängigen Programmiersprachen - ganze Apps lassen sich mit Hilfe von ChatGPT und ein wenig menschlicher Hilfe erstellen. Aber wie ist es mit Industrieprogrammierung? Ist ChatGPT in der Lage Software für Maschinensteuerungen zu schreiben?

Fangen wir einfach an und finden wir mal heraus, ob ChatGPT überhaupt eine Vorstellung davon hat, was SPS-Programmierer machen:

Aufgaben eines SPS-Programmierers laut ChatGPT

Die Antwort ist erstaunlich präzise. ChatGPT listet tatsächlich die wichtigsten Kompetenzen eines SPS-Programmierers auf und berücksichtigt technische und soziale Fähigkeiten - dafür gibt's von mir 5 Sterne!

So, dann schauen wir mal, ob ChatGPT die SPS-Programmiersprachen kennt:

ChatGPTs Kenntnisse über SPS-Programmiersprachen

Und tatsächlich, die wichtigen Sprachen werden genannt und so bezeichnet und abgekürzt, wie sie in der relevanten Norm IEC 61131-3 genannt werden. Siemens hat leicht abgewandelte Abkürzungen, aber ich denke, es ist sinnvoll, wenn sich ChatGPT bei dieser allgemeinen Frage an die Norm hält. Also auch hier 5 Sterne!

Dann geht es jetzt mal an ein einfaches Programm. Vor einigen Wochen habe ich bereits FUP und KOP ausprobiert, da lieferte ChatGPT tatsächlich eine grafische Darstellung (mit ASCII-Zeichen), bei der man mit gutem Willen FUP bzw. KOP erkennen konnte. Mittlerweile funktioniert das nicht mehr. Bei Fragen nach FUP zeigt ChatGPT eine Lösung in SCL:

ChatGPTs antwortet mit SCL auf eine FUP-Anfrage

Und bei der folgenden Frage nach KOP hatte ChatGPT zunächst auch SCL gezeigt. Dann habe ich meine Frage nochmal präzisiert und leider auch wieder kein KOP, sondern stattdessen eine Handlungsliste bekommen:

ChatGPTs zeigt eine Aktionsliste statt KOP

Für grafische Programmiersprachen gibt es daher nur einen von fünf Sternen. Natürlich, ChatGPT ist eine textbasierte KI, also überfordern wir sie nicht, sondern fokussieren uns auf SCL:

ChatGPT schreibt eine Schleife in SCL

Gut, ehrlicherweise muss ich sagen, dass ich mehrere Versuche gebraucht habe, bis ChatGPT tatsächlich Code in SCL auswirft. Manchmal nutzt es SAS, eine Programmiersprache für Statistikauswertungen oder auch mal VB. Deshalb gibt es dafür erstmal nur 2 von 5 Sternen. Wenn ChatGPT aber verstanden hat, was gefordert ist, bringt es zum Beispiel folgende Lösungen. Hier mal zur Abwechslung eine Pumpensteuerung auf Englisch:

ChatGPT generiert eine Pumpensteuerung in SCL

Das ist ordentlich gelöst, 5 Sterne. Jetzt schauen wir, wie SCL mit einer Sortieranlage umgeht:

ChatGPT erstellt Code für eine Sortieranlage SC

Das ist seltsam. material_type wird als INT deklariert, aber später in der IF-Abfrage wird auf WOOD geprüft. Das ist eindeutig kein Integer. Außerdem hat ChatGPT den zweiten Teil der Anweisung nicht korrekt verstanden. Das Band soll auch an Fach 2 stoppen, in dem ELSE-Zweig wird conveyor_stop aber auf TRUE gesetzt.

 

Fazit: ChatGPT kennt SPS-Programmiersprachen - allein das ist schon etwas überraschend. Und die KI erzeugt Code mit meistens richtiger Syntax. Um schnell mal eine Grundstruktur für einen Funktionsblock in SCL zu bekommen, insbesondere, wenn man die Syntax nicht in Perfektion beherrscht, kann es sehr hilfreich sein. Code-Snippets in SCL kann ChatGPT schon heute erstellen. Das kann Tipparbeit ersparen. Aber ungeprüft darf der Code nicht übernommen werden!

Für umfangreiche SCL-Programme oder gar eine komplette Maschinenprogrammierung kann es noch nicht verwendet werden. Das liegt vor allem daran, dass oft erst im Entwicklungsprozess die Anforderungen präzisiert werden und eine Vielzahl verschiedener Geräte verschiedener Hersteller mit unterschiedlichen Schnittstellen miteinander kommunizieren. Wer weiß, was die Zukunft bringt? Können präzise formulierte Pflichtenhefte direkt von ChatGPT in SCL-Code umgewandelt werden?

Was meinst du, wie sich ChatGPT entwickelt? Kannst du dir vorstellen, ChatGPT jetzt schon einzusetzen und wenn ja, wofür?

Ein Kommentar zu “ChatGPT für SPS-Programmierung - geht das?”

  1. Donnerstag, 18. April 2024 18:58

    Ich habe es tatsächlich auch mal ausprobiert, mit ziemlich ausgedehnten Gehversuchen, das Ergebnis hat mich überrascht, auch wenn ich es so dann nicht zum Einsatz gebracht habe. Die Aufgabe war einen FB zur PID Steuerung & Regelung mit autotune Funktion nach der Zieger Nichols Methode zu entwickeln. Hier das Ergebniss:

    PID Autotune
    FUNCTION_BLOCK PID_Autotuner
    VAR_INPUT
        Start : BOOL; // Starte die Regeloptimierung
        Setpoint : REAL; // Sollwert für den Regelprozess
        Process_Variable : REF_TO REAL; // Referenz auf die Prozessvariable
        Sampling_Time : TIME := T#1S; // Abtastrate für die Regeloptimierung
        Tune_Type : INT := 0; // 0 für klassische Ziegler-Nichols-Methode, 1 für andere
    END_VAR
    VAR_OUTPUT
        Tuned_Kp : REAL; // Optimaler proportionaler Verstärkungsfaktor (Kp)
        Tuned_Ki : REAL; // Optimaler integraler Verstärkungsfaktor (Ki)
        Tuned_Kd : REAL; // Optimaler differenzieller Verstärkungsfaktor (Kd)
        Tuning_Complete : BOOL; // Regeloptimierung abgeschlossen
    END_VAR
    VAR
        // Interne Variablen
        Error_Sum : REAL := 0.0; // Summe der Fehler für den integralen Term
        Last_Error : REAL := 0.0; // Letzter Fehler für die Ableitung
        Last_Output : REAL := 0.0; // Letzter Ausgang für die Ableitung
        Time_Count : INT := 0; // Zähler für die Abtastzeit
        Init_Complete : BOOL := FALSE; // Initialisierung abgeschlossen
        Step : INT := 0; // Schritt der Ziegler-Nichols-Methode
        Max_Step : INT := 6; // Maximaler Schritt für die Ziegler-Nichols-Methode
        P_Term : REAL := 0.0; // Proportionaler Term
        I_Term : REAL := 0.0; // Integraler Term
        D_Term : REAL := 0.0; // Differenzieller Term
        Output : REAL := 0.0; // Ausgang der Regelung
        Previous_Output : REAL := 0.0; // Vorheriger Ausgang der Regelung
        Error : REAL := 0.0; // Fehler zwischen Sollwert und Prozessvariable
        Setpoint_Half : REAL := 0.0; // Halber Sollwert für die Schrittantwort
        Process_Variable_Half : REAL := 0.0; // Halbe Prozessvariable für die Schrittantwort
        Time_Constant : TIME := T#0S; // Zeitkonstante für die Schrittantwort
    END_VAR

    IF Start THEN
        Init_Complete := FALSE; // Initialisierung starten
        Time_Count := 0; // Zähler zurücksetzen
        Step := 0; // Schritt zurücksetzen
        Error_Sum := 0.0; // Fehler-Summe zurücksetzen
        Tuning_Complete := FALSE; // Regeloptimierung ist noch nicht abgeschlossen
    END_IF

    IF NOT Init_Complete THEN // Initialisierung durchführen
        // Sollwert und Prozessvariable setzen
        Setpoint_Half := Setpoint / 2.0;
        Process_Variable_Half := *Process_Variable / 2.0;
        
        CASE Step OF
            0: // Regelkreis öffnen, Prozessvariable lesen
                Output := 0.0;
                IF Time_Count > 2 THEN
                    Process_Variable_Half := *Process_Variable; // Aktualisiere Prozessvariable
                    Time_Count := 0; // Zähler zurücksetzen
                    Step := Step + 1; // Nächster Schritt
                ELSE
                    Time_Count := Time_Count + 1; // Zähler erhöhen
                END_IF
            1: // Regelkreis schließen, Proportionalverstärkung erhöhen
                P_Term := 1.0;
                IF Tune_Type = 0 THEN
                    Kp := 1.2;
                ELSE
                    // Implementiere andere Methoden
                END_IF
                Output := Kp * (Setpoint - *Process_Variable);
                IF Time_Count > 5 THEN
                    Last_Error := Error;
                    Error := Setpoint_Half - *Process_Variable;
                    Error_Sum := Error_Sum + Error;
                    IF Tune_Type = 0 THEN
                        Kp := Kp - 0.2;
                    ELSE
                        // Implementiere andere Methoden
                    END_IF
                    Time_Count := 0; // Zähler zurücksetzen
                    Step := Step + 1; // Nächster Schritt
                ELSE
                    Time_Count := Time_Count + 1; // Zähler erhöhen
                END_IF
            2: // Integralverstärkung erhöhen
                I_Term := 1.0;
                IF Tune_Type = 0 THEN
                    Ki := 2.0;
                ELSE
                    // Implementiere andere Methoden
                END_IF
                Output := Kp * (Setpoint - *Process_Variable) + Ki * Error_Sum;
                IF Time_Count > 15 THEN
                    IF Tune_Type = 0 THEN
                        Ki := Ki - 0.5;
                    ELSE
                        // Implementiere andere Methoden
                    END_IF
                    Time_Count := 0; // Zähler zurücksetzen
                    Step := Step + 1; // Nächster Schritt
                ELSE
                    Time_Count := Time_Count + 1; // Zähler erhöhen
                END_IF
            3: // Differenzialverstärkung erhöhen
                D_Term := 1.0;
                IF Tune_Type = 0 THEN
                    Kd := 0.5;
                ELSE
                    // Implementiere andere Methoden
                END_IF
                Output := Kp * (Setpoint - *Process_Variable) + Ki * Error_Sum - Kd * (Output - Previous_Output);
                Previous_Output := Output;
                IF Time_Count > 20 THEN
                    IF Tune_Type = 0 THEN
                        Kd := Kd - 0.1;
                    ELSE
                        // Implementiere andere Methoden
                    END_IF
                    Time_Count := 0; // Zähler zurücksetzen
                    Step := Step + 1; // Nächster Schritt
                ELSE
                    Time_Count := Time_Count + 1; // Zähler erhöhen
                END_IF
            4: // Regelung überprüfen
                IF Tune_Type = 0 THEN
                    IF Step < Max_Step THEN
                        Output := Kp * (Setpoint - *Process_Variable) + Ki * Error_Sum - Kd * (Output - Previous_Output);
                        Previous_Output := Output;
                        Time_Count := Time_Count + 1; // Zähler erhöhen
                    ELSE
                        // Regeloptimierung abgeschlossen
                        Tuned_Kp := Kp;
                        Tuned_Ki := Ki;
                        Tuned_Kd := Kd;
                        Tuning_Complete := TRUE;
                        Init_Complete := TRUE;
                    END_IF
                ELSE
                    // Implementiere andere Methoden
                END_IF
            5: // Regelkreis öffnen
                Output := 0.0;
                IF Time_Count > 2 THEN
                    Time_Count := 0; // Zähler zurücksetzen
                    Init_Complete := TRUE;
                ELSE
                    Time_Count := Time_Count + 1; // Zähler erhöhen
                END_IF
        END_CASE
    ELSE // Regelkreis schließen, reguläre PID-Regelung ausführen
        Output := Kp * (Setpoint - *Process_Variable) + Ki * Error_Sum - Kd * (Output - Previous_Output);
        Previous_Output := Output;
        Error := Setpoint - *Process_Variable;
        Error_Sum := Error_Sum + Error;
    END_IF

    Desweiteren kann Chat GPT bei richtigem Umgang auch Weakauren für ein bekanntes MMORPG in LUA schreiben.

Kommentar hinterlassen

Als Antwort auf Some User

Mehr Blogartikel

Wie du in 7 Schritten technische Probleme systematisch und schnell löst

Wie du in 7 Schritten technische Probleme systemat...

Bei Schaltplanengineering, Softwareentwicklung, bei Inbetriebnahmen und im Alltag treten laufend technische Probleme auf. Hier erfährst du, wie du jedes technische Problem in 7 Schritten löst und warum die einz...

Die 7 wichtigsten Kennzeichen und Prüfzeichen für elektrische Anlagen

Die 7 wichtigsten Kennzeichen und Prüfzeichen für...

Vorstellung der wichtigsten deutschen und internationalen Kenn- und Prüfzeichen für elektrisch automatisierte Anlagen:

2 Methoden, die du kennen solltest, um einen PID-Regler einzustellen

2 Methoden, die du kennen solltest, um einen PID-R...

In der Praxis haben sich zwei Methoden bewährt, um die Regelparameter für eine übliche Regelstrecke mit Ausgleich zu finden:

Schnittstellen für Drehgeber

Schnittstellen für Drehgeber

Dieser Artikel liefert einen Überblick über alle gängigen Schnittstellen für Drehgeber. Inkrementalgeber: Sin/Cos \(1~V_{ss}\) TTL RS422 HTL Absolutwertgeber: SSI BiSS C Hiperface EnDat 3 Resolver Einteilung de...

Stromstoßschaltung mit SPS - so geht's

Stromstoßschaltung mit SPS - so geht's

Der Begriff Stromstoßschaltung bedeutet, dass sich durch einen Stromstoß von nur einem Taster der Schaltzustand ändert. Es wird also zum Beispiel zum Ein- und Ausschalten einer Lampe derselbe Taster verwendet....

ChatGPT für SPS-Programmierung - geht das?

ChatGPT für SPS-Programmierung - geht das?

ChatGPT generiert lupenreinen Code in den gängigen Programmiersprachen - ganze Apps lassen sich mit Hilfe von ChatGPT und ein wenig menschlicher Hilfe erstellen. Aber wie ist es mit Industrieprogrammierung? Ist...

Memes für Inbetriebnehmer

Memes für Inbetriebnehmer

Italienische Sonne tanken, das spanische Meer genießen, französischen Wein verkosten: Das machen Inbetriebnehmer auf Dienstreisen ... oder?