Схема ВР483М в ТРС

/*
## двухкамерный резервуар ##

V tm 0 0.1
V zr 0 0.1
V tc 0 0.1
V rk 0 6
V zk 0 6

## магистральная часть ##

V mk 0 0.5     # MK
C tm mk 12mm   #

V s1 0 0.1     # камера в седле C1
V kdr 0 0.1    # КДР
V k 0 0.01      # режимная камера

C s1 mk 0.3mm   # радиальный канал в седле С1

C mk_s1_p mk s1 2mm 0  # 2d1.0 в хвостовике плунжера (соединяют МК с ЗК при отпуске)

C kp s1 zk 3.6mm 0  # клапан плунжера (соединяет ЗК и С1 при торможении)

C s1_zk_p s1 zk 0.7mm 0  # верхнее отверстие в плунжере (соединяет С1 с ЗК или К)
C s1_k_p  s1 k  0.7mm 0

C k_zk_p k zk 0.7mm 0  # нижнее отверстие в плунжере (соединяет ЗК и К)

C chm mk s1 12mm 0  # челночная манжета (соединяет МК с С1 при торможении)

C dr s1 kdr 4mm 0  # клапан доп. разрядки

C ak kdr at 0.9mm 0  # атмосферный клапан

C km mk zk 0.9mm 0  # клапан мягкости

C rd rk k 0.6mm 0  # режимная диафрагма (соединение РК с К)

## главная часть ##

C tm_zr tm zr 1.3mm 0  #  дроссельное отверстие для зарядки ЗР

C rk_zk rk zk 0.5mm 1  #  дроссельное отверстие, соединяющее ЗК и РК

C zr_tc zr tc 1 0       #  отверстие (4d3.0 или d1.7) для наполнения ТЦ
C kdr_tc kdr tc 12mm 1  #  канал КДР - ТЦ - Ат
C tc_at tc at 2.3mm 1   #  ниппель в уравнительном поршне для соединения ТЦ с атмосферой

C vk rk at 1.5mm 0  # выпускной вентиль (выпуск воздуха из РК и отпуск тормоза)
*/

include "splibrary.gs"

class SPAO_VR483M isclass SPAirObject
{
    define public int ModeR = 0;
    define public int ModeG = 1;
    public int Mode = ModeR;

    define public int LoadModeP = 0;
    define public int LoadModeS = 1;
    define public int LoadModeG = 2;
    public int LoadMode = LoadModeG;

    float kmOpenPressure = Math.Rand(300.0f, 400.0f);
    bool chmOpen = false;
    float mdPosition = 4.5f;
    float gpPosition = 0.0f;
    float upPosition = 5.0f;

    int vTM;
    int vRK;
    int vZK;
    int vZR;
    int vTC;
    int vMK;
    int vS1;
    int vKDR;
    int vK;
    int cMK_S1_P;
    int cKP;
    int cS1_ZK_P;
    int cS1_K_P;
    int cK_ZK_P;
    int cChM;
    int cDR;
    int cAK;
    int cKM;
    int cRD;
    int cTM_ZR;
    int cRK_ZK;
    int cZR_TC;
    int cKDR_TC;
    int cTC_AT;

    define float chmOpenSensivity = 150.0f;
    define float chmCloseSensivity = 10.0f;
    define float chmMinOpenDelta = 10.0f;
    define float chmFullOpenDelta = 60.0f;

    define float mdReleaseMax = 10.0f;
    define float mdBrakeFirstStage = 5.0f;
    define float mdBrakeSecondStage = 10.0f;
    define float mdBrakeThirdStage = 20.0f;
    define float mdBrakeMax = 30.0f;
    define float mdSpeed = 3.0f;

    define float rdRatioRK = 0.4f;
    define float rdRatioK = 0.6f;
    define float rdOpenPressure = rdRatioK * 350.0f + rdRatioRK * 250.0f;
    define float rdFullOpenDelta = 20.0f;

    define float okSensivity = 2.0f;

