From ea9c6d98dc9a5fe256812b13157654239992cf41 Mon Sep 17 00:00:00 2001 From: firleju Date: Mon, 26 Sep 2016 17:48:10 +0200 Subject: [PATCH] Translacja hamulce.pas. Pliki wynikowe. --- McZapkie/hamulce.cpp | 2596 ++++++++++++++++++++++++++++++++++++++++++ McZapkie/hamulce.h | 714 ++++++++++++ 2 files changed, 3310 insertions(+) create mode 100644 McZapkie/hamulce.cpp create mode 100644 McZapkie/hamulce.h diff --git a/McZapkie/hamulce.cpp b/McZapkie/hamulce.cpp new file mode 100644 index 00000000..ce271a0c --- /dev/null +++ b/McZapkie/hamulce.cpp @@ -0,0 +1,2596 @@ +/* +This Source Code Form is subject to the +terms of the Mozilla Public License, v. +2.0. If a copy of the MPL was not +distributed with this file, You can +obtain one at +http://mozilla.org/MPL/2.0/. +*/ +/* +MaSzyna EU07 - SPKS +Brakes. Oerlikon ESt. +Copyright (C) 2007-2014 Maciej Cierniak +*/ + +#include "hamulce.h" +#include "../Mover.h" + +//---FUNKCJE OGOLNE--- + + static double/*?*/ const DPL = 0.25; + +double PR(double P1, double P2) +{ double result; double PH; double PL; + + PH =Max0R( P1, P2 )+0.1; + PL =P1+P2-PH+0.2; + PR =( P2-P1 )*1.0/( 1.13*PH-PL ); +return result; +} + +double PF_old(double P1, double P2, double S) +{ double result; double PH; double PL; + + PH =Max0R( P1, P2 )+1; + PL =P1+P2-PH+2; + if( PH-PL<0.0001 ) PF_old =0;else + if( ( PH-PL )<0.05 ) + PF_old =20*( PH-PL )*( PH+1 )*222*S*( P2-P1 )*1.0/( 1.13*PH-PL );else + PF_old =( PH+1 )*222*S*( P2-P1 )*1.0/( 1.13*PH-PL ); +return result; +} + +double PF(double P1, double P2, double S, double DP = 0.25) +{ double result; double PH; double PL; double sg; double FM; + + PH =Max0R( P1, P2 )+1; //wyzsze cisnienie absolutne + PL =P1+P2-PH+2; //nizsze cisnienie absolutne + sg =PL*1.0/PH; //bezwymiarowy stosunek cisnien + FM =PH*197*S*sign( P2-P1 ); //najwyzszy mozliwy przeplyw, wraz z kierunkiem + if( ( sg>0.5 ) ) //jesli ponizej stosunku krytycznego + if( ( PH-PL )0.5 ) ) //jesli ponizej stosunku krytycznego + if( ( sgPL ) + { + LIM =LIM+1; + PH =PH+1; //wyzsze cisnienie absolutne + PL =PL+1; //nizsze cisnienie absolutne + sg =PL*1.0/PH; //bezwymiarowy stosunek cisnien + FM =PH*197*S; //najwyzszy mozliwy przeplyw, wraz z kierunkiem + if( ( LIM-PL )0.5 ) ) //jesli ponizej stosunku krytycznego + if( ( PH-PL )0.5 ) ) //jesli ponizej stosunku krytycznego + if( ( PH-PL )0.88 then P:=0.5+(VtoC-0.88)*1.043-0.064*(VtoC-0.88)*(VtoC-0.88) + else P:=0.15+0.35/0.82*(VtoC-0.06); +end; */ + +//(* STARA WERSJA +double TBrakeCyl::P() +{ double result; double VtoC; //stosunek cisnienia do objetosci + + static double/*?*/ const VS = 0.005; + static double/*?*/ const pS = 0.05; + static double/*?*/ const VD = 1.10; + static double/*?*/ const cD = 1; + static double/*?*/ const pD = VD-cD; + + VtoC =Vol*1.0/Cap; +// P:=VtoC; + if( VtoCVD ) P =VtoC-cD //caly silownik;else P =pS+( VtoC-VS )*1.0/( VD-VS )*( pD-pS ); //wysuwanie tloka +return result; +} //*) + + +//---HAMULEC--- +/* +constructor TBrake.Create(i_mbp, i_bcr, i_bcd, i_brc: real; i_bcn, i_BD, i_mat, i_ba, i_nbpa: byte); +begin + inherited Create; + MaxBP:=i_mbp; + BCN:=i_bcn; + BCA:=i_bcn*i_bcr*i_bcr*pi; + BA:=i_ba; + NBpA:=i_nbpa; + BrakeDelays:=i_BD; + +//tworzenie zbiornikow + BrakeCyl.CreateCap(i_bcd*BCA*1000); + BrakeRes.CreateCap(i_brc); + ValveRes.CreateCap(0.2); + +// FM.Free; +//materialy cierne + case i_mat of + bp_P10Bg: FM:=TP10Bg.Create; + bp_P10Bgu: FM:=TP10Bgu.Create; + else //domyslnie + FM:=TP10.Create; + end; + + +end ; */ + +/*?*//*CONSTRUCTOR*/void TBrake::Create(double i_mbp, double i_bcr, double i_bcd, double i_brc, unsigned char i_bcn, unsigned char i_BD, unsigned char i_mat, unsigned char i_ba, unsigned char i_nbpa) +{ + inherited:: Create; + MaxBP =i_mbp; + BCN =i_bcn; + BCA =i_bcn*i_bcr*i_bcr*pi; + BA =i_ba; + NBpA =i_nbpa; + BrakeDelays =i_BD; + //210.88 +// SizeBR:=i_bcn*i_bcr*i_bcr*i_bcd*40.17*MaxBP/(5-MaxBP); //objetosc ZP w stosunku do cylindra 14" i cisnienia 4.2 atm + SizeBR =i_brc*0.0128; + SizeBC =i_bcn*i_bcr*i_bcr*i_bcd*210.88*MaxBP*1.0/4.2; //objetosc CH w stosunku do cylindra 14" i cisnienia 4.2 atm + +// BrakeCyl:=TReservoir.Create; + BrakeCyl =TBrakeCyl.Create; + BrakeRes =TReservoir.Create; + ValveRes =TReservoir.Create; + +//tworzenie zbiornikow + BrakeCyl.CreateCap( i_bcd*BCA*1000 ); + BrakeRes.CreateCap( i_brc ); + ValveRes.CreateCap( 0.25 ); + +// FM.Free; +//materialy cierne + i_mat =i_mat && ( 255-bp_MHS ); + switch( i_mat ) { + case bp_P10Bg: FM =TP10Bg.Create; + case bp_P10Bgu: FM =TP10Bgu.Create; + case bp_FR513: FM =TFR513.Create; + case bp_FR510: FM =TFR510.Create; + case bp_Cosid: FM =TCosid.Create; + case bp_P10yBg: FM =TP10yBg.Create; + case bp_P10yBgu: FM =TP10yBgu.Create; + case bp_D1: FM =TDisk1.Create; + case bp_D2: FM =TDisk2.Create; + default: //domyslnie + FM =TP10.Create; + } +} + +//inicjalizacja hamulca (stan poczatkowy) +void TBrake::Init(double PP, double HPP, double LPP, double BP, unsigned char BDF) +{ + +} + +//pobranie wspolczynnika tarcia materialu +double TBrake::GetFC(double Vel, double N) +{ double result; + GetFC =FM.GetFC( N , Vel ); +return result; +} + +//cisnienie cylindra hamulcowego +double TBrake::GetBCP() +{ double result; + GetBCP =BrakeCyl.P; +return result; +} + +//cisnienie zbiornika pomocniczego +double TBrake::GetBRP() +{ double result; + GetBRP =BrakeRes.P; +return result; +} + +//cisnienie komory wstepnej +double TBrake::GetVRP() +{ double result; + GetVRP =ValveRes.P; +return result; +} + +//cisnienie zbiornika sterujacego +double TBrake::GetCRP() +{ double result; + GetCRP =0; +return result; +} + +//przeplyw z przewodu glowneg +double TBrake::GetPF(double PP, double dt, double Vel) +{ double result; + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + GetPF =0; +return result; +} + +//przeplyw z przewodu zasilajacego +double TBrake::GetHPFlow(double HP, double dt) +{ double result; + GetHPFlow =0; +return result; +} + +double TBrake::GetBCF() +{ double result; + GetBCF =BCA*100*BrakeCyl.P; +return result; +} + +bool TBrake::SetBDF(unsigned char nBDF) +{ bool result; + if( ( ( nBDF && BrakeDelays )==nBDF )&&( nBDF!=BrakeDelayFlag ) ) + { + BrakeDelayFlag =nBDF; + SetBDF =true; + } + else + SetBDF =false; +return result; +} + +void TBrake::Releaser(unsigned char state) +{ + BrakeStatus =( BrakeStatus && 247 ) || state*b_rls; +} + +void TBrake::SetEPS(double nEPS) +{ + +} + +void TBrake::ASB(unsigned char state) +{ //255-b_asb(32) + BrakeStatus =( BrakeStatus && 223 ) || state*b_asb; +} + +unsigned char TBrake::GetStatus() +{ unsigned char result; + GetStatus =BrakeStatus; +return result; +} + +unsigned char TBrake::GetSoundFlag() +{ unsigned char result; + GetSoundFlag =SoundFlag; + SoundFlag =0; +return result; +} + +void TBrake::SetASBP(double Press) +{ + ASBP =Press; +} + +void TBrake::ForceEmptiness() +{ + ValveRes.CreatePress( 0 ); + BrakeRes.CreatePress( 0 ); + ValveRes.Act( ); + BrakeRes.Act( ); +} + + +//---WESTINGHOUSE--- + +void TWest::Init(double PP, double HPP, double LPP, double BP, unsigned char BDF) +{ + ValveRes.CreatePress( PP ); + BrakeCyl.CreatePress( BP ); + BrakeRes.CreatePress( PP*1.0/2+HPP*1.0/2 ); +// BrakeStatus:=3*Byte(BP>0.1); +} + +double TWest::GetPF(double PP, double dt, double Vel) +{ double result; double dv; double dV1; + double VVP; double BVP; double CVP; double BCP; + double temp; + + + BVP =BrakeRes.P; + VVP =ValveRes.P; + CVP =BrakeCyl.P; + BCP =BrakeCyl.P; + + if( ( BrakeStatus && 1 )==1 ) + if( ( VVP+0.03BVP+0.1 ) ) + BrakeStatus =( BrakeStatus && 252 );else if( ( VVP>BVP ) ) + BrakeStatus =( BrakeStatus && 253 );else + ;else + if( ( VVP+0.25LBP+0.01 ) && ( DCV ) ) + dv =PF( 0, CVP, 0.1*SizeBC )*dt;else dv =0; + BrakeCyl.Flow( -dv ); + +//hamulec EP + temp =BVP*unsigned char( EPS>0 ); + dv =PF( temp, LBP, 0.0015 )*dt*EPS*EPS*unsigned char( LBP*EPS silowniki + if( ( ( BrakeStatus && b_on )==b_on )&&( ( TareBP<0.1 )||( BCPLBP ) ) + { + DCV =false; + dv =PF( BVP, CVP, 0.017*SizeBC )*dt; + } + else dv =0;else dv =0; + BrakeRes.Flow( dv ); + BrakeCyl.Flow( -dv ); + if( ( DCV ) ) + dVP =PF( LBP, BCP, 0.01*SizeBC )*dt;else dVP =0; + BrakeCyl.Flow( -dVP ); + if( ( dVP>0 ) ) dVP =0; +//przeplyw ZP <-> rozdzielacz + if( ( ( BrakeStatus && b_hld )==b_off ) ) + dv =PF( BVP, VVP, 0.0011*SizeBR )*dt;else dv =0; + BrakeRes.Flow( dv ); + dV1 =dv*0.95; + ValveRes.Flow( -0.05*dv ); +//przeplyw PG <-> rozdzielacz + dv =PF( PP, VVP, 0.01*SizeBR )*dt; + ValveRes.Flow( -dv ); + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + GetPF =dv-dV1; +return result; +} + +double TWest::GetHPFlow(double HP, double dt) +{ double result; + GetHPFlow =dVP; +return result; +} + +void TWest::SetLBP(double P) +{ + LBP =P; + if( P>BrakeCyl.P ) +// begin + DCV =true; +// end +// else +// LBP:=P; +} + +void TWest::SetEPS(double nEPS) +{ + double BCP; + + BCP =BrakeCyl.P; + if( nEPS>0 ) + DCV =true;else if( nEPS==0 ) + { + if( ( EPS!=0 ) ) + { + if( ( LBP>0.4 ) ) + LBP =BrakeCyl.P; + if( ( LBP<0.15 ) ) + LBP =0; + } + } + EPS =nEPS; +} + +void TWest::PLC(double mass) +{ + LoadC =1+unsigned char( mass0.25 ) ) + if( ( VVP+0.003+BCP*1.0/BVMCVP ) ) + BrakeStatus =( BrakeStatus && 252 ) //luzowanie;else if( ( VVP+BCP*1.0/BVM>CVP ) ) + BrakeStatus =( BrakeStatus && 253 ) //zatrzymanie napelaniania;else + ;else + if( ( VVP+0.100.25 )&&( BCP>0.25 ) ) //zatrzymanie luzowanie + BrakeStatus =( BrakeStatus || 1 ); + + if( ( BrakeStatus && 1 )==0 ) + SoundFlag =SoundFlag || sf_CylU; +} + +double TESt::CVs(double BP) +{ double result; double VVP; double BVP; double CVP; + + BVP =BrakeRes.P; + CVP =CntrlRes.P; + VVP =ValveRes.P; + +//przeplyw ZS <-> PG + if( ( VVP0.4 ) ) + CVs =0;else + if( ( VVP>CVP+0.4 ) ) + if( ( BVP>CVP+0.2 ) ) + CVs =0.23;else + CVs =0.05;else + if( ( BVP>CVP-0.1 ) ) + CVs =1;else + CVs =0.3; +return result; +} + +double TESt::BVs(double BCP) +{ double result; double VVP; double BVP; double CVP; + + BVP =BrakeRes.P; + CVP =CntrlRes.P; + VVP =ValveRes.P; + +//przeplyw ZP <-> rozdzielacz + if( ( BVPCVP+0.4 ) ) + BVs =0.1;else + BVs =0.3;else + BVs =0; +return result; +} + + + + + +double TESt::GetPF(double PP, double dt, double Vel) +{ double result; double dv; double dV1; double temp; + double VVP; double BVP; double BCP; double CVP; + + BVP =BrakeRes.P; + VVP =ValveRes.P; + BCP =BrakeCyl.P; + CVP =CntrlRes.P-0.0; + + dv =0; dV1 =0; + +//sprawdzanie stanu + CheckState( BCP , dV1 ); + CheckReleaser( dt ); + + CVP =CntrlRes.P; + VVP =ValveRes.P; +//przeplyw ZS <-> PG + temp =CVs( BCP ); + dv =PF( CVP, VVP, 0.0015*temp )*dt; + CntrlRes.Flow( +dv ); + ValveRes.Flow( -0.04*dv ); + dV1 =dV1-0.96*dv; + + +//luzowanie + if( ( BrakeStatus && b_hld )==b_off ) + dv =PF( 0, BCP, 0.0058*SizeBC )*dt;else dv =0; + BrakeCyl.Flow( -dv ); + +//przeplyw ZP <-> silowniki + if( ( BrakeStatus && b_on )==b_on ) + dv =PF( BVP, BCP, 0.016*SizeBC )*dt;else dv =0; + BrakeRes.Flow( dv ); + BrakeCyl.Flow( -dv ); + +//przeplyw ZP <-> rozdzielacz + temp =BVs( BCP ); +// if(BrakeStatus and b_hld)=b_off then + if( ( VVP-0.05>BVP ) ) + dv =PF( BVP, VVP, 0.02*SizeBR*temp*1.0/1.87 )*dt;else dv =0; + BrakeRes.Flow( dv ); + dV1 =dV1+dv*0.96; + ValveRes.Flow( -0.04*dv ); +//przeplyw PG <-> rozdzielacz + dv =PF( PP, VVP, 0.01 )*dt; + ValveRes.Flow( -dv ); + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; + GetPF =dv-dV1; +return result; +} + +void TESt::Init(double PP, double HPP, double LPP, double BP, unsigned char BDF) +{ + ValveRes.CreatePress( PP ); + BrakeCyl.CreatePress( BP ); + BrakeRes.CreatePress( PP ); + CntrlRes =TReservoir.Create; + CntrlRes.CreateCap( 15 ); + CntrlRes.CreatePress( HPP ); + BrakeStatus =0; + + BVM =1*1.0/( HPP-LPP )*MaxBP; + + BrakeDelayFlag =BDF; +} + + +void TESt::EStParams(double i_crc) +{ + +} + + +double TESt::GetCRP() +{ double result; + GetCRP =CntrlRes.P; +return result; +} + +//---EP2--- + +void TEStEP2::Init(double PP, double HPP, double LPP, double BP, unsigned char BDF) +{ + inherited::/*?*/PROC_NAME; + ImplsRes.CreateCap( 1 ); + ImplsRes.CreatePress( BP ); + + BrakeRes.CreatePress( PP ); + + BrakeDelayFlag =bdelay_P; + BrakeDelays =bdelay_P; +} + + +double TEStEP2::GetPF(double PP, double dt, double Vel) +{ double result; double dv; double dV1; double temp; + double VVP; double BVP; double BCP; double CVP; + + BVP =BrakeRes.P; + VVP =ValveRes.P; + BCP =ImplsRes.P; + CVP =CntrlRes.P; //110115 - konsultacje warszawa1 + + dv =0; dV1 =0; + +//odluzniacz + CheckReleaser( dt ); + +//sprawdzanie stanu + if( ( ( BrakeStatus && 1 )==1 )&&( BCP>0.25 ) ) + if( ( VVP+0.003+BCP*1.0/BVMCVP-0.12 ) ) + BrakeStatus =( BrakeStatus && 252 ) //luzowanie;else if( ( VVP+BCP*1.0/BVM>CVP-0.12 ) ) + BrakeStatus =( BrakeStatus && 253 ) //zatrzymanie napelaniania;else + ;else + if( ( VVP+0.100.25 ) ) //zatrzymanie luzowanie + BrakeStatus =( BrakeStatus || 1 ); + +//przeplyw ZS <-> PG + if( ( BVP0 )||( BCP>0.25 ) ) + temp =0;else + if( ( VVP>CVP+0.4 ) ) + temp =0.1;else + temp =0.5; + + dv =PF( CVP, VVP, 0.0015*temp*1.0/1.8 )*dt; + CntrlRes.Flow( +dv ); + ValveRes.Flow( -0.04*dv ); + dV1 =dV1-0.96*dv; + +//hamulec EP + temp =BVP*unsigned char( EPS>0 ); + dv =PF( temp, LBP, 0.00053+0.00060*unsigned char( EPS<0 ) )*dt*EPS*EPS*unsigned char( LBP*EPS KI + if( ( ( BrakeStatus && b_on )==b_on ) && ( BCP rozdzielacz + dv =PF( PP, VVP, 0.01*SizeBR )*dt; + ValveRes.Flow( -dv ); + + GetPF =dv-dV1; + + temp =Max0R( BCP, LBP ); + + if( ( ImplsRes.P>LBP+0.01 ) ) + LBP =0; + +//luzowanie CH + if( ( BrakeCyl.P>temp+0.005 )||( Max0R( ImplsRes.P, 8*LBP )<0.05 ) ) + dv =PF( 0, BrakeCyl.P, 0.25*SizeBC*( 0.01+( BrakeCyl.P-temp ) ) )*dt;else dv =0; + BrakeCyl.Flow( -dv ); +//przeplyw ZP <-> CH + if( ( BrakeCyl.P0.10 )&&( Max0R( BCP, LBP )0 ) && ( LBP+0.01 PG + temp =CVs( BCP ); + dv =PF( CVP, VVP, 0.0015*temp )*dt; + CntrlRes.Flow( +dv ); + ValveRes.Flow( -0.04*dv ); + dV1 =dV1-0.96*dv; + + +//luzowanie + if( ( BrakeStatus && b_hld )==b_off ) + dv =PF( 0, BCP, 0.0042*( 1.37-unsigned char( BrakeDelayFlag==bdelay_G ) )*SizeBC )*dt;else dv =0; + BrakeCyl.Flow( -dv ); +//przeplyw ZP <-> silowniki + if( ( BrakeStatus && b_on )==b_on ) + dv =PF( BVP, BCP, 0.017*( 1+unsigned char( ( BCP<0.58 )&&( BrakeDelayFlag==bdelay_G ) ) )*( 1.13-unsigned char( ( BCP>0.6 )&&( BrakeDelayFlag==bdelay_G ) ) )*SizeBC )*dt;else dv =0; + BrakeRes.Flow( dv ); + BrakeCyl.Flow( -dv ); +//przeplyw ZP <-> rozdzielacz + temp =BVs( BCP ); + if( ( VVP-0.05>BVP ) ) + dv =PF( BVP, VVP, 0.02*SizeBR*temp*1.0/1.87 )*dt;else dv =0; + BrakeRes.Flow( dv ); + dV1 =dV1+dv*0.96; + ValveRes.Flow( -0.04*dv ); +//przeplyw PG <-> rozdzielacz + dv =PF( PP, VVP, 0.01 )*dt; + ValveRes.Flow( -dv ); + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; + GetPF =dv-dV1; +return result; +} + +//---EST4-RAPID--- + +double TESt4R::GetPF(double PP, double dt, double Vel) +{ double result; double dv; double dV1; double temp; + double VVP; double BVP; double BCP; double CVP; + + BVP =BrakeRes.P; + VVP =ValveRes.P; + BCP =ImplsRes.P; + CVP =CntrlRes.P-0.0; + + dv =0; dV1 =0; + +//sprawdzanie stanu + CheckState( BCP , dV1 ); + CheckReleaser( dt ); + + CVP =CntrlRes.P; + VVP =ValveRes.P; +//przeplyw ZS <-> PG + temp =CVs( BCP ); + dv =PF( CVP, VVP, 0.0015*temp*1.0/1.8 )*dt; + CntrlRes.Flow( +dv ); + ValveRes.Flow( -0.04*dv ); + dV1 =dV1-0.96*dv; + + +//luzowanie KI + if( ( BrakeStatus && b_hld )==b_off ) + dv =PF( 0, BCP, 0.00037*1.14*15*1.0/19 )*dt;else dv =0; + ImplsRes.Flow( -dv ); +//przeplyw ZP <-> KI + if( ( BrakeStatus && b_on )==b_on ) + dv =PF( BVP, BCP, 0.0014 )*dt;else dv =0; +// BrakeRes.Flow(dV); + ImplsRes.Flow( -dv ); +//przeplyw ZP <-> rozdzielacz + temp =BVs( BCP ); + if( ( BVP rozdzielacz + dv =PF( PP, VVP, 0.01*SizeBR )*dt; + ValveRes.Flow( -dv ); + + GetPF =dv-dV1; + + + + RapidStatus =( BrakeDelayFlag==bdelay_R )&&( ( ( Vel>55 )&&( RapidStatus ) )||( Vel>70 ) ); + + RapidTemp =RapidTemp+( 0.9*unsigned char( RapidStatus )-RapidTemp )*dt*1.0/2; + temp =1.9-RapidTemp; + if( ( ( BrakeStatus && b_asb )==b_asb ) ) + temp =1000; +//luzowanie CH + if( ( BrakeCyl.P*temp>ImplsRes.P+0.005 )||( ImplsRes.P<0.25 ) ) + if( ( ( BrakeStatus && b_asb )==b_asb ) ) + dv =PFVd( BrakeCyl.P, 0, 0.115*SizeBC*4, ImplsRes.P*1.0/temp )*dt;else + dv =PFVd( BrakeCyl.P, 0, 0.115*SizeBC, ImplsRes.P*1.0/temp )*dt +// dV:=PF(0,BrakeCyl.P,0.115*sizeBC/2)*dt +// dV:=PFVd(BrakeCyl.P,0,0.015*sizeBC/2,ImplsRes.P/temp)*dt;else dv =0; + BrakeCyl.Flow( -dv ); +//przeplyw ZP <-> CH + if( ( BrakeCyl.P*temp0.3 ) ) +// dV:=PFVa(BVP,BrakeCyl.P,0.020*sizeBC,ImplsRes.P/temp)*dt + dv =PFVa( BVP, BrakeCyl.P, 0.60*SizeBC, ImplsRes.P*1.0/temp )*dt;else dv =0; + BrakeRes.Flow( -dv ); + BrakeCyl.Flow( +dv ); + + ImplsRes.Act; + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; +return result; +} + +void TESt4R::Init(double PP, double HPP, double LPP, double BP, unsigned char BDF) +{ + inherited::/*?*/PROC_NAME; + ImplsRes =TReservoir.Create; + ImplsRes.CreateCap( 1 ); + ImplsRes.CreatePress( BP ); + + BrakeDelayFlag =bdelay_R; +} + + +//---EST3/AL2--- + +double TESt3AL2::GetPF(double PP, double dt, double Vel) +{ double result; double dv; double dV1; double temp; + double VVP; double BVP; double BCP; double CVP; + + BVP =BrakeRes.P; + VVP =ValveRes.P; + BCP =ImplsRes.P; + CVP =CntrlRes.P-0.0; + + dv =0; dV1 =0; + +//sprawdzanie stanu + CheckState( BCP , dV1 ); + CheckReleaser( dt ); + + VVP =ValveRes.P; +//przeplyw ZS <-> PG + temp =CVs( BCP ); + dv =PF( CVP, VVP, 0.0015*temp )*dt; + CntrlRes.Flow( +dv ); + ValveRes.Flow( -0.04*dv ); + dV1 =dV1-0.96*dv; + +//luzowanie KI + if( ( BrakeStatus && b_hld )==b_off ) + dv =PF( 0, BCP, 0.00017*( 1.37-unsigned char( BrakeDelayFlag==bdelay_G ) ) )*dt;else dv =0; + ImplsRes.Flow( -dv ); +//przeplyw ZP <-> KI + if( ( ( BrakeStatus && b_on )==b_on ) && ( BCP0.6 )&&( BrakeDelayFlag==bdelay_G ) ) ) )*dt;else dv =0; + BrakeRes.Flow( dv ); + ImplsRes.Flow( -dv ); +//przeplyw ZP <-> rozdzielacz + temp =BVs( BCP ); + if( ( VVP-0.05>BVP ) ) + dv =PF( BVP, VVP, 0.02*SizeBR*temp*1.0/1.87 )*dt;else dv =0; + BrakeRes.Flow( dv ); + dV1 =dV1+dv*0.96; + ValveRes.Flow( -0.04*dv ); +//przeplyw PG <-> rozdzielacz + dv =PF( PP, VVP, 0.01 )*dt; + ValveRes.Flow( -dv ); + GetPF =dv-dV1; + +//luzowanie CH + if( ( BrakeCyl.P>ImplsRes.P*LoadC+0.005 )||( ImplsRes.P<0.15 ) ) + dv =PF( 0, BrakeCyl.P, 0.015*SizeBC )*dt;else dv =0; + BrakeCyl.Flow( -dv ); + +//przeplyw ZP <-> CH + if( ( BrakeCyl.P0.15 ) ) + dv =PF( BVP, BrakeCyl.P, 0.020*SizeBC )*dt;else dv =0; + BrakeRes.Flow( dv ); + BrakeCyl.Flow( -dv ); + + ImplsRes.Act; + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; +return result; +} + +void TESt3AL2::PLC(double mass) +{ + LoadC =1+unsigned char( mass PG + if( ( ( CVP-BCP )*BVM>0.5 ) ) + temp =0;else + if( ( VVP>CVP+0.4 ) ) + temp =0.5;else + temp =0.5; + + dv =PF1( CVP, VVP, 0.0015*temp*1.0/1.8*1.0/2 )*dt; + CntrlRes.Flow( +dv ); + ValveRes.Flow( -0.04*dv ); + dV1 =dV1-0.96*dv; + + +//luzowanie KI {G} +// if VVP>BCP then +// dV:=PF(VVP,BCP,0.00004)*dt +// else if (CVP-BCP)<1.5 then +// dV:=PF(VVP,BCP,0.00020*(1.33-Byte((CVP-BCP)*BVM>0.65)))*dt +// else dV:=0; 0.00025 P + /*P*/ + if( VVP>BCP ) + dv =PF( VVP, BCP, 0.00043*( 1.5-unsigned char( ( ( CVP-BCP )*BVM>1 )&&( BrakeDelayFlag==bdelay_G ) ) ), 0.1 )*dt;else if( ( CVP-BCP )<1.5 ) + dv =PF( VVP, BCP, 0.001472*( 1.36-unsigned char( ( ( CVP-BCP )*BVM>1 )&&( BrakeDelayFlag==bdelay_G ) ) ), 0.1 )*dt;else dv =0; + + ImplsRes.Flow( -dv ); + ValveRes.Flow( +dv ); +//przeplyw PG <-> rozdzielacz + dv =PF( PP, VVP, 0.01, 0.1 )*dt; + ValveRes.Flow( -dv ); + + GetPF =dv-dV1; + +// if Vel>55 then temp:=0.72 else +// temp:=1;{R} +//cisnienie PP + RapidTemp =RapidTemp+( RM*unsigned char( ( Vel>55 )&&( BrakeDelayFlag==bdelay_R ) )-RapidTemp )*dt*1.0/2; + temp =1-RapidTemp; + if( EDFlag>0.2 ) temp =10000; + +//powtarzacz — podwojny zawor zwrotny + temp =Max0R( ( ( CVP-BCP )*BVM+ASBP*unsigned char( ( BrakeStatus && b_asb )==b_asb ) )*1.0/temp, LBP ); +//luzowanie CH + if( ( BrakeCyl.P>temp+0.005 )||( temp<0.28 ) ) +// dV:=PF(0,BrakeCyl.P,0.0015*3*sizeBC)*dt +// dV:=PF(0,BrakeCyl.P,0.005*3*sizeBC)*dt + dv =PFVd( BrakeCyl.P, 0, 0.005*7*SizeBC, temp )*dt;else dv =0; + BrakeCyl.Flow( -dv ); +//przeplyw ZP <-> CH + if( ( BrakeCyl.P0.29 ) ) +// dV:=PF(BVP,BrakeCyl.P,0.002*3*sizeBC*2)*dt + dv =-PFVa( BVP, BrakeCyl.P, 0.002*7*SizeBC*2, temp )*dt;else dv =0; + BrakeRes.Flow( dv ); + BrakeCyl.Flow( -dv ); + + ImplsRes.Act; + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; +// LBP:=ValveRes.P; +// ValveRes.CreatePress(ImplsRes.P); +return result; +} + +void TLSt::Init(double PP, double HPP, double LPP, double BP, unsigned char BDF) +{ + inherited::/*?*/PROC_NAME; + ValveRes.CreateCap( 1 ); + ImplsRes.CreateCap( 8 ); + ImplsRes.CreatePress( PP ); + BrakeRes.CreatePress( 8 ); + ValveRes.CreatePress( PP ); + + EDFlag =0; + + BrakeDelayFlag =BDF; +} + +void TLSt::SetLBP(double P) +{ + LBP =P; +} + +double TLSt::GetEDBCP() +{ double result; double CVP; double BCP; + + CVP =CntrlRes.P; + BCP =ImplsRes.P; + GetEDBCP =( CVP-BCP )*BVM; +return result; +} + +void TLSt::SetED(double EDstate) +{ + EDFlag =EDstate; +} + +void TLSt::SetRM(double RMR) +{ + RM =1-RMR; +} + +double TLSt::GetHPFlow(double HP, double dt) +{ double result; double dv; + + dv =Min0R( PF( HP, BrakeRes.P, 0.01*dt ), 0 ); + BrakeRes.Flow( -dv ); + GetHPFlow =dv; +return result; +} + +//---EStED--- + +double TEStED::GetPF(double PP, double dt, double Vel) +{ double result; double dv; double dV1; double temp; + double VVP; double BVP; double BCP; double CVP; double MPP; double nastG; + unsigned char i; + + BVP =BrakeRes.P; + VVP =ValveRes.P; + BCP =ImplsRes.P; + CVP =CntrlRes.P-0.0; + MPP =Miedzypoj.P; + dV1 =0; + + nastG =( BrakeDelayFlag && bdelay_G ); + +//sprawdzanie stanu + if( ( BCP<0.25 )&&( VVP+0.08>CVP ) ) Przys_blok =false; + +//sprawdzanie stanu + if( ( VVP+0.002+BCP*1.0/BVMCVP-0.05 ) ) + BrakeStatus =( BrakeStatus && 252 ) //luzowanie;else if( ( VVP+BCP*1.0/BVM>CVP-0.05 ) ) + BrakeStatus =( BrakeStatus && 253 ) //zatrzymanie napelaniania;else if( ( VVP+( BCP-0.1 )*1.0/BVM0.25 ) ) //zatrzymanie luzowania + BrakeStatus =( BrakeStatus || 1 ); + + if( ( VVP+0.100.5 ) ) + Zamykajacy =true;else if( ( VVP-0.6CVP-0.08 ) ) + temp =Nozzles[ 5 ];else + temp =Nozzles[ 6 ]; + dv =dv+PF( MPP, CVP, temp ); + + if( ( MPP-0.05>BVP ) ) + dv =dv+PF( MPP-0.05, BVP, Nozzles[ 10 ]*nastG+( 1-nastG )*Nozzles[ 9 ] ); + if( MPP>VVP ) dv =dv+PF( MPP, VVP, 0.02 ); + Miedzypoj.Flow( dv*dt*0.15 ); + + + RapidTemp =RapidTemp+( RM*unsigned char( ( Vel>55 )&&( BrakeDelayFlag==bdelay_R ) )-RapidTemp )*dt*1.0/2; + temp =Max0R( 1-RapidTemp, 0.001 ); +// if EDFlag then temp:=1000; +// temp:=temp/(1-); + +//powtarzacz — podwojny zawor zwrotny + temp =Max0R( LoadC*BCP*1.0/temp*Min0R( Max0R( 1-EDFlag, 0 ), 1 ), LBP ); + + if( ( BrakeCyl.P>temp ) ) + dv =-PFVd( BrakeCyl.P, 0, 0.02*SizeBC, temp )*dt;else + if( ( BrakeCyl.P0 ) + BrakeRes.Flow( -dv ); + + +//przeplyw ZS <-> PG + if( ( MPPCVP-0.08 ) ) + temp =Nozzles[ 5 ];else + temp =Nozzles[ 6 ]; + dv =PF( CVP, MPP, temp )*dt; + CntrlRes.Flow( +dv ); + ValveRes.Flow( -0.02*dv ); + dV1 =dV1+0.98*dv; + +//przeplyw ZP <-> MPJ + if( ( MPP-0.05>BVP ) ) + dv =PF( BVP, MPP-0.05, Nozzles[ 10 ]*nastG+( 1-nastG )*Nozzles[ 9 ] )*dt;else dv =0; + BrakeRes.Flow( dv ); + dV1 =dV1+dv*0.98; + ValveRes.Flow( -0.02*dv ); +//przeplyw PG <-> rozdzielacz + dv =PF( PP, VVP, 0.005 )*dt; //0.01 + ValveRes.Flow( -dv ); + + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; + Miedzypoj.Act; + ImplsRes.Act; + GetPF =dv-dV1; +return result; +} + +void TEStED::Init(double PP, double HPP, double LPP, double BP, unsigned char BDF) +{ int i; + + inherited::/*?*/PROC_NAME; + + ValveRes.CreatePress( 1*PP ); + BrakeCyl.CreatePress( 1*BP ); + +// CntrlRes:=TReservoir.Create; +// CntrlRes.CreateCap(15); +// CntrlRes.CreatePress(1*HPP); + + BrakeStatus =unsigned char( BP>1 )*1; + Miedzypoj =TReservoir.Create; + Miedzypoj.CreateCap( 5 ); + Miedzypoj.CreatePress( PP ); + + ImplsRes.CreateCap( 1 ); + ImplsRes.CreatePress( BP ); + + BVM =1*1.0/( HPP-0.05-LPP )*MaxBP; + + BrakeDelayFlag =BDF; + Zamykajacy =false; + EDFlag =0; + + Nozzles[ 0 ] =1.250*1.0/1.7; + Nozzles[ 1 ] =0.907; + Nozzles[ 2 ] =0.510*1.0/1.7; + Nozzles[ 3 ] =0.524*1.0/1.17; + Nozzles[ 4 ] =7.4; + Nozzles[ 7 ] =5.3; + Nozzles[ 8 ] =2.5; + Nozzles[ 9 ] =7.28; + Nozzles[ 10 ] =2.96; + Nozzles[ 5 ] =1.1; + Nozzles[ 6 ] =0.9; + + { long i_end = 11 ; for( i = 0 ; i < i_end ; ++i ) + { + Nozzles[ i ] =Nozzles[ i ]*Nozzles[ i ]*3.14159*1.0/4000; + }} + +} + +double TEStED::GetEDBCP() +{ double result; + GetEDBCP =ImplsRes.P*LoadC; +return result; +} + +void TEStED::PLC(double mass) +{ + LoadC =1+unsigned char( massCVP ) ) + BrakeStatus =( BrakeStatus && 252 ) //luzowanie;else if( ( VVP+BCP*1.0/BVM>CVP ) ) + BrakeStatus =( BrakeStatus && 253 ) //zatrzymanie napelaniania;else + ;else + if( ( VVP+0.100.25 ) ) //zatrzymanie luzowanie + BrakeStatus =( BrakeStatus || 1 ); +} + +double TCV1::CVs(double BP) +{ double result; +//przeplyw ZS <-> PG + if( ( BP>0.05 ) ) + CVs =0;else + CVs =0.23;return result; +} + +double TCV1::BVs(double BCP) +{ double result; double VVP; double BVP; double CVP; + + BVP =BrakeRes.P; + CVP =CntrlRes.P; + VVP =ValveRes.P; + +//przeplyw ZP <-> rozdzielacz + if( ( BVP0.05 ) ) + BVs =0;else + BVs =0.2*( 1.5-unsigned char( BVP>VVP ) ); +return result; +} + +double TCV1::GetPF(double PP, double dt, double Vel) +{ double result; double dv; double dV1; double temp; + double VVP; double BVP; double BCP; double CVP; + + BVP =BrakeRes.P; + VVP =Min0R( ValveRes.P, BVP+0.05 ); + BCP =BrakeCyl.P; + CVP =CntrlRes.P-0.0; + + dv =0; dV1 =0; + +//sprawdzanie stanu + CheckState( BCP , dV1 ); + + VVP =ValveRes.P; +//przeplyw ZS <-> PG + temp =CVs( BCP ); + dv =PF( CVP, VVP, 0.0015*temp )*dt; + CntrlRes.Flow( +dv ); + ValveRes.Flow( -0.04*dv ); + dV1 =dV1-0.96*dv; + + +//luzowanie + if( ( BrakeStatus && b_hld )==b_off ) + dv =PF( 0, BCP, 0.0042*( 1.37-unsigned char( BrakeDelayFlag==bdelay_G ) )*SizeBC )*dt;else dv =0; + BrakeCyl.Flow( -dv ); + +//przeplyw ZP <-> silowniki + if( ( BrakeStatus && b_on )==b_on ) + dv =PF( BVP, BCP, 0.017*( 1+unsigned char( ( BCP<0.58 )&&( BrakeDelayFlag==bdelay_G ) ) )*( 1.13-unsigned char( ( BCP>0.6 )&&( BrakeDelayFlag==bdelay_G ) ) )*SizeBC )*dt;else dv =0; + BrakeRes.Flow( dv ); + BrakeCyl.Flow( -dv ); + +//przeplyw ZP <-> rozdzielacz + temp =BVs( BCP ); + if( ( VVP+0.05>BVP ) ) + dv =PF( BVP, VVP, 0.02*SizeBR*temp*1.0/1.87 )*dt;else dv =0; + BrakeRes.Flow( dv ); + dV1 =dV1+dv*0.96; + ValveRes.Flow( -0.04*dv ); +//przeplyw PG <-> rozdzielacz + dv =PF( PP, VVP, 0.01 )*dt; + ValveRes.Flow( -dv ); + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; + GetPF =dv-dV1; +return result; +} + +void TCV1::Init(double PP, double HPP, double LPP, double BP, unsigned char BDF) +{ + ValveRes.CreatePress( PP ); + BrakeCyl.CreatePress( BP ); + BrakeRes.CreatePress( PP ); + CntrlRes =TReservoir.Create; + CntrlRes.CreateCap( 15 ); + CntrlRes.CreatePress( HPP ); + BrakeStatus =0; + + BVM =1*1.0/( HPP-LPP )*MaxBP; + + BrakeDelayFlag =BDF; +} + +double TCV1::GetCRP() +{ double result; + GetCRP =CntrlRes.P; +return result; +} + + +//---CV1-L-TR--- + +void TCV1L_TR::SetLBP(double P) +{ + LBP =P; +} + +double TCV1L_TR::GetHPFlow(double HP, double dt) +{ double result; double dv; + + dv =PF( HP, BrakeRes.P, 0.01 )*dt; + dv =Min0R( 0, dv ); + BrakeRes.Flow( -dv ); + GetHPFlow =dv; +return result; +} + +void TCV1L_TR::Init(double PP, double HPP, double LPP, double BP, unsigned char BDF) +{ + inherited::/*?*/PROC_NAME; + ImplsRes =TReservoir.Create; + ImplsRes.CreateCap( 2.5 ); + ImplsRes.CreatePress( BP ); +} + +double TCV1L_TR::GetPF(double PP, double dt, double Vel) +{ double result; double dv; double dV1; double temp; + double VVP; double BVP; double BCP; double CVP; + + BVP =BrakeRes.P; + VVP =Min0R( ValveRes.P, BVP+0.05 ); + BCP =ImplsRes.P; + CVP =CntrlRes.P-0.0; + + dv =0; dV1 =0; + +//sprawdzanie stanu + CheckState( BCP , dV1 ); + + VVP =ValveRes.P; +//przeplyw ZS <-> PG + temp =CVs( BCP ); + dv =PF( CVP, VVP, 0.0015*temp )*dt; + CntrlRes.Flow( +dv ); + ValveRes.Flow( -0.04*dv ); + dV1 =dV1-0.96*dv; + + +//luzowanie KI + if( ( BrakeStatus && b_hld )==b_off ) + dv =PF( 0, BCP, 0.000425*( 1.37-unsigned char( BrakeDelayFlag==bdelay_G ) ) )*dt;else dv =0; + ImplsRes.Flow( -dv ); +//przeplyw ZP <-> KI + if( ( ( BrakeStatus && b_on )==b_on ) && ( BCP0.6 )&&( BrakeDelayFlag==bdelay_G ) ) ) )*dt;else dv =0; + BrakeRes.Flow( dv ); + ImplsRes.Flow( -dv ); + +//przeplyw ZP <-> rozdzielacz + temp =BVs( BCP ); + if( ( VVP+0.05>BVP ) ) + dv =PF( BVP, VVP, 0.02*SizeBR*temp*1.0/1.87 )*dt;else dv =0; + BrakeRes.Flow( dv ); + dV1 =dV1+dv*0.96; + ValveRes.Flow( -0.04*dv ); +//przeplyw PG <-> rozdzielacz + dv =PF( PP, VVP, 0.01 )*dt; + GetPF =dv-dV1; + + temp =Max0R( BCP, LBP ); + +//luzowanie CH + if( ( BrakeCyl.P>temp+0.005 )||( Max0R( ImplsRes.P, 8*LBP )<0.25 ) ) + dv =PF( 0, BrakeCyl.P, 0.015*SizeBC )*dt;else dv =0; + BrakeCyl.Flow( -dv ); + +//przeplyw ZP <-> CH + if( ( BrakeCyl.P0.3 )&&( Max0R( BCP, LBP )CVP ) ) + BrakeStatus =( BrakeStatus && 252 ) //luzowanie;else if( ( VVP+BCP*1.0/BVM>CVP ) ) + BrakeStatus =( BrakeStatus && 253 ) //zatrzymanie napelaniania;else + ;else + if( ( VVP+0.100.25 ) ) //zatrzymanie luzowanie + BrakeStatus =( BrakeStatus || 1 ); +} + +double TKE::CVs(double BP) +{ double result; double VVP; double BVP; double CVP; + + BVP =BrakeRes.P; + CVP =CntrlRes.P; + VVP =ValveRes.P; + +//przeplyw ZS <-> PG + if( ( BP>0.2 ) ) + CVs =0;else + if( ( VVP>CVP+0.4 ) ) + CVs =0.05;else + CVs =0.23;return result; +} + +double TKE::BVs(double BCP) +{ double result; double VVP; double BVP; double CVP; + + BVP =BrakeRes.P; + CVP =CntrlRes.P; + VVP =ValveRes.P; + +//przeplyw ZP <-> rozdzielacz + if( ( BVP>VVP ) ) + BVs =0;else + if( ( BVP PG + temp =CVs( IMP ); + dv =PF( CVP, VVP, 0.0015*temp )*dt; + CntrlRes.Flow( +dv ); + ValveRes.Flow( -0.04*dv ); + dV1 =dV1-0.96*dv; + +//luzowanie + if( ( BrakeStatus && b_hld )==b_off ) + { + if( ( ( BrakeDelayFlag && bdelay_G )==0 ) ) + temp =0.283+0.139;else + temp =0.139; + dv =PF( 0, IMP, 0.001*temp )*dt;} + else dv =0; + ImplsRes.Flow( -dv ); + +//przeplyw ZP <-> silowniki + if( ( ( BrakeStatus && b_on )==b_on )&&( IMP50 )&&( RapidStatus ) )||( Vel>70 ) );else //jesli tarczowki, to zostan + RapidStatus =( ( BrakeDelayFlag && bdelay_R )==bdelay_R ); + +// temp:=1.9-0.9*Byte(RapidStatus); + + if( ( RM*RM>0.1 ) ) //jesli jest rapid + if( ( RM>0 ) ) //jesli dodatni (naddatek); + temp =1-RM*unsigned char( RapidStatus );else + temp =1-RM*( 1-unsigned char( RapidStatus ) );else + temp =1; + temp =temp*1.0/LoadC; +//luzowanie CH +// temp:=Max0R(BCP,LBP); + IMP =Max0R( IMP*1.0/temp, Max0R( LBP, ASBP*unsigned char( ( BrakeStatus && b_asb )==b_asb ) ) ); + +//luzowanie CH + if( ( BCP>IMP+0.005 )||( Max0R( ImplsRes.P, 8*LBP )<0.25 ) ) + dv =PFVd( BCP, 0, 0.05, IMP )*dt;else dv =0; + BrakeCyl.Flow( -dv ); + if( ( BCP0.3 ) ) + dv =PFVa( BVP, BCP, 0.05, IMP )*dt;else dv =0; + BrakeRes.Flow( -dv ); + BrakeCyl.Flow( +dv ); + +//przeplyw ZP <-> rozdzielacz + temp =BVs( IMP ); +// if(BrakeStatus and b_hld)=b_off then + if( ( IMP<0.25 )||( VVP+0.05>BVP ) ) + dv =PF( BVP, VVP, 0.02*SizeBR*temp*1.0/1.87 )*dt;else dv =0; + BrakeRes.Flow( dv ); + dV1 =dV1+dv*0.96; + ValveRes.Flow( -0.04*dv ); +//przeplyw PG <-> rozdzielacz + dv =PF( PP, VVP, 0.01 )*dt; + ValveRes.Flow( -dv ); + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; + ImplsRes.Act; + GetPF =dv-dV1; +return result; +} + +void TKE::Init(double PP, double HPP, double LPP, double BP, unsigned char BDF) +{ + ValveRes.CreatePress( PP ); + BrakeCyl.CreatePress( BP ); + BrakeRes.CreatePress( PP ); + + CntrlRes =TReservoir.Create; //komora sterujaca + CntrlRes.CreateCap( 5 ); + CntrlRes.CreatePress( HPP ); + + ImplsRes =TReservoir.Create; //komora zastepcza silownika + ImplsRes.CreateCap( 1 ); + ImplsRes.CreatePress( BP ); + + BrakeStatus =0; + + BVM =1*1.0/( HPP-LPP )*MaxBP; + + BrakeDelayFlag =BDF; +} + +double TKE::GetCRP() +{ double result; + GetCRP =CntrlRes.P; +return result; +} + +double TKE::GetHPFlow(double HP, double dt) +{ double result; double dv; + + dv =PF( HP, BrakeRes.P, 0.01 )*dt; + dv =Min0R( 0, dv ); + BrakeRes.Flow( -dv ); + GetHPFlow =dv; +return result; +} + +void TKE::PLC(double mass) +{ + LoadC =1+unsigned char( massRP+0.05 ) ) + dpMainValve =PF( Min0R( CP+0.1, HP ), PP, 1.1*( ActFlowSpeed )*1.0/( LBDelay ) )*dt; + if( ( CP0.1 ) ) + { + CP =5+( TP-0.1 )*0.08; + TP =TP-dt*1.0/12*1.0/2; + } + if( ( CP>RP+0.1 )&&( CP<=5 ) ) + dpMainValve =PF( Min0R( CP+0.25, HP ), PP, 2*( ActFlowSpeed )*1.0/( LBDelay ) )*dt;else + if( CP>5 ) + dpMainValve =PF( Min0R( CP, HP ), PP, 2*( ActFlowSpeed )*1.0/( LBDelay ) )*dt;else + dpMainValve =PF( dpPipe, PP, ( ActFlowSpeed )*1.0/( LBDelay ) )*dt;} + + if( ( Round( i_bcp )==i_bcpno ) ) + { + dpMainValve =PF( 0, PP, ( ActFlowSpeed )*1.0/( LBDelay ) )*dt; + } + + GetPF =dpMainValve; +return result; +} + +void TFV4a::Init(double Press) +{ + CP = Press; + TP = 0; + RP = Press; + Time = false; + TimeEP =false; +} + + +//---FV4a/M--- nowonapisany kran bez poprawki IC + +double TFV4aM::GetPF(double i_bcp, double PP, double HP, double dt, double ep) +{ double result;/*?*//*SUB-FUNCTION TO BE EXTRACTED*/double LPP_RP(double pos) //cisnienie z zaokraglonej pozycji; +{ double result; int i_pos; + + i_pos =Round( pos-0.5 ); //zaokraglone w dol + LPP_RP =BPT[ i_pos ][ 1 ]+( BPT[ i_pos+1 ][ 1 ]-BPT[ i_pos ][ 1 ] )*( pos-i_pos ); //interpolacja liniowa +return result; +} +/*?*//*SUB-FUNCTION TO BE EXTRACTED*/bool EQ(double pos, double i_pos) +{ bool result; + EQ =( pos<=i_pos+0.5 )&&( pos>i_pos-0.5 ); +return result; +} + + static double/*?*/ const LBDelay = 100; + static double/*?*/ const xpM = 0.3; //mnoznik membrany komory pod + + double LimPP; double dpPipe; double dpMainValve; double ActFlowSpeed; double DP; + double pom; + unsigned char i; + + ep =PP*1.0/2*1.5+ep*1.0/2*0.5; //SPKS!! +// ep:=pp; +// ep:=cp/3+pp/3+ep/3; +// ep:=cp; + + { long i_end = 5 ; for( i = 0 ; i < i_end ; ++i ) + Sounds[ i ] =0;} + DP =0; + + i_bcp =Max0R( Min0R( i_bcp, 5.999 ), -1.999 ); //na wszelki wypadek, zeby nie wyszlo poza zakres + + if( ( TP>0 ) ) + { //jesli czasowy jest niepusty +// dp:=0.07; //od cisnienia 5 do 0 w 60 sekund ((5-0)*dt/75) + DP =0.045; //2.5 w 55 sekund (5,35->5,15 w PG) + TP =TP-DP*dt; + Sounds[ s_fv4a_t ] =DP; + } + else //.08 + { + TP =0; + } + + if( ( XP>0 ) ) //jesli komora pod niepusta jest niepusty + { + DP =2.5; + Sounds[ s_fv4a_x ] =DP*XP; + XP =XP-dt*DP*2; //od cisnienia 5 do 0 w 10 sekund ((5-0)*dt/10) + } + else //.75 + XP =0; //jak pusty, to pusty + + LimPP =Min0R( LPP_RP( i_bcp )+TP*0.08+RedAdj, HP ); //pozycja + czasowy lub zasilanie + ActFlowSpeed =BPT[ Round( i_bcp ) ][ 0 ]; + + if( ( EQ( i_bcp, -1 ) ) ) pom =Min0R( HP, 5.4+RedAdj );else pom =Min0R( CP, HP ); + + if( ( pom>RP+0.25 ) ) Fala =true; + if( ( Fala ) ) + if( ( pom>RP+0.3 ) ) +// if(ep>rp+0.11)then + XP =XP-20*PR( pom, XP )*dt +// else +// xp:=xp-16*(ep-(ep+0.01))/(0.1)*PR(ep,xp)*dt;else Fala =false; + + if( ( LimPP>CP ) ) //podwyzszanie szybkie + CP =CP+5*60*Min0R( abs( LimPP-CP ), 0.05 )*PR( CP, LimPP )*dt //zbiornik sterujacy;else + CP =CP+13*Min0R( abs( LimPP-CP ), 0.05 )*PR( CP, LimPP )*dt; //zbiornik sterujacy + + LimPP =pom; //cp + dpPipe =Min0R( HP, LimPP+XP*xpM ); + + if( dpPipe>PP ) + dpMainValve =-PFVa( HP, PP, ActFlowSpeed*1.0/( LBDelay ), dpPipe, 0.4 );else + dpMainValve =PFVd( PP, 0, ActFlowSpeed*1.0/( LBDelay ), dpPipe, 0.4 ); + + if( EQ( i_bcp, -1 ) ) + { + if( ( TP<5 ) ) TP =TP+dt; //5/10 + if( ( TP<1 ) ) TP =TP-0.5*dt; //5/10 +// dpMainValve:=dpMainValve*2;//+1*PF(dpPipe,pp,(ActFlowSpeed)/(LBDelay))//coby nie przeszkadzal przy ladowaniu z zaworu obok + } + + if( EQ( i_bcp, 0 ) ) + { + if( ( TP>2 ) ) + dpMainValve =dpMainValve*1.5;//+0.5*PF(dpPipe,pp,(ActFlowSpeed)/(LBDelay))//coby nie przeszkadzal przy ladowaniu z zaworu obok + } + + + + + + ep =dpPipe; + if( ( EQ( i_bcp, 0 )||( RP>ep ) ) ) + RP =RP+PF( RP, ep, 0.0007 )*dt //powolne wzrastanie, ale szybsze na jezdzie;else + RP =RP+PF( RP, ep, 0.000093*1.0/2*2 )*dt; //powolne wzrastanie i to bardzo //jednak trzeba wydluzyc, bo obecnie zle dziala + if( ( RP0 ) + Sounds[ s_fv4a_b ] =dpMainValve;else + Sounds[ s_fv4a_u ] =-dpMainValve; + } + + GetPF =dpMainValve*dt; +return result; +} + +void TFV4aM::Init(double Press) +{ + CP = Press; + TP = 0; + RP = Press; + XP = 0; + Time =false; + TimeEP =false; +} + +void TFV4aM::SetReductor(double nAdj) +{ + RedAdj = nAdj; +} + +double TFV4aM::GetSound(unsigned char i) +{ double result; + if( i>4 ) + GetSound =0;else + GetSound =Sounds[ i ]; +return result; +} + +double TFV4aM::GetPos(unsigned char i) +{ double result; + static double const table[11] = ( -2, 6, -1, 0, -2, 1, 4, 6, 0, 0, 0 ); + + GetPos =table[ i ]; +return result; +} + +//---FV4a/M--- nowonapisany kran bez poprawki IC + +double TMHZ_EN57::GetPF(double i_bcp, double PP, double HP, double dt, double ep) +{ double result;/*?*//*SUB-FUNCTION TO BE EXTRACTED*/double LPP_RP(double pos) //cisnienie z zaokraglonej pozycji; +{ double result; + if( pos>8.5 ) + LPP_RP =5.0-0.15*pos-0.35;else if( pos>0.5 ) + LPP_RP =5.0-0.15*pos-0.1;else + LPP_RP =5.0;return result; +} +/*?*//*SUB-FUNCTION TO BE EXTRACTED*/bool EQ(double pos, double i_pos) +{ bool result; + EQ =( pos<=i_pos+0.5 )&&( pos>i_pos-0.5 ); +return result; +} + + static double/*?*/ const LBDelay = 100; + + double LimPP; double dpPipe; double dpMainValve; double ActFlowSpeed; double DP; + double pom; + unsigned char i; + + + { long i_end = 5 ; for( i = 0 ; i < i_end ; ++i ) + Sounds[ i ] =0;} + DP =0; + + i_bcp =Max0R( Min0R( i_bcp, 9.999 ), -0.999 ); //na wszelki wypadek, zeby nie wyszlo poza zakres + + if( ( TP>0 ) ) + { + DP =0.045; + if( EQ( i_bcp, 0 ) ) + TP =TP-DP*dt; + Sounds[ s_fv4a_t ] =DP; + } + else + { + TP =0; + } + + LimPP =Min0R( LPP_RP( i_bcp )+TP*0.08+RedAdj, HP ); //pozycja + czasowy lub zasilanie + ActFlowSpeed =4; + + if( ( EQ( i_bcp, -1 ) ) ) pom =Min0R( HP, 5.4+RedAdj );else pom =Min0R( CP, HP ); + + if( ( LimPP>CP ) ) //podwyzszanie szybkie + CP =CP+60*Min0R( abs( LimPP-CP ), 0.05 )*PR( CP, LimPP )*dt //zbiornik sterujacy;else + CP =CP+13*Min0R( abs( LimPP-CP ), 0.05 )*PR( CP, LimPP )*dt; //zbiornik sterujacy + + LimPP =pom; //cp + if( EQ( i_bcp, -1 ) ) + dpPipe =HP;else + dpPipe =Min0R( HP, LimPP ); + + if( dpPipe>PP ) + dpMainValve =-PFVa( HP, PP, ActFlowSpeed*1.0/( LBDelay ), dpPipe, 0.4 );else + dpMainValve =PFVd( PP, 0, ActFlowSpeed*1.0/( LBDelay ), dpPipe, 0.4 ); + + if( EQ( i_bcp, -1 ) ) + { + if( ( TP<5 ) ) TP =TP+dt; //5/10 + if( ( TP<1 ) ) TP =TP-0.5*dt; //5/10 + } + + if( ( EQ( i_bcp, 10 ) )||( EQ( i_bcp, -2 ) ) ) + { + DP =PF( 0, PP, 2*( ActFlowSpeed )*1.0/( LBDelay ) ); + dpMainValve =DP; + Sounds[ s_fv4a_e ] =DP; + Sounds[ s_fv4a_u ] =0; + Sounds[ s_fv4a_b ] =0; + Sounds[ s_fv4a_x ] =0; + } + else + { + if( dpMainValve>0 ) + Sounds[ s_fv4a_b ] =dpMainValve;else + Sounds[ s_fv4a_u ] =-dpMainValve; + } + + if( ( i_bcp<1.5 ) ) + RP =Max0R( 0, 0.125*i_bcp );else + RP =Min0R( 1, 0.125*i_bcp-0.125 ); + + GetPF =dpMainValve*dt; +return result; +} + +void TMHZ_EN57::Init(double Press) +{ + CP = Press; + TP = 0; + RP = 0; + Time =false; + TimeEP =false; +} + +void TMHZ_EN57::SetReductor(double nAdj) +{ + RedAdj = nAdj; +} + +double TMHZ_EN57::GetSound(unsigned char i) +{ double result; + if( i>4 ) + GetSound =0;else + GetSound =Sounds[ i ]; +return result; +} + +double TMHZ_EN57::GetPos(unsigned char i) +{ double result; + static double const table[11] = ( -2, 10, -1, 0, 0, 2, 9, 10, 0, 0, 0 ); + + GetPos =table[ i ]; +return result; +} + +double TMHZ_EN57::GetCP() +{ double result; + GetCP =RP; +return result; +} + +double TMHZ_EN57::GetEP(double pos) +{ double result; + if( pos<9.5 ) + GetEP =Min0R( Max0R( 0, 0.125*pos ), 1 );else + GetEP =0; +return result; +} + +//---M394--- Matrosow + +double TM394::GetPF(double i_bcp, double PP, double HP, double dt, double ep) +{ double result; + static double/*?*/ const LBDelay = 65; + + double LimPP; double dpPipe; double dpMainValve; double ActFlowSpeed; + int BCP; + + BCP =Round( i_bcp ); + if( BCP<-1 ) BCP =1; + + LimPP =Min0R( BPT_394[ BCP ][ 1 ], HP ); + ActFlowSpeed =BPT_394[ BCP ][ 0 ]; + if( ( BCP==1 )||( BCP==i_bcpno ) ) + LimPP =PP; + if( ( BCP==0 ) ) + LimPP =LimPP+RedAdj; + if( ( BCP!=2 ) ) + if( CP4 ) )*Min0R( abs( LimPP-CP ), 0.05 )*PR( CP, LimPP )*dt; //zbiornik sterujacy + + LimPP =CP; + dpPipe =Min0R( HP, LimPP ); + +// if(dpPipe>pp)then //napelnianie +// dpMainValve:=PF(dpPipe,pp,ActFlowSpeed/(LBDelay))*dt +// else //spuszczanie + dpMainValve =PF( dpPipe, PP, ActFlowSpeed*1.0/( LBDelay ) )*dt; + + if( BCP==-1 ) +// begin + dpMainValve =PF( HP, PP, ( ActFlowSpeed )*1.0/( LBDelay ) )*dt; +// end; + + if( BCP==i_bcpno ) +// begin + dpMainValve =PF( 0, PP, ( ActFlowSpeed )*1.0/( LBDelay ) )*dt; +// end; + + GetPF =dpMainValve; +return result; +} + +void TM394::Init(double Press) +{ + CP = Press; + RedAdj = 0; + Time =true; + TimeEP =false; +} + +void TM394::SetReductor(double nAdj) +{ + RedAdj = nAdj; +} + +double TM394::GetCP() +{ double result; + GetCP = CP; +return result; +} + +double TM394::GetPos(unsigned char i) +{ double result; + static double const table[11] = ( -1, 5, -1, 0, 1, 2, 4, 5, 0, 0, 0 ); + + GetPos =table[ i ]; +return result; +} + +//---H14K1-- Knorr + +double TH14K1::GetPF(double i_bcp, double PP, double HP, double dt, double ep) +{ double result; + static double/*?*/ const LBDelay = 100; //szybkosc + zasilanie sterujacego + static double const BPT_K[ /*?*//*-1..4*/ (4)-(-1)+1 ][2] = ( ( 10 , 0 ) , ( 4 , 1 ) , ( 0 , 1 ) , ( 4 , 0 ) , ( 4 , -1 ) , ( 15 , -1 ) ); + static double/*?*/ const NomPress = 5.0; + + double LimPP; double dpPipe; double dpMainValve; double ActFlowSpeed; + int BCP; + + BCP =Round( i_bcp ); + if( i_bcp<-1 ) BCP =1; + LimPP =BPT_K[ BCP ][ 1 ]; + if( LimPP<0 ) + LimPP =0.5*PP;else if( LimPP>0 ) + LimPP =PP;else + LimPP =CP; + ActFlowSpeed =BPT_K[ BCP ][ 0 ]; + + CP =CP+6*Min0R( abs( LimPP-CP ), 0.05 )*PR( CP, LimPP )*dt; //zbiornik sterujacy + + dpMainValve =0; + + if( BCP==-1 ) + dpMainValve =PF( HP, PP, ( ActFlowSpeed )*1.0/( LBDelay ) )*dt; + if( ( BCP==0 ) ) + dpMainValve =-PFVa( HP, PP, ( ActFlowSpeed )*1.0/( LBDelay ), NomPress+RedAdj )*dt; + if( ( BCP>1 )&&( PP>CP ) ) + dpMainValve =PFVd( PP, 0, ( ActFlowSpeed )*1.0/( LBDelay ), CP )*dt; + if( BCP==i_bcpno ) + dpMainValve =PF( 0, PP, ( ActFlowSpeed )*1.0/( LBDelay ) )*dt; + + GetPF =dpMainValve; +return result; +} + +void TH14K1::Init(double Press) +{ + CP = Press; + RedAdj = 0; + Time =true; + TimeEP =true; +} + +void TH14K1::SetReductor(double nAdj) +{ + RedAdj = nAdj; +} + +double TH14K1::GetCP() +{ double result; + GetCP = CP; +return result; +} + +double TH14K1::GetPos(unsigned char i) +{ double result; + static double const table[11] = ( -1, 4, -1, 0, 1, 2, 3, 4, 0, 0, 0 ); + + GetPos =table[ i ]; +return result; +} + +//---St113-- Knorr EP + +double TSt113::GetPF(double i_bcp, double PP, double HP, double dt, double ep) +{ double result; + static double/*?*/ const LBDelay = 100; //szybkosc + zasilanie sterujacego + static double const BPT_K[ /*?*//*-1..4*/ (4)-(-1)+1 ][2] = ( ( 10 , 0 ) , ( 4 , 1 ) , ( 0 , 1 ) , ( 4 , 0 ) , ( 4 , -1 ) , ( 15 , -1 ) ); + static double const BEP_K[ /*?*//*-1..5*/ (5)-(-1)+1 ] = ( 0 , -1 , 1 , 0 , 0 , 0 , 0 ); + static double/*?*/ const NomPress = 5.0; + + double LimPP; double dpPipe; double dpMainValve; double ActFlowSpeed; + int BCP; + + BCP =Round( i_bcp ); + + EPS =BEP_K[ BCP ]; + + if( BCP>0 ) BCP =BCP-1; + + if( BCP<-1 ) BCP =1; + LimPP =BPT_K[ BCP ][ 1 ]; + if( LimPP<0 ) + LimPP =0.5*PP;else if( LimPP>0 ) + LimPP =PP;else + LimPP =CP; + ActFlowSpeed =BPT_K[ BCP ][ 0 ]; + + CP =CP+6*Min0R( abs( LimPP-CP ), 0.05 )*PR( CP, LimPP )*dt; //zbiornik sterujacy + + dpMainValve =0; + + if( BCP==-1 ) + dpMainValve =PF( HP, PP, ( ActFlowSpeed )*1.0/( LBDelay ) )*dt; + if( ( BCP==0 ) ) + dpMainValve =-PFVa( HP, PP, ( ActFlowSpeed )*1.0/( LBDelay ), NomPress+RedAdj )*dt; + if( ( BCP>1 )&&( PP>CP ) ) + dpMainValve =PFVd( PP, 0, ( ActFlowSpeed )*1.0/( LBDelay ), CP )*dt; + if( BCP==i_bcpno ) + dpMainValve =PF( 0, PP, ( ActFlowSpeed )*1.0/( LBDelay ) )*dt; + + GetPF =dpMainValve; +return result; +} + +double TSt113::GetCP() +{ double result; + GetCP =EPS; +return result; +} + +double TSt113::GetPos(unsigned char i) +{ double result; + static double const table[11] = ( -1, 5, -1, 0, 2, 3, 4, 5, 0, 0, 1 ); + + GetPos =table[ i ]; +return result; +} + +void TSt113::Init(double Press) +{ + Time =true; + TimeEP =true; +} + +//--- test --- + +double Ttest::GetPF(double i_bcp, double PP, double HP, double dt, double ep) +{ double result; + static double/*?*/ const LBDelay = 100; + + double LimPP; double dpPipe; double dpMainValve; double ActFlowSpeed; + + + LimPP =BPT[ Round( i_bcp ) ][ 1 ]; + ActFlowSpeed =BPT[ Round( i_bcp ) ][ 0 ]; + + if( ( i_bcp==i_bcpno ) ) LimPP =0.0; + + if( ( i_bcp==-1 ) ) LimPP =7; + + CP =CP+20*Min0R( abs( LimPP-CP ), 0.05 )*PR( CP, LimPP )*dt*1.0/1; + + LimPP =CP; + dpPipe =Min0R( HP, LimPP ); + + dpMainValve =PF( dpPipe, PP, ActFlowSpeed*1.0/( LBDelay ) )*dt; + + if( ( Round( i_bcp )==i_bcpno ) ) + { + dpMainValve =PF( 0, PP, ( ActFlowSpeed )*1.0/( LBDelay ) )*dt; + } + + GetPF =dpMainValve; +return result; +} + +void Ttest::Init(double Press) +{ + CP = Press; +} + + +//---FD1--- + +double TFD1::GetPF(double i_bcp, double PP, double HP, double dt, double ep) +{ double result; double DP; double temp; + +// MaxBP:=4; +// temp:=Min0R(i_bcp*MaxBP,Min0R(5.0,HP)); + temp =Min0R( i_bcp*MaxBP, HP ); //0011 + DP =10*Min0R( abs( temp-BP ), 0.1 )*PF( temp, BP, 0.0006*( 2+unsigned char( temp>BP ) ) )*dt*Speed; + BP =BP-DP; + GetPF =-DP; +return result; +} + +void TFD1::Init(double Press) +{ + BP =0; + MaxBP =Press; + Time =false; + TimeEP =false; + Speed =1; +} + +double TFD1::GetCP() +{ double result; + GetCP =BP; +return result; +} + +void TFD1::SetSpeed(double nSpeed) +{ + Speed =nSpeed; +} + + +//---KNORR--- + +double TH1405::GetPF(double i_bcp, double PP, double HP, double dt, double ep) +{ double result; double DP; double temp; double A; + + PP =Min0R( PP, MaxBP ); + if( i_bcp>0.5 ) + { + temp =Min0R( MaxBP, HP ); + A =2*( i_bcp-0.5 )*0.0011; + BP =Max0R( BP, PP ); + } + else + { + temp =0; + A =0.2*( 0.5-i_bcp )*0.0033; + BP =Min0R( BP, PP ); + } + DP =PF( temp, BP, A )*dt; + BP =BP-DP; + GetPF =-DP; +return result; +} + +void TH1405::Init(double Press) +{ + BP =0; + MaxBP =Press; + Time =true; + TimeEP =false; +} + +double TH1405::GetCP() +{ double result; + GetCP =BP; +return result; +} + + +//---FVel6--- + +double TFVel6::GetPF(double i_bcp, double PP, double HP, double dt, double ep) +{ double result; + static double/*?*/ const LBDelay = 100; + + double LimPP; double dpPipe; double dpMainValve; double ActFlowSpeed; + + LimPP =Min0R( 5*unsigned char( i_bcp<3.5 ), HP ); + if( ( i_bcp>=3.5 ) && ( ( i_bcp<4.3 )||( i_bcp>5.5 ) ) ) + ActFlowSpeed =0;else if( ( i_bcp>4.3 ) && ( i_bcp<4.8 ) ) + ActFlowSpeed =4*( i_bcp-4.3 ) //konsultacje wawa1 - bylo 8;else if( ( i_bcp<4 ) ) + ActFlowSpeed =2;else + ActFlowSpeed =4; + dpMainValve =PF( LimPP, PP, ActFlowSpeed*1.0/( LBDelay ) )*dt; + + + Sounds[ s_fv4a_e ] =0; + Sounds[ s_fv4a_u ] =0; + Sounds[ s_fv4a_b ] =0; + if( ( i_bcp<3.5 ) ) Sounds[ s_fv4a_u ] =-dpMainValve;else + if( ( i_bcp<4.8 ) ) Sounds[ s_fv4a_b ] =dpMainValve;else + if( ( i_bcp<5.5 ) ) Sounds[ s_fv4a_e ] =dpMainValve; + + GetPF =dpMainValve; + if( ( i_bcp<-0.5 ) ) + EPS =-1;else if( ( i_bcp>0.5 )&&( i_bcp<4.7 ) ) + EPS =1;else + EPS =0; +// EPS:=i_bcp*Byte(i_bcp<2) +return result; +} + +double TFVel6::GetCP() +{ double result; + GetCP =EPS; +return result; +} + +double TFVel6::GetPos(unsigned char i) +{ double result; + static double const table[11] = ( -1, 6, -1, 0, 6, 4, 4.7, 5, -1, 0, 1 ); + + GetPos =table[ i ]; +return result; +} + +double TFVel6::GetSound(unsigned char i) +{ double result; + if( i>2 ) + GetSound =0;else + GetSound =Sounds[ i ]; +return result; +} + +void TFVel6::Init(double Press) +{ + Time =true; + TimeEP =true; +} + + + +//END diff --git a/McZapkie/hamulce.h b/McZapkie/hamulce.h new file mode 100644 index 00000000..f15f9d81 --- /dev/null +++ b/McZapkie/hamulce.h @@ -0,0 +1,714 @@ +#pragma once +#ifndef INCLUDED_HAMULCE_H +#define INCLUDED_HAMULCE_H + /*fizyka hamulcow dla symulatora*/ + +/* +This Source Code Form is subject to the +terms of the Mozilla Public License, v. +2.0. If a copy of the MPL was not +distributed with this file, You can +obtain one at +http://mozilla.org/MPL/2.0/. +*/ +/* + MaSzyna EU07 - SPKS + Brakes. + Copyright (C) 2007-2014 Maciej Cierniak +*/ + + +/* +(C) youBy +Co brakuje: +moze jeszcze jakis SW +*/ +/* +Zrobione: +ESt3, ESt3AL2, ESt4R, LSt, FV4a, FD1, EP2, prosty westinghouse +duzo wersji żeliwa +KE +Tarcze od 152A +Magnetyki (implementacja w mover.pas) +Matrosow 394 +H14K1 (zasadniczy), H1405 (pomocniczy), St113 (ep) +Knorr/West EP - żeby był +*/ + +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit + + + static int const LocalBrakePosNo = 10; /*ilosc nastaw hamulca recznego lub pomocniczego*/ + static int const MainBrakeMaxPos = 10; /*max. ilosc nastaw hamulca zasadniczego*/ + + /*nastawy hamulca*/ + static int const bdelay_G = 1; //G + static int const bdelay_P = 2; //P + static int const bdelay_R = 4; //R + static int const bdelay_M = 8; //Mg + static int const bdelay_GR = 128; //G-R + + + /*stan hamulca*/ + static int const b_off = 0; //luzowanie + static int const b_hld = 1; //trzymanie + static int const b_on = 2; //napelnianie + static int const b_rfl = 4; //uzupelnianie + static int const b_rls = 8; //odluzniacz + static int const b_ep = 16; //elektropneumatyczny + static int const b_asb = 32; //elektropneumatyczny + static int const b_dmg = 128; //wylaczony z dzialania + + /*uszkodzenia hamulca*/ + static int const df_on = 1; //napelnianie + static int const df_off = 2; //luzowanie + static int const df_br = 4; //wyplyw z ZP + static int const df_vv = 8; //wyplyw z komory wstepnej + static int const df_bc = 16; //wyplyw z silownika + static int const df_cv = 32; //wyplyw z ZS + static int const df_PP = 64; //zawsze niski stopien + static int const df_RR = 128; //zawsze wysoki stopien + + /*indeksy dzwiekow FV4a*/ + static int const s_fv4a_b = 0; //hamowanie + static int const s_fv4a_u = 1; //luzowanie + static int const s_fv4a_e = 2; //hamowanie nagle + static int const s_fv4a_x = 3; //wyplyw sterujacego fala + static int const s_fv4a_t = 4; //wyplyw z czasowego + + /*pary cierne*/ + static int const bp_P10 = 0; + static int const bp_P10Bg = 2; //żeliwo fosforowe P10 + static int const bp_P10Bgu = 1; + static int const bp_LLBg = 4; //komp. b.n.t. + static int const bp_LLBgu = 3; + static int const bp_LBg = 6; //komp. n.t. + static int const bp_LBgu = 5; + static int const bp_KBg = 8; //komp. w.t. + static int const bp_KBgu = 7; + static int const bp_D1 = 9; //tarcze + static int const bp_D2 = 10; + static int const bp_FR513 = 11; //Frenoplast FR513 + static int const bp_Cosid = 12; //jakistam kompozyt :D + static int const bp_PKPBg = 13; //żeliwo PKP + static int const bp_PKPBgu = 14; + static int const bp_MHS = 128; //magnetyczny hamulec szynowy + static int const bp_P10yBg = 15; //żeliwo fosforowe P10 + static int const bp_P10yBgu = 16; + static int const bp_FR510 = 17; //Frenoplast FR510 + + static int const sf_Acc = 1; //przyspieszacz + static int const sf_BR = 2; //przekladnia + static int const sf_CylB = 4; //cylinder - napelnianie + static int const sf_CylU = 8; //cylinder - oproznianie + static int const sf_rel = 16; //odluzniacz + static int const sf_ep = 32; //zawory ep + + static int const bh_MIN = 0; //minimalna pozycja + static int const bh_MAX = 1; //maksymalna pozycja + static int const bh_FS = 2; //napelnianie uderzeniowe //jesli nie ma, to jazda + static int const bh_RP = 3; //jazda + static int const bh_NP = 4; //odciecie - podwojna trakcja + static int const bh_MB = 5; //odciecie - utrzymanie stopnia hamowania/pierwszy 1 stopien hamowania + static int const bh_FB = 6; //pelne + static int const bh_EB = 7; //nagle + static int const bh_EPR = 8; //ep - luzowanie //pelny luz dla ep kątowego + static int const bh_EPN = 9; //ep - utrzymanie //jesli rowne luzowaniu, wtedy sterowanie przyciskiem + static int const bh_EPB = 10; //ep - hamowanie //pelne hamowanie dla ep kątowego + + + static double/*?*/ const SpgD = 0.7917; + static double/*?*/ const SpO = 0.5067; //przekroj przewodu 1" w l/m + //wyj: jednostka dosyc dziwna, ale wszystkie obliczenia + //i pojemnosci sa podane w litrach (rozsadne wielkosci) + //zas dlugosc pojazdow jest podana w metrach + //a predkosc przeplywu w m/s //3.5 + //7//1.5 +// BPT: array[-2..6] of array [0..1] of real= ((0, 5.0), (14, 5.4), (9, 5.0), (6, 4.6), (9, 4.5), (9, 4.0), (9, 3.5), (9, 2.8), (34, 2.8)); +// BPT: array[-2..6] of array [0..1] of real= ((0, 5.0), (7, 5.0), (2.0, 5.0), (4.5, 4.6), (4.5, 4.2), (4.5, 3.8), (4.5, 3.4), (4.5, 2.8), (8, 2.8)); + static double const BPT[ /*?*//*-2..6*/ (6)-(-2)+1 ][2] = ( ( 0 , 5.0 ) , ( 7 , 5.0 ) , ( 2.0 , 5.0 ) , ( 4.5 , 4.6 ) , ( 4.5 , 4.2 ) , ( 4.5 , 3.8 ) , ( 4.5 , 3.4 ) , ( 4.5 , 2.8 ) , ( 8 , 2.8 ) ); + static double const BPT_394[ /*?*//*-1..5*/ (5)-(-1)+1 ][2] = ( ( 13 , 10.0 ) , ( 5 , 5.0 ) , ( 0 , -1 ) , ( 5 , -1 ) , ( 5 , 0.0 ) , ( 5 , 0.0 ) , ( 18 , 0.0 ) ); +// BPT: array[-2..6] of array [0..1] of real= ((0, 5.0), (12, 5.4), (9, 5.0), (9, 4.6), (9, 4.2), (9, 3.8), (9, 3.4), (9, 2.8), (34, 2.8)); +// BPT: array[-2..6] of array [0..1] of real= ((0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, 0)); + static double/*?*/ const i_bcpno = 6; + + + //klasa obejmujaca pojedyncze zbiorniki + + +struct/*class*/ TReservoir: public TObject +{ +protected: + double Cap; + double Vol; + double dVol; + +public: + /*?*/static/*CONSTRUCTOR*/void Create(); + void CreateCap(double Capacity); + void CreatePress(double Press); + virtual double pa(); + virtual double P(); + void Flow(double dv); + void Act(); + +}; + + + typedef TReservoir *PReservoir; + + +struct/*class*/ TBrakeCyl: public TReservoir + +{ +public: + double pa()/*override*/; + double P()/*override*/; + +}; + + + //klasa obejmujaca uklad hamulca zespolonego pojazdu + + +struct/*class*/ TBrake: public TObject +{ +protected: + TReservoir BrakeCyl; //silownik + TReservoir BrakeRes; //ZP + TReservoir ValveRes; //komora wstepna + unsigned char BCN; //ilosc silownikow + double BCM; //przekladnia hamulcowa + double BCA; //laczny przekroj silownikow + unsigned char BrakeDelays; //dostepne opoznienia + unsigned char BrakeDelayFlag; //aktualna nastawa + TFricMat FM; //material cierny + double MaxBP; //najwyzsze cisnienie + unsigned char BA; //osie hamowane + unsigned char NBpA; //klocki na os + double SizeBR; //rozmiar^2 ZP (w stosunku do 14") + double SizeBC; //rozmiar^2 CH (w stosunku do 14") + bool DCV; //podwojny zawor zwrotny + double ASBP; //cisnienie hamulca pp + + unsigned char BrakeStatus; //flaga stanu + unsigned char SoundFlag; + +public: + /*?*/static/*CONSTRUCTOR*/void Create(double i_mbp, double i_bcr, double i_bcd, double i_brc, + unsigned char i_bcn, unsigned char i_BD, unsigned char i_mat, unsigned char i_ba, unsigned char i_nbpa); + //maksymalne cisnienie, promien, skok roboczy, pojemnosc ZP; + //ilosc cylindrow, opoznienia hamulca, material klockow, osie hamowane, klocki na os; + + virtual double GetFC(double Vel, double N); //wspolczynnik tarcia - hamulec wie lepiej + virtual double GetPF(double PP, double dt, double Vel); //przeplyw miedzy komora wstepna i PG + double GetBCF(); //sila tlokowa z tloka + virtual double GetHPFlow(double HP, double dt); //przeplyw - 8 bar + virtual double GetBCP(); //cisnienie cylindrow hamulcowych + double GetBRP(); //cisnienie zbiornika pomocniczego + double GetVRP(); //cisnienie komory wstepnej rozdzielacza + virtual double GetCRP(); //cisnienie zbiornika sterujacego + virtual void Init(double PP, double HPP, double LPP, double BP, unsigned char BDF); //inicjalizacja hamulca + bool SetBDF(unsigned char nBDF); //nastawiacz GPRM + void Releaser(unsigned char state); //odluzniacz + virtual void SetEPS(double nEPS); //hamulec EP + void ASB(unsigned char state); //hamulec przeciwposlizgowy + unsigned char GetStatus(); //flaga statusu, moze sie przydac do odglosow + void SetASBP(double Press); //ustalenie cisnienia pp + virtual void ForceEmptiness(); + unsigned char GetSoundFlag(); +// procedure + +}; + + + +struct/*class*/ TWest: public TBrake + +{ +private: + double LBP; //cisnienie hamulca pomocniczego + double dVP; //pobor powietrza wysokiego cisnienia + double EPS; //stan elektropneumatyka + double TareM; double LoadM; //masa proznego i pelnego + double TareBP; //cisnienie dla proznego + double LoadC; //wspolczynnik przystawki wazacej + +public: + void SetLBP(double P); //cisnienie z hamulca pomocniczego + double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG + void Init(double PP, double HPP, double LPP, double BP, unsigned char BDF)/*override*/; + double GetHPFlow(double HP, double dt)/*override*/; + void PLC(double mass); //wspolczynnik cisnienia przystawki wazacej + void SetEPS(double nEPS)/*override*/; //stan hamulca EP + void SetLP(double TM, double LM, double TBP); //parametry przystawki wazacej + +}; + + + +struct/*class*/ TESt: public TBrake + +{ +private: + TReservoir CntrlRes; //zbiornik sterujący + double BVM; //przelozenie PG-CH + +public: + double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG + void EStParams(double i_crc); //parametry charakterystyczne dla ESt + void Init(double PP, double HPP, double LPP, double BP, unsigned char BDF)/*override*/; + double GetCRP()/*override*/; + void CheckState(double BCP, double & dV1); //glowny przyrzad rozrzadczy + void CheckReleaser(double dt); //odluzniacz + double CVs(double BP); //napelniacz sterujacego + double BVs(double BCP); //napelniacz pomocniczego + +}; + + + +struct/*class*/ TESt3: public TESt + +{ +private: + double CylFlowSpeed[2][2]; + +public: + double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG + +}; + + + +struct/*class*/ TESt3AL2: public TESt3 + +{ +private: + double TareM; double LoadM; //masa proznego i pelnego + double TareBP; //cisnienie dla proznego + double LoadC; + +public: + TReservoir ImplsRes; //komora impulsowa + double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG + void PLC(double mass); //wspolczynnik cisnienia przystawki wazacej + void SetLP(double TM, double LM, double TBP); //parametry przystawki wazacej + void Init(double PP, double HPP, double LPP, double BP, unsigned char BDF)/*override*/; + +}; + + + +struct/*class*/ TESt4R: public TESt + +{ +private: + bool RapidStatus; + double RapidTemp; //akrualne, zmienne przelozenie + +public: + TReservoir ImplsRes; //komora impulsowa + double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG + void Init(double PP, double HPP, double LPP, double BP, unsigned char BDF)/*override*/; + +}; + + + +struct/*class*/ TLSt: public TESt4R + +{ +private: + double CylFlowSpeed[2][2]; + double LBP; //cisnienie hamulca pomocniczego + double RM; //przelozenie rapida + double EDFlag; //luzowanie hamulca z powodu zalaczonego ED + +public: + void SetLBP(double P); //cisnienie z hamulca pomocniczego + void SetRM(double RMR); //ustalenie przelozenia rapida + double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG + double GetHPFlow(double HP, double dt)/*override*/; //przeplyw - 8 bar + void Init(double PP, double HPP, double LPP, double BP, unsigned char BDF)/*override*/; + virtual double GetEDBCP(); //cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED w EP09 + void SetED(double EDstate); //stan hamulca ED do luzowania + +}; + + + +struct/*class*/ TEStED: public TLSt //zawor z EP09 - Est4 z oddzielnym przekladnikiem, kontrola rapidu i takie tam + +{ +private: + double Nozzles[11]; //dysze + bool Zamykajacy; //pamiec zaworka zamykajacego + bool Przys_blok; //blokada przyspieszacza + TReservoir Miedzypoj; //pojemnosc posrednia (urojona) do napelniania ZP i ZS + double TareM; double LoadM; //masa proznego i pelnego + double TareBP; //cisnienie dla proznego + double LoadC; + +public: + void Init(double PP, double HPP, double LPP, double BP, unsigned char BDF)/*override*/; + double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG + double GetEDBCP()/*override*/; //cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED + void PLC(double mass); //wspolczynnik cisnienia przystawki wazacej + void SetLP(double TM, double LM, double TBP); //parametry przystawki wazacej + +}; + + + +struct/*class*/ TEStEP2: public TLSt + +{ +private: + double TareM; double LoadM; //masa proznego i pelnego + double TareBP; //cisnienie dla proznego + double LoadC; + double EPS; + +public: + double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG + void Init(double PP, double HPP, double LPP, double BP, unsigned char BDF)/*override*/; //inicjalizacja + void PLC(double mass); //wspolczynnik cisnienia przystawki wazacej + void SetEPS(double nEPS)/*override*/; //stan hamulca EP + void SetLP(double TM, double LM, double TBP); //parametry przystawki wazacej + +}; + + + +struct/*class*/ TCV1: public TBrake + +{ +private: + TReservoir CntrlRes; //zbiornik sterujący + double BVM; //przelozenie PG-CH + +public: + double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG + void Init(double PP, double HPP, double LPP, double BP, unsigned char BDF)/*override*/; + double GetCRP()/*override*/; + void CheckState(double BCP, double & dV1); + double CVs(double BP); + double BVs(double BCP); + +public: + +}; + + + +struct/*class*/ TCV1R: public TCV1 + +{ +private: + TReservoir ImplsRes; //komora impulsowa + bool RapidStatus; + +public: +// function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG +// procedure Init(PP, HPP, LPP, BP: real; BDF: byte); override; + +}; + + + +struct/*class*/ TCV1L_TR: public TCV1 + +{ +private: + TReservoir ImplsRes; //komora impulsowa + double LBP; //cisnienie hamulca pomocniczego + +public: + double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG + void Init(double PP, double HPP, double LPP, double BP, unsigned char BDF)/*override*/; + void SetLBP(double P); //cisnienie z hamulca pomocniczego + double GetHPFlow(double HP, double dt)/*override*/; //przeplyw - 8 bar + +}; + + + +struct/*class*/ TKE: public TBrake //Knorr Einheitsbauart — jeden do wszystkiego + +{ +private: + bool RapidStatus; + TReservoir ImplsRes; //komora impulsowa + TReservoir CntrlRes; //zbiornik sterujący + TReservoir Brak2Res; //zbiornik pomocniczy 2 + double BVM; //przelozenie PG-CH + double TareM; double LoadM; //masa proznego i pelnego + double TareBP; //cisnienie dla proznego + double LoadC; //wspolczynnik zaladowania + double RM; //przelozenie rapida + double LBP; //cisnienie hamulca pomocniczego + +public: + void SetRM(double RMR); //ustalenie przelozenia rapida + double GetPF(double PP, double dt, double Vel)/*override*/; //przeplyw miedzy komora wstepna i PG + void Init(double PP, double HPP, double LPP, double BP, unsigned char BDF)/*override*/; + double GetHPFlow(double HP, double dt)/*override*/; //przeplyw - 8 bar + double GetCRP()/*override*/; + void CheckState(double BCP, double & dV1); + void CheckReleaser(double dt); //odluzniacz + double CVs(double BP); //napelniacz sterujacego + double BVs(double BCP); //napelniacz pomocniczego + void PLC(double mass); //wspolczynnik cisnienia przystawki wazacej + void SetLP(double TM, double LM, double TBP); //parametry przystawki wazacej + void SetLBP(double P); //cisnienie z hamulca pomocniczego + +}; + + + + + + //klasa obejmujaca krany + + +struct/*class*/ HANDLE: public TObject +{ +private: +// BCP: integer; + +public: + bool Time; + bool TimeEP; + double Sounds[5]; //wielkosci przeplywow dla dzwiekow + virtual double GetPF(double i_bcp, double PP, double HP, double dt, double ep); + virtual void Init(double Press); + virtual double GetCP(); + virtual void SetReductor(double nAdj); + virtual double GetSound(unsigned char i); + virtual double GetPos(unsigned char i); + +}; + + + +struct/*class*/ TFV4a: public HANDLE + +{ +private: + double CP; double TP; double RP; //zbiornik sterujący, czasowy, redukcyjny + +public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; + void Init(double Press)/*override*/; + +}; + + + +struct/*class*/ TFV4aM: public HANDLE + +{ +private: + double CP; double TP; double RP; //zbiornik sterujący, czasowy, redukcyjny + double XP; //komora powietrzna w reduktorze — jest potrzebna do odwzorowania fali + double RedAdj; //dostosowanie reduktora cisnienia (krecenie kapturkiem) +// Sounds: array[0..4] of real; //wielkosci przeplywow dla dzwiekow + bool Fala; + +public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; + void Init(double Press)/*override*/; + void SetReductor(double nAdj)/*override*/; + double GetSound(unsigned char i)/*override*/; + double GetPos(unsigned char i)/*override*/; + +}; + + + +struct/*class*/ TMHZ_EN57: public HANDLE + +{ +private: + double CP; double TP; double RP; //zbiornik sterujący, czasowy, redukcyjny + double RedAdj; //dostosowanie reduktora cisnienia (krecenie kapturkiem) + bool Fala; + +public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; + void Init(double Press)/*override*/; + void SetReductor(double nAdj)/*override*/; + double GetSound(unsigned char i)/*override*/; + double GetPos(unsigned char i)/*override*/; + double GetCP()/*override*/; + double GetEP(double pos); + +}; + + + +/* FBS2= class(THandle) + private + CP, TP, RP: real; //zbiornik sterujący, czasowy, redukcyjny + XP: real; //komora powietrzna w reduktorze — jest potrzebna do odwzorowania fali + RedAdj: real; //dostosowanie reduktora cisnienia (krecenie kapturkiem) +// Sounds: array[0..4] of real; //wielkosci przeplywow dla dzwiekow + Fala: boolean; + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + procedure Init(press: real); override; + procedure SetReductor(nAdj: real); override; + function GetSound(i: byte): real; override; + function GetPos(i: byte): real; override; + end; */ + +/* TD2= class(THandle) + private + CP, TP, RP: real; //zbiornik sterujący, czasowy, redukcyjny + XP: real; //komora powietrzna w reduktorze — jest potrzebna do odwzorowania fali + RedAdj: real; //dostosowanie reduktora cisnienia (krecenie kapturkiem) +// Sounds: array[0..4] of real; //wielkosci przeplywow dla dzwiekow + Fala: boolean; + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + procedure Init(press: real); override; + procedure SetReductor(nAdj: real); override; + function GetSound(i: byte): real; override; + function GetPos(i: byte): real; override; + end;*/ + + +struct/*class*/ TM394: public HANDLE + +{ +private: + double CP; //zbiornik sterujący, czasowy, redukcyjny + double RedAdj; //dostosowanie reduktora cisnienia (krecenie kapturkiem) + +public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; + void Init(double Press)/*override*/; + void SetReductor(double nAdj)/*override*/; + double GetCP()/*override*/; + double GetPos(unsigned char i)/*override*/; + +}; + + + +struct/*class*/ TH14K1: public HANDLE + +{ +private: + double CP; //zbiornik sterujący, czasowy, redukcyjny + double RedAdj; //dostosowanie reduktora cisnienia (krecenie kapturkiem) + +public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; + void Init(double Press)/*override*/; + void SetReductor(double nAdj)/*override*/; + double GetCP()/*override*/; + double GetPos(unsigned char i)/*override*/; + +}; + + + +struct/*class*/ TSt113: public TH14K1 + +{ +private: + double EPS; + +public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; + double GetCP()/*override*/; + double GetPos(unsigned char i)/*override*/; + void Init(double Press)/*override*/; + +}; + + + +struct/*class*/ Ttest: public HANDLE + +{ +private: + double CP; + +public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; + void Init(double Press)/*override*/; + +}; + + + +struct/*class*/ TFD1: public HANDLE + +{ +private: + double MaxBP; //najwyzsze cisnienie + double BP; //aktualne cisnienie + +public: + double Speed; //szybkosc dzialania + double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; + void Init(double Press)/*override*/; + double GetCP()/*override*/; + void SetSpeed(double nSpeed); +// procedure Init(press: real; MaxBP: real); overload; + +}; + + + +struct/*class*/ TH1405: public HANDLE + +{ +private: + double MaxBP; //najwyzsze cisnienie + double BP; //aktualne cisnienie + +public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; + void Init(double Press)/*override*/; + double GetCP()/*override*/; +// procedure Init(press: real; MaxBP: real); overload; + +}; + + + + +struct/*class*/ TFVel6: public HANDLE + +{ +private: + double EPS; + +public: + double GetPF(double i_bcp, double PP, double HP, double dt, double ep)/*override*/; + double GetCP()/*override*/; + double GetPos(unsigned char i)/*override*/; + double GetSound(unsigned char i)/*override*/; + void Init(double Press)/*override*/; + +}; + + +double PF(double P1, double P2, double S, double DP = 0.25); +double PF1(double P1, double P2, double S); + +double PFVa(double PH, double PL, double S, double LIM, double DP = 0.1); //zawor napelniajacy z PH do PL, PL do LIM +double PFVd(double PH, double PL, double S, double LIM, double DP = 0.1); //zawor wypuszczajacy z PH do PL, PH do LIM + + + +#endif//INCLUDED_HAMULCE_H +//END