TrCh x6x

TrCh = {
    --nastavitelne konstanty
    FMAX = 220, --maximalni celkova tazna sila [kN]
    PREVOD = 74/30, --prevodovy pomer
    IkABSMAX = 1200, --maximalni kotevni proud [A] (1200 pro 361, jinak 1100)
    N_IkMAX = 36.725925, --uhlova rychlost TM [rad/s] pri ktere zacne regulace snizovat Ik - totozne pro vsechny x6x
    N_IkMIN = 102.21191626409, --uhlova rychlost TM [rad/s] pri ktere prestane regulace snizovat Ik - totozne pro vsechny x6x
    IbMIN = 15, --minimalni nezeslabeny budici proud [A] - pri w = 0
    IbMAX = 120, --maximalni nezeslabeny budici proud [A] - pri w = 0 (120 pro 361, jinak 110)
    IbINC_START = 100, --hodnota Ik kdy zacne stoupat Ib
    D_KOLA = 1.215, --prumer kola [m]

    w_TM = 0, --omega TM [rad/s]
    pt = 0, --pomerny tah 1MSK
    targetIk = 0, --vysledny zadany kotevni proud 1MSK [A]
    targetIb = 0, --vysledny zadany budici proud 1MSK [A]
    ik = 0, --okamzita hodnota kotevniho proudu [A]
    ib = 0, --okamzita hodnota budiciho proudu [A]

    nabehlyIb = false, --false dokud Ib nedosahl alespon 70% zadane hodnoty, blokuje nabeh Ik

    GetMaxIb = function(self) --vraci maximalni mozny Ib pro aktualni rychlost
        ibMax = math.min(
            self.IbMAX, --maximalni Ib az do UiMAX
            1.615276 + (110 - 1.615276)/(1 + ((self.w_TM-101.449)/17.02498)^0.8428483) --uhlova rychlost TM kdy Ui == UiMAX
        );

        return ibMax;
    end,

    GetIb = function(self, maxIk) --vraci zadany budici proud v zavislosti na aktualnim pt
        if (self.pt > 0) then --nenulove pt, jinak zadany Ib je nulovy
            baseIb = self.IbMIN; --zakladni nejmensi mozny Ib
            if (maxIk > self.IbINC_START) then --pokud Ik dosahl stanovene hodnoty, zacne se zvysovat Ib
                dIk = (self.IbMAX-self.IbMIN)/(self.IkABSMAX - self.IbINC_START); --zdvih na A Ik
                baseIb = self.IbMIN + (maxIk - self.IbINC_START)*dIk; --minimalni hodnota + vypocitany prirustek podle Ik
            end
            return math.min(baseIb, self:GetMaxIb()); --nesmi prekrocit maximalni fyzikalne mozny Ib
        else
            return 0;
        end
    end,

    GetIkForF = function(self, _kn) --vraci pozadovany kotevni proud pro zadanou taznou silu
        _k = self.PREVOD/(81/23); --prepocet z charakteristiky 163 na pouzity prevod
        ibKoef = 1 - ((math.max(self.w_TM-self.N_IkMIN, 0)*1.33709)/self.FMAX); --koeficient zeslabeneho budeni
        kn = _kn/ibKoef; --fiktivni pozadovane kn vlivem zeslabeneho pole
        exp_ik = 0; --exponencialni cast
        if (kn > 0) then
            exp_ik = math.sqrt(kn / (0.0005417 * _k));
        end
        lin_ik = (kn + 44.29796 * _k)/(0.3098367 * _k);
        if (math.min(exp_ik, lin_ik) < 289.4343) then --bod prechodu z exponencialni na linearni krivku - vzdy 289.4343 A
            return exp_ik; --pred bodem vrati exponencialni vysledek
        else
            return lin_ik; --za bodem linearni
        end
    end,

    GetIk = function(self, baseIk) --vraci skutecny mozny kotevni proud na zaklade pozadovaneho
        if (self.w_TM > self.N_IkMAX) then --pri vetsi rychlosti nez bod zacatku snizovani Ik
            dIk = (self.IkABSMAX-850)/(self.N_IkMIN-self.N_IkMAX); --zdvih na rad/s
            baseIk = math.min(baseIk, math.max(self.IkABSMAX - (self.w_TM - self.N_IkMAX)*dIk, 850)) --vraceny Ik je minimem z Ik pozadovanym regulaci a vykonem omezeneho Ik
        end
        if (baseIk > self.targetIb/0.032) then --pokud sytici pomer Ik/Ib dosahl hodnoty 0.032
            baseIk = self.targetIb/0.032; --limituje Ik takovym zpusobem aby pomer neklesl pod 0.032
        end

        return baseIk;
    end,

    GetF = function(self) --vraci skutecne vystupni kN podle okamzitych hodnot Ib a Ik
        if self.ib > 0 and self.ik > 0 then --pokud jsou kotevni i budici proudy nenulove
            ibNabehKoef = math.min(self.ib/self.targetIb,1); --jakesi pseudo omezeni pri neplnem buzeni
            ibKoef = 1 - ((math.max(self.w_TM-self.N_IkMIN, 0)*1.33709)/self.FMAX); --koeficient zeslabeneho budiciho pole pri vysokych V
            _k = self.PREVOD/(81/23); --prepocet z charakteristiky 163 na pouzity prevod
            if (self.ik < 282.5367) then --bod prechodu z exponencialni na linearni krivku - vzdy 282.5367 A
                return (0.0005417 * _k * self.ik^2) * ibNabehKoef * ibKoef; --exponencialni cast pred bodem
            else
                return (0.3098367 * _k * self.ik - 44.29796 * _k) * ibNabehKoef * ibKoef; --linearni cast za bodem
            end
        else
            return 0;
        end
    end,

    Update = function(self,deltaTime,pozTah,speed) --update funkce TrCh, deltaTime - ubehly cas od posledniho volani [s], pozTah - navoleny tah, speed - rychlost [m/s]
        self.pt = pozTah
        self.w_TM = speed / self.D_KOLA * self.PREVOD * 2; --prepocet m/s na omegu
        maxIk = self:GetIkForF(self.FMAX * self.pt); --teoreticky pozadovany Ik podle zadanych kN [A]
        self.targetIb = self:GetIb(maxIk); --pozadovany Ib [A]
        self.targetIk = self:GetIk(maxIk); --pozadovany Ik [A]
        if (self.ib > self.targetIb) then --pokud skutecny Ib > pozadovany Ib
            self.ib = math.max(self.ib - deltaTime*15, self.targetIb) --snizuj cca 15A/s
            Call("SetControlValue", "IBA", 0, self.ib);
            Call("SetControlValue", "IBB", 0, self.ib);
        elseif (self.ib < self.targetIb) then --pokud pozadovany Ib > skutecny Ib
            self.ib = math.min(self.ib + deltaTime*15, self.targetIb) --zvysuj cca 15A/s
            Call("SetControlValue", "IBA", 0, self.ib);
            Call("SetControlValue", "IBB", 0, self.ib);
        end
        if (self.ib <= 0) then --nulovy Ib
            if (self.ik > 0) then --nenulovy Ik
                self.ik = math.max(self.ik - deltaTime*600, 0) --snizuj Ik cca. 600A/s
                Call("SetControlValue", "IKA", 0, self.ik);
                Call("SetControlValue", "IKB", 0, self.ik);
            else
                self.ik = 0
            end
            self.nabehlyIb = false --Ib nedosahl 70% pozadovaneho
        else
            self.nabehlyIb = self.nabehlyIb or self.ib > math.min(self.targetIb, 15)*0.7 --Ib minimalne 70% pozadovaneho, jinak blokovany nabeh Ik
            if (self.ik > self.targetIk) then --pokud skutecny Ik > pozadovany Ik
                self.ik = math.max(self.ik - deltaTime*600, self.targetIk) --snizuj Ik cca. 600A/s
                Call("SetControlValue", "IKA", 0, self.ik);
                Call("SetControlValue", "IKB", 0, self.ik);
            elseif (self.ik < self.targetIk and self.nabehlyIb) then --pozadovany Ik > skutecny Ik a Ib jiz dosahl alespon 70%
                self.ik = math.min(self.ik + 350*deltaTime, self.targetIk) --zvysuj Ik cca. 350A/s
                Call("SetControlValue", "IKA", 0, self.ik);
                Call("SetControlValue", "IKB", 0, self.ik);
            end
        end
        Call("SetControlValue", "Regulator", 0, math.min(self:GetF(),self.FMAX)/self.FMAX); --nastavi regulator podle okamzitych hodnot Ik a Ib
    end
}