    define float gpSpeed = 7.0f / 1.0f;
    define float gpMaxPressure = 60.0f;
    define float gpMaxPosition = 23.0f;
    define float gpSpring = gpMaxPressure / gpMaxPosition;
    define float gpSensivity = 2.0f;
    define float gpMaxAddVolume = 0.3f;

    define float rkBaseVolume = 6.0f;
    define float upMinPosition = 5.0f;
    define float upMaxPosition = 23.0f;
    define float upPositionRange = upMaxPosition - upMinPosition;
    define float upMinPressure = 40.0f;
    define float upMaxPressureG = 430.0f;
    define float upMaxPressureP = 170.0f;
    define float upPressureSP = 120.0f;
    define float tkSensivity = 0.3f;
    define float tkApplyFullOpenDelta = 2.0f;
    define float tkReleaseFullOpenDelta = 0.5f;

    public void Init(SPAirScheme scheme)
    {
        inherited(scheme);
        vTM = scheme.GetNodeId("tm");
        vRK = scheme.GetNodeId("rk");
        vZK = scheme.GetNodeId("zk");
        vZR = scheme.GetNodeId("zr");
        vTC = scheme.GetNodeId("tc");

        vMK = scheme.GetNodeId("mk");
        vS1 = scheme.GetNodeId("s1");
        vKDR = scheme.GetNodeId("kdr");
        vK = scheme.GetNodeId("k");

        cMK_S1_P = scheme.GetLinkId("mk_s1_p");
        cKP = scheme.GetLinkId("kp");
        cS1_ZK_P = scheme.GetLinkId("s1_zk_p");
        cS1_K_P = scheme.GetLinkId("s1_k_p");
        cK_ZK_P = scheme.GetLinkId("k_zk_p");
        cChM = scheme.GetLinkId("chm");
        cDR = scheme.GetLinkId("dr");
        cAK = scheme.GetLinkId("ak");
        cKM = scheme.GetLinkId("km");
        cRD = scheme.GetLinkId("rd");

        cTM_ZR = scheme.GetLinkId("tm_zr");
        cRK_ZK = scheme.GetLinkId("rk_zk");
        cZR_TC = scheme.GetLinkId("zr_tc");
        cKDR_TC = scheme.GetLinkId("kdr_tc");
        cTC_AT = scheme.GetLinkId("tc_at");
    }

    public void Update(float dt)
    {
        float openMK_S1_P = 0.0f;
        float openKP = 0.0f;
        float openS1_ZK_P = 0.0f;
        float openS1_K_P = 0.0f;
        float openK_ZK = 0.0f;
        float openChM = 0.0f;
        float openDR = 0.0f;
        float openAK = 0.0f;
        float openKM = 0.0f;
        float openRD = 0.0f;
        float openTM_ZR = 0.0f;
        float openRK_ZK = 0.0f;
        float openZR_TC = 0.0f;
        float openKDR_TC = 0.0f;
        float openTC_AT = 0.0f;

        float kdrPressure = scheme.GetPressure(vKDR);
        float mkPressure = scheme.GetPressure(vMK);
        float zkPressure = scheme.GetPressure(vZK);
        float s1Pressure = scheme.GetPressure(vS1);
        float kPressure = scheme.GetPressure(vK);
        float tmPressure = scheme.GetPressure(vTM);
        float zrPressure = scheme.GetPressure(vZR);
        float rkPressure = scheme.GetPressure(vRK);
        float tcPressure = scheme.GetPressure(vTC);

        // клапан мягкости
        if (kdrPressure < 40.0f and zkPressure >= kmOpenPressure)
            openKM = 1.0f;

        // челночная манжета
        float chmPressure = mkPressure - s1Pressure;
        if (chmPressure > chmOpenSensivity)
            chmOpen = true;
        else if (chmPressure < chmCloseSensivity)
            chmOpen = false;
        if (chmOpen) {
            openChM = (chmPressure - chmMinOpenDelta) / chmFullOpenDelta;
            if (openChM > 1.0f)
                openChM = 1.0f;
        }

        // магистральная диафрагма
        float mdTargetPosition = 4.5f;
        float mdPressure = zkPressure - mkPressure;

        // расчет положения МД
        if (mdPressure >= mdBrakeMax)
            mdTargetPosition = 0.0f;
        else if (mdPressure < -mdReleaseMax)
            mdTargetPosition = 11.0f;
        else if (mdPressure >= mdBrakeThirdStage) {
            float a = (mdPressure - mdBrakeThirdStage) / (mdBrakeMax - mdBrakeThirdStage);
            mdTargetPosition = 1.5f * a;
        }
        else if (mdPressure >= mdBrakeSecondStage) {
            float a = (mdPressure - mdBrakeSecondStage) / (mdBrakeThirdStage - mdBrakeSecondStage);
            mdTargetPosition = 1.5f * a + (1.0f - a) * 3.0f;
        }
        else if (mdPressure >= mdBrakeFirstStage) {
            float a = (mdPressure - mdBrakeFirstStage)/ (mdBrakeSecondStage - mdBrakeFirstStage);
            mdTargetPosition = 3.0f * a + (1.0f - a) * 4.5f;
        }
        else if (mdPressure < 0.0f) {
            float a = -mdPressure / mdReleaseMax;
            mdTargetPosition = 11.0f * a + (1.0f - a) * 4.5f;
        }

        float mdPositionDelta = mdTargetPosition - mdPosition;
        if (mdPositionDelta >= 0.0f) {
            mdPosition = mdPosition + mdSpeed * Math.Sqrt(mdPositionDelta) * dt;
            if (mdPosition > mdTargetPosition)
                mdPosition = mdTargetPosition;
        }
        else {
            mdPosition = mdPosition - mdSpeed * Math.Sqrt(-mdPositionDelta) * dt;
            if (mdPosition < mdTargetPosition)
                mdPosition = mdTargetPosition;
        }

        // открытие клапанов МД
        if (mdPosition < 4.5f) {
            openDR = (4.5f - mdPosition) / 1.5f;
            if (mdPosition < 3.0f) {
                openDR = 1.0f;
                openAK = 1.0f;
                if (mdPosition < 1.5f) {
                    openKP = (1.5f - mdPosition) / 1.5f;
                }
            }
        }
        // 483M
        else if (mdPosition >= 9.75f) {
            openS1_K_P = 1.0f;
            if (mdPosition >= 10.0f) {
                openK_ZK = 1.0f;
                if (mdPosition >= 10.5f) {
                    openMK_S1_P = 1.0f;
                }
            }
        }
        openS1_ZK_P = 1.0f - openS1_K_P;

        // режимная камера (Р и Г режим отпуска)
        if (Mode == ModeR) {
            float rdPressure = rdRatioK * kPressure + rdRatioRK * rkPressure;
            float rdDelta = rdPressure - rdOpenPressure;
            if (rdDelta > 0.0f) {
                openRD = rdDelta / rdFullOpenDelta;
                if (openRD > 1.0f)
                    openRD = 1.0f;
            }
        }

        // главная часть

        // ОК зарядки ЗР
        if (tmPressure - zrPressure > okSensivity)
            openTM_ZR = 1.0f;

        // положение главного поршня
        float gpSpringPressure = 15.0f + gpPosition * gpSpring;
        float gpPressure = rkPressure - (zkPressure + gpSpringPressure);
        if (gpPressure > gpSensivity) {
            gpPosition = gpPosition + gpSpeed * (gpPressure - gpSensivity) * dt;
            if (gpPosition > gpMaxPosition)
                gpPosition = gpMaxPosition;
        }
        else if (gpPressure < -gpSensivity) {
            gpPosition = gpPosition + gpSpeed * (gpPressure + gpSensivity) * dt;
            if (gpPosition < 0.0f)
                gpPosition = 0.0f;
        }

        // увеличение объема РК из-за движения главного поршня
        float rkVolume = scheme.GetVolume(vRK);
        float rkAir = rkPressure * rkVolume;
        rkVolume = rkBaseVolume + gpPosition * gpMaxAddVolume / gpMaxPosition;
        rkPressure = rkAir / rkVolume;
        scheme.SetPressureVolume(vRK, rkPressure, rkVolume);

        // положение уравнительного поршня
        float upPressure = tcPressure - upMinPressure;
        if (upPressure > 0.0f) {
            if (LoadMode == LoadModeG)
                upPosition = upMinPosition + upPositionRange * (upPressure / upMaxPressureG);
            else if (LoadMode == LoadModeS) {
                float pressureG = 0.0f;
                float pressureS = upPressure;
                if (pressureS > upPressureSP) {
                    pressureG = upPressure - upPressureSP;
                    pressureS = upPressureSP;
                }
                upPosition = upMinPosition + upPositionRange * (pressureS / upMaxPressureP + pressureG / upMaxPressureG);
            }
            else
                upPosition = upMinPosition + upPositionRange * (upPressure / upMaxPressureP);
            if (upPosition > upMaxPosition)
                upPosition = upMaxPosition;
        }
        else
            upPosition = upMinPosition;

        // каналы, управляемые главным поршнем
        if (gpPosition < 5.0f) {
            openRK_ZK = 1.0f;
            openKDR_TC = 1.0f;
        }

        // тормозной клапан
        float tkDelta = gpPosition - upPosition;
        if (tkDelta > tkSensivity) {
            float tkHole = 12.0f;
            if (gpPosition > 15.0f)
                tkHole = 1.7f;
            float open = (tkDelta - tkSensivity) / tkApplyFullOpenDelta;
            if (open > 1.0f)
                open = 1.0f;
            openZR_TC = open * SPHelper.Hole(tkHole);
        }
        else if (tkDelta < -tkSensivity) {
            openTC_AT = (-tkDelta - tkSensivity) / tkReleaseFullOpenDelta;
        }

        scheme.SetFlowRate(cMK_S1_P, openMK_S1_P);
        scheme.SetFlowRate(cKP, openKP);
        scheme.SetFlowRate(cS1_ZK_P, openS1_ZK_P);
        scheme.SetFlowRate(cS1_K_P, openS1_K_P);
        scheme.SetFlowRate(cK_ZK_P, openK_ZK);
        scheme.SetFlowRate(cChM, openChM);
        scheme.SetFlowRate(cDR, openDR);
        scheme.SetFlowRate(cAK, openAK);
        scheme.SetFlowRate(cKM, openKM);
        scheme.SetFlowRate(cRD, openRD);
        scheme.SetFlowRate(cTM_ZR, openTM_ZR);
        scheme.SetFlowRate(cRK_ZK, openRK_ZK);
        scheme.SetFlowRate(cZR_TC, openZR_TC);
        scheme.SetFlowRate(cKDR_TC, openKDR_TC);
        scheme.SetFlowRate(cTC_AT, openTC_AT);
    }

    public Soup GetProperties()
    {
        Soup sp = inherited();
        sp.SetNamedTag("mode", Mode);
        sp.SetNamedTag("load-mode", LoadMode);
        sp.SetNamedTag("km-open-pressure", kmOpenPressure);
        sp.SetNamedTag("chm-open", chmOpen);
        sp.SetNamedTag("md-position", mdPosition);
        sp.SetNamedTag("gp-position", gpPosition);
        sp.SetNamedTag("up-position", upPosition);
        return sp;
    }

    public void SetProperties(Soup sp)
    {
        inherited(sp);
        Mode = SPHelper.GetInt(sp, "mode", Mode);
        LoadMode = SPHelper.GetInt(sp, "load-mode", LoadMode);
        kmOpenPressure = SPHelper.GetFloat(sp, "km-open-pressure", kmOpenPressure);
        chmOpen = SPHelper.GetBool(sp, "chm-open", chmOpen);
        mdPosition = SPHelper.GetFloat(sp, "md-position", mdPosition);
        gpPosition = SPHelper.GetFloat(sp, "gp-position", gpPosition);
        upPosition = SPHelper.GetFloat(sp, "up-position", upPosition);
    }
};