controller 2

function [delta_tau, e, u]  = myFunction(IT2_Strecke, tau, a2, a1, a0, b2, b1, b0, u_max, u_min, w, x)

    coder.extrinsic("tf", "d2c", "c2d", "tfdata");

    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Initialisierung der persistenten Variablen %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    persistent ek_1;    % vorheriger interne Regelfehler
    persistent ek_2;    % interner Regelfehler vor zwei Zyklen
    persistent ek_3;    % interner Regelfehler vor drei Zyklen

    persistent uk_1;    % vorherige ausgegebene Stellgröße
    persistent uk_2;    % ausgegebene Stellgröße vor zwei Zyklen
    persistent uk_3;    % ausgegebene Stellgröße vor drei Zyklen

    persistent b2_neu;  % Zählerkoeffizienten mit neuer Abtastzeit
    persistent b1_neu;  % Zählerkoeffizienten mit neuer Abtastzeit
    persistent b0_neu;  % niedrigster Zählerkoeffizienten mit neuer Abtastzeit

    persistent a2_neu;  % Nennerkoeffizienten mit neuer Abtastzeit
    persistent a1_neu;  % Nennerkoeffizienten mit neuer Abtastzeit
    persistent a0_neu;  % niedrigster Nennerkoeffizienten mit neuer Abtastzeit

    persistent tau_neu; % neu berechnete Abtastzeit

    if isempty(tau_neu)
        tau_neu = 0.1;
    end

    if isempty(ek_1)
        ek_1 = 0;
        ek_2 = 0;
        ek_3 = 0;

        uk_1 = 0;
        uk_2 = 0;
        uk_3 = 0;
    end

    if isempty(b2_neu)
        b2_neu = 0;
        b1_neu = 0;
        b0_neu = 0;

        a2_neu = 0;
        a1_neu = 0;
        a0_neu = 0;
    end

    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Berechnung des Regelfehlers %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    ek = w -x;  % aktueller Regelfehler im Vergleich zum w0 - x

    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Dead-Beat-Regelalgorithmus %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    % Bei a1, a2 und b1 gibt die Zahl den Exponenten an -> a*z, a*z^2 und b*z
    b1b0 = b1 + b0;
    b2b1b0 = b2 + b1 + b0;

    if IT2_Strecke < 1
        % PT2
        uk = (1 / b1b0) * (ek + a1 * ek_1 + a0 * ek_2 + b1 * uk_1 + b0 * uk_2);
    else
        % IT2
        uk = (1 / b2b1b0) * (ek + a2 * ek_1 + a1 * ek_2 + a0 * ek_3 + b2 * uk_1 + b1 * uk_2 + b0 * uk_3);
    end

    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Ermittlung der neuen Abtastzeit %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    if IT2_Strecke < 1
        %%%%%%%%%%%%%%%
        % PT2-Strecke %
        %%%%%%%%%%%%%%%

        gz = tf([b2 b1 b0],[a2 a1 a0], tau); % Übertragungsfunktion der diskretisierten Strecke erstellen
        gs = d2c(gz); % Übertragungsfunktion der eingegebenen Strecke erstellen

        if (uk > u_max && abs(ek_1) < 0.001 && abs(ek_2) < 0.001) % andere Bedingungen damit eine neue Abtastzeit nur aus einer Ruhelage ermittelt wird
            while (uk > u_max)
                tau_neu = tau_neu + 0.001;

                gz_neu = c2d(gs, tau_neu); % kontinuierliche Strecke mit neuer Abtastzeit diskretisieren

                [numerator, denominator] = tfdata(gz_neu); % Koeffizienten der diskretiesierten Strecke extrahieren

                % Umwandlung von Zell-Arrays in normale Arrays
                numerator_array = cell2mat(numerator);
                denominator_array = cell2mat(denominator);

                % Zähler
                b2_neu = numerator_array(1);
                b1_neu = numerator_array(2);
                b0_neu = numerator_array(3); % niedrigster Exponent

                % Nenner
                a2_neu = denominator_array(1);
                a1_neu = denominator_array(2);
                a0_neu = denominator_array(3); % niedrigster Exponent

                b1b0_neu = b1_neu + b0_neu;
                uk = (1 / b1b0_neu) * (ek + a1_neu * ek_1 + a0_neu * ek_2 + b1_neu * uk_1 + b0_neu * uk_2);
            end

            assignin('base', 'tau_neu', tau_neu);

            assignin('base', 'b2_neu', b2_neu);
            assignin('base', 'b1_neu', b1_neu);
            assignin('base', 'b0_neu', b0_neu);

            assignin('base', 'a2_neu', a2_neu);
            assignin('base', 'a1_neu', a1_neu);
            assignin('base', 'a0_neu', a0_neu);
        end

        if (uk < u_min && abs(ek_1) < 0.001 && abs(ek_2) < 0.001) % andere Bedingungen damit eine neue Abtastzeit nur aus einer Ruhelage ermittelt wird
            while (uk > u_max)
                tau_neu = tau_neu + 0.001;

                gz_neu = c2d(gs, tau_neu); % kontinuierliche Strecke mit neuer Abtastzeit diskretisieren

                [numerator, denominator] = tfdata(gz_neu); % Koeffizienten der diskretiesierten Strecke extrahieren

                % Umwandlung von Zell-Arrays in normale Arrays
                numerator_array = cell2mat(numerator);
                denominator_array = cell2mat(denominator);

                % Zähler
                b2_neu = numerator_array(2);
                b1_neu = numerator_array(3);
                b0_neu = numerator_array(4); % niedrigster Exponent

                % Nenner
                a2_neu = denominator_array(2);
                a1_neu = denominator_array(3);
                a0_neu = denominator_array(4); % niedrigster Exponent

                b1b0_neu = b1_neu + b0_neu;
                uk = (1 / b1b0_neu) * (ek + a1_neu * ek_1 + a0_neu * ek_2 + b1_neu * uk_1 + b0_neu * uk_2);
            end

            assignin('base', 'tau_neu', tau_neu);

            assignin('base', 'b2_neu', b2_neu);
            assignin('base', 'b1_neu', b1_neu);
            assignin('base', 'b0_neu', b0_neu);

            assignin('base', 'a2_neu', a2_neu);
            assignin('base', 'a1_neu', a1_neu);
            assignin('base', 'a0_neu', a0_neu);
        end
    else
        %%%%%%%%%%%%%%%
        % IT2-Strecke %
        %%%%%%%%%%%%%%%

        gz = tf([b2 b1 b0],[1 a2 a1 a0], tau); % Übertragungsfunktion der diskretisierten Strecke erstellen
        gs = d2c(gz); % Übertragungsfunktion der eingegebenen Strecke erstellen

        if (uk > u_max && abs(ek_1) < 0.001 && abs(ek_2) < 0.001 && abs(ek_3) < 0.001) % andere Bedingungen damit eine neue Abtastzeit nur aus einer Ruhelage ermittelt wird
            while (uk > u_max)
                tau_neu = tau_neu + 0.001;

                %IT2 = tf(10, [0.02 0.3 1 0]);

                gz_neu = c2d(gs, tau_neu); % kontinuierliche Strecke diskretisieren

                [numerator, denominator] = tfdata(gz_neu); % Koeffizienten der diskretiesierten Strecke extrahieren

                % Umwandlung von Zell-Arrays in normale Arrays
                numerator_array = cell2mat(numerator);
                denominator_array = cell2mat(denominator);

                % Zähler
                b2_neu = numerator_array(2);
                b1_neu = numerator_array(3);
                b0_neu = numerator_array(4); % niedrigster Exponent

                % Nenner
                a2_neu = denominator_array(2);
                a1_neu = denominator_array(3);
                a0_neu = denominator_array(4); % niedrigster Exponent

                b2b1b0_neu = b2_neu + b1_neu + b0_neu;
                uk = (1 / b2b1b0_neu) * (ek + a2_neu * ek_1 + a1_neu * ek_2 + a0_neu * ek_3 + b2_neu * uk_1 + b1_neu * uk_2 + b0_neu * uk_3);
            end

            assignin('base', 'tau_neu', tau_neu);

            assignin('base', 'b2_neu', b2_neu);
            assignin('base', 'b1_neu', b1_neu);
            assignin('base', 'b0_neu', b0_neu);

            assignin('base', 'a2_neu', a2_neu);
            assignin('base', 'a1_neu', a1_neu);
            assignin('base', 'a0_neu', a0_neu);
        end

        if (uk < u_min && abs(ek_1) < 0.001 && abs(ek_2) < 0.001 && abs(ek_3) < 0.001) % andere Bedingungen damit eine neue Abtastzeit nur aus einer Ruhelage ermittelt wird
            while (uk > u_max)
                tau_neu = tau_neu + 0.001;

                gz_neu = c2d(gs, tau_neu); % kontinuierliche Strecke diskretisieren

                [numerator, denominator] = tfdata(gz_neu); % Koeffizienten der diskretiesierten Strecke extrahieren

                % Umwandlung von Zell-Arrays in normale Arrays
                numerator_array = cell2mat(numerator);
                denominator_array = cell2mat(denominator);

                % Zähler
                b2_neu = numerator_array(2);
                b1_neu = numerator_array(3);
                b0_neu = numerator_array(4); % niedrigster Exponent

                % Nenner
                a2_neu = denominator_array(2);
                a1_neu = denominator_array(3);
                a0_neu = denominator_array(4); % niedrigster Exponent

                b2b1b0_neu = b2_neu + b1_neu + b0_neu;
                uk = (1 / b2b1b0_neu) * (ek + a2_neu * ek_1 + a1_neu * ek_2 + a0_neu * ek_3 + b2_neu * uk_1 + b1_neu * uk_2 + b0_neu * uk_3);
            end

            assignin('base', 'tau_neu', tau_neu);

            assignin('base', 'b2_neu', b2_neu);
            assignin('base', 'b1_neu', b1_neu);
            assignin('base', 'b0_neu', b0_neu);

            assignin('base', 'a2_neu', a2_neu);
            assignin('base', 'a1_neu', a1_neu);
            assignin('base', 'a0_neu', a0_neu);
        end
    end

    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Solange das System nicht in Ruhe ist, wird die Abtastzeit gehalten %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    if IT2_Strecke < 1
        if (abs(ek_1) > 0.001 || abs(ek_2) > 0.001)
                b1b0_neu = b1_neu + b0_neu;
                uk = (1 / b1b0_neu) * (ek + a1_neu * ek_1 + a0_neu * ek_2 + b1_neu * uk_1 + b0_neu * uk_2);
        end
    else
        if (abs(ek_1) > 0.001 || abs(ek_2) > 0.001 || abs(ek_3) > 0.001)
                b2b1b0_neu = b2_neu + b1_neu + b0_neu;
                uk = (1 / b2b1b0_neu) * (ek + a2_neu * ek_1 + a1_neu * ek_2 + a0_neu * ek_3 + b2_neu * uk_1 + b1_neu * uk_2 + b0_neu * uk_3);
        end
    end

    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Wenn Regelung fertig, Sollwert erreicht mit eine Genauigkeit kleiner als 0.01 %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    if IT2_Strecke < 1
        if (abs(ek_2) < 0.001 && abs(ek_1) < 0.001 && abs(ek) < 0.001 && w ~= 0)
            uk = (1 / b1b0) * (ek + a1 * ek_1 + a0 * ek_2 + b1 * uk_1 + b0 * uk_2);
            tau_neu = tau;
        end

        if (abs(ek_2) < 0.001 && abs(ek_1) < 0.001 && abs(ek) < 0.001 && w == 0)
            uk = 0;
            tau_neu = tau;
        end
    else
        if(abs(ek)<0.001)
            uk = 0;
            tau_neu = tau;
        end
    end

    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % Aktualisieren der Vergangenheitswerte %
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    ek_3 = ek_2;
    ek_2 = ek_1;
    ek_1 = ek;

    uk_3 = uk_2;
    uk_2 = uk_1;
    uk_1 = uk;

    %%%%%%%%%%%%%%%%%%%%%
    % Ausgabe der Werte %
    %%%%%%%%%%%%%%%%%%%%%

    e = ek;
    u = uk;

    delta_tau = tau_neu - tau;
end