extern string _TP = "Основные входные параметры"; //--- extern int Tick = 3; //тик в баре м1 после которого запрет работы эксперта . 0 - выключено bool Market = TRUE; extern int TakeProfit = 26; //--- (10 2 60) extern int StopLoss = 120; //--- (100 10 200) extern bool Margin = FALSE; //флаг учёта профита в долях маржи при разрешении входа extern double ProfitMargin =0; //профит в долях маржи при разрешении входа extern int DOP = 10; // условие включения доливки рыночным при просадке на пип DOP или при=0 выкл extern double KDOP =1; //множитель лота доливки рыночным ордером extern bool MarketOrder =TRUE; //флаг рыночного ордера extern bool MinimLot =FALSE; //флаг минимального рыночного начального (главного) ордера extern double LimitOrder = 10; //флаг - дистанция лимитного ордера . если = 0 - откл. extern double TimeL =11; //время экспирации лимитного ордера extern double KLimit =1; //множитель лота лимитного ордера extern bool DeleteLimit = TRUE; //флаг удаления лимитного ордера при стоплосе главного в безубытке extern double StopOrder = 7; //флаг - дистанция стопового ордера extern double TimeS =20; //время экспирации стопового ордера extern int DOPS = 20; //условие просадки шлавного рыночного ордера для открытия стопового в пип extern double KStop =1; //множитель лота стопового ордера extern bool ModifStop = TRUE; //флаг модификации стопового ордера при увеличении дистанции от цены ( сохранение дистанции при её увеличении) extern bool UseStopLevels = TRUE;//--- Включение стоповых ордеров. Если выключена, то работают только виртуальные тейки и лоссы. //--- //----------------------------------------------------------------------------------------------------------------------------------------------------------------- extern string ТРАЛ1 = "ДОЛЕВОЙ_ТРАЛ"; extern double Профит_срабатывания = 50; // профит включения трала в ПИПАХ СЧЁТА!!! extern double Трейлинг = 0; //трейлинг в доле от профита (напр 0.2 ) если = 0 то выкл. //----------------------------------------------------------------------------------------------------------------------------------------------------------------- extern int TIME = 300; extern int SecureProfit = 1; //--- (0 1 5) Вывод в безубыток extern int SecureProfitTriger = 7; //--- (10 2 30) extern int MaxLossPoints = -65; //--- (-200 5 -20) Максимальная просадка для закрытия ордеров Buy и Sell при изменении сигнала (При просадке равной от - MaxLossPoints или меньше (например прибыль 0), ордер закроется) extern string _MM = "Настройка MM"; //--- extern bool RecoveryMode = FALSE; //--- Включение режима восстановления депозита (увеличение лота если случился стоп-лосс) extern double FixedLot = 0.01; //--- Фиксированный объём лота extern double AutoMM = 10.0; //--- ММ включается если AutoMM > 0. Процент риска. При RecoveryMode = FALSE, менять нужно только это значение. //--- При AutoMM = 20 и депозите в 1000$, лот будет равен 0,2. Далее лот будет увеличиваться исходя из свободных средств, то есть уже при депозите в 2000$ лот будет равен 0,4. extern double AutoMM_Max = 20.0; //--- Максимальный риск extern int MaxAnalizCount = 50; //--- Число закрытых ранее ордеров для анализа(Используется при RecoveryMode = True) extern double Risk = 25.0; //--- Риск от депозита (Используется при RecoveryMode = True) extern double MultiLotPercent = 1.1; //--- Коэффициент умножение лота (Используется при RecoveryMode = True) //+--------------------------------------------------------------------------------------------------------------+ //| Периоды индикаторов. Кол-во баров для каждого индикатора. //+--------------------------------------------------------------------------------------------------------------+ extern string _Periods = "Периоды индикаторов"; //--- Периоды индикаторов (Тоже можно будет заоптить, так как для каждой пары свои) extern int iMA_Period = 75; //--- (60 5 100) extern int iCCI_Period = 18; //--- (10 2 30) extern int TFCCI = 15; extern int iATR_Period = 14; //--- (10 2 30) (!) Можно не оптить extern int iWPR_Period = 11; //--- (10 1 20) //+--------------------------------------------------------------------------------------------------------------+ //| Настройки из DLL //+--------------------------------------------------------------------------------------------------------------+ //| EURUSD | GBPUSD | USDCHF | USDJPY | USDCAD | //+---------------------------------------------------------------- //| TP=26; | TP=50; | TP=17; | TP=27; | TP=14; | //| SL=120; | SL=120; | SL=120; | SL=130; | SL=150; | //| SP=1; | SP=2; | SP=0; | SP=2; | SP=2; | //| SPT=10; | SPT=24; | SPT=15; | SPT=14; | SPT=10; | //| MLP=-65; | MLP=-200; | MLP=-40; | MLP=-80; | MLP=-30; | //+---------------------------------------------------------------- //| MA=75; | MA=75; | MA=70; | MA=85; | MA=65; | //| CCI=18; | CCI=12; | CCI=14; | CCI=12; | CCI=12; | //| ATR=14; | ATR=14; | ATR=14; | ATR=14; | ATR=14; | //| WPR=11; | WPR=12; | WPR=12; | WPR=12; | WPR=16; | //+---------------------------------------------------------------- //| FATR=6; | FATR=6; | FATR=3; | FATR=0; | FATR=4; | //| FCCI=150; | FCCI=290; | FCCI=170; | FCCI=2000; | FCCI=130; | //+---------------------------------------------------------------- //| MAFOA=15; | MAFOA=12; | MAFOA=8; | MAFOA=5; | MAFOA=5; | //| MAFOB=39; | MAFOB=33; | MAFOB=25; | MAFOB=21; | MAFOB=15; | //| WPRFOA=-99;| WPRFOA=-99;| WPRFOA=-95;| WPRFOA=-99;| WPRFOA=-99;| //| WPRFOB=-95;| WPRFOB=-94;| WPRFOB=-92;| WPRFOB=-95;| WPRFOB=-89;| //+---------------------------------------------------------------- //| MAFC=14; | MAFC=18; | MAFC=11; | MAFC=14; | MAFC=14; | //| WPRFC=-19; | WPRFC=-19; | WPRFC=-22; | WPRFC=-27; | WPRFC=-6; | //+--------------------------------------------------------------------------------------------------------------+ //+--------------------------------------------------------------------------------------------------------------+ //| Параметры оптимизации для правил открытия и закрытия позиции. //+--------------------------------------------------------------------------------------------------------------+ extern string _Add_Op = "Расширенные параметры оптимизации"; //--- extern string _AddOpenFilters = "---"; //--- extern int M=1,Z=1;// M - параметр линии стох Z - замедление extern int FilterATR = 6; //--- (0 1 10) Проверка на вход по ATR для Buy и Sell (if (iATR_Signal <= FilterATR * pp) return (0);) (!) Можно не оптить extern double iCCI_OpenFilter = 150; //--- (100 10 400) Фильтр по iCCI для Buy и Sell. При оптимизации под JPY рекомендуемо оптить по правилу (100 50 4000) //--- extern string _OpenOrderFilters = "---"; //--- extern int iMA_Filter_Open_a = 15; //--- (4 2 20) Фильтр МА для открытия Buy и Sell (Пунты) extern int iMA_Filter_Open_b = 39; //--- (14 2 50) Фильтр МА для открытия Buy и Sell (Пунты) extern int iWPR_Filter_Open_a = 1; //--- (-100 1 0) Фильтр WPR для открытия Buy и Sell extern int iWPR_Filter_Open_b = 5; //--- (-100 1 0) Фильтр WPR для открытия Buy и Sell //--- extern string _CloseOrderFilters = "---"; //--- extern int Price_Filter_Close = 14; //--- (10 2 20) Фильтр цены открытия для закрытия Buy и Sell (Пунты) extern int iWPR_Filter_Close = 97; //--- (0 1 -100) Фильтр WPR для закрытия Buy и Sell //+--------------------------------------------------------------------------------------------------------------+ //| Расширенные настройки //+--------------------------------------------------------------------------------------------------------------+ extern string _Add = "Расширенные настройки"; extern bool LongTrade = TRUE; //--- Выключатель длинных позиций extern bool ShortTrade = TRUE; //--- Выключатель коротких позиций extern int MagicNumber = 345; extern double MaxSpread = 2; extern double Slippage = 2; extern bool WriteLog = TRUE; //--- //--- Включение всплывающих окон в терминале. extern bool WriteDebugLog = TRUE; //--- Включение всплывающих окон об ошибках в терминале. extern bool PrintLogOnChart = TRUE; //--- Включение комментариев на графике (при тестировании выключается автоматически) //+--------------------------------------------------------------------------------------------------------------+ //| Блок дополнительных переменных //+--------------------------------------------------------------------------------------------------------------+ double K; double pp; int pd; double cf; string EASymbol; //--- Текущий символ double CloseSlippage = 3; //--- Проскальзывание для закрытия ордера int SP; int CloseSP; int MaximumTrades = 1; double NDMaxSpread; //--- Максимальный спред ввиде пунктов bool CheckSpreadRule; //--- Правило для проверки спреда перед открытием (Останавливает зацикливание сообщений о превышенном спреде) string OpenOrderComment = "WSFR"; int RandomOpenTimePercent = 0; //--- Используется при занятом потоке комманд терминала, своебразная рендомная пауза. Выражается в секундах. //--- //--- Параметры для автолота double MinLot = 0.01; double MaxLot = 0.01; double LotStep = 0.01; int LotValue = 100000; double FreeMargin = 1000.0; double LotPrice = 1; double LotSize; //--- Параметры на открытие int iWPR_Filter_OpenLong_a; int iWPR_Filter_OpenLong_b; int iWPR_Filter_OpenShort_a; int iWPR_Filter_OpenShort_b; //--- Параметры на закрытие int iWPR_Filter_CloseLong; int iWPR_Filter_CloseShort; //--- color OpenBuyColor = Blue; color OpenSellColor = Red; color CloseBuyColor = DodgerBlue; color CloseSellColor = DeepPink; //--- bool SoundAlert = FALSE; //--- Звуковое оповещение об открытии/закрытии сделки string SoundFileAtOpen = "alert.wav"; string SoundFileAtClose = "alert.wav"; int Dist = 1; //--- Дополнительный фильтр проверки цены после открытия ордера. bool OpenAddOrderRule = FALSE; //--- При включении данной торговли новые ордера не будут не будут открываться. Необходима если вы решили остановить торговлю, но не хотите чтобы советник терял открытые им ордера. //+--------------------------------------------------------------------------------------------------------------+ //| INIT. Инициализация некоторых переменных, удаление объектов на графике. //+--------------------------------------------------------------------------------------------------------------+ void init() { //+--------------------------------------------------------------------------------------------------------------+ //--- if (IsTesting() && !IsVisualMode()) PrintLogOnChart = FALSE; //--- Если тестируем, то отключаются комментарии на графике if (!PrintLogOnChart) Comment(""); //--- EASymbol = Symbol(); //--- Инициализация текущено символа //--- if (Digits < 4) { pp = 0.01; pd = 2; cf = 0.009; K=1; } else { pp = 0.0001; pd = 4; cf = 0.00009; K=10; } int k =10; if (Digits < 5)k=1; //--- SP = Slippage * MathPow(10, Digits - pd); //--- Расчет проскальзывания цены для пятизнака CloseSP = CloseSlippage * MathPow(10, Digits - pd); NDMaxSpread = NormalizeDouble(MaxSpread * pp, pd + 1); //--- Преобразование значения MaxSpread в пункты //--- if (ObjectFind("BKGR") >= 0) ObjectDelete("BKGR"); if (ObjectFind("BKGR2") >= 0) ObjectDelete("BKGR2"); if (ObjectFind("BKGR3") >= 0) ObjectDelete("BKGR3"); if (ObjectFind("BKGR4") >= 0) ObjectDelete("BKGR4"); if (ObjectFind("LV") >= 0) ObjectDelete("LV"); //--- //--- Инициализация параметров для MM MinLot = MarketInfo(Symbol(), MODE_MINLOT); MaxLot = MarketInfo(Symbol(), MODE_MAXLOT); LotValue = MarketInfo(Symbol(), MODE_LOTSIZE); LotStep = MarketInfo(Symbol(), MODE_LOTSTEP); FreeMargin = MarketInfo(Symbol(), MODE_MARGINREQUIRED); //--- Получение значения стоимости лота конкретного символа исходя из парамтеров вашего брокера. double SymbolBid = 0; if (StringSubstr(AccountCurrency(), 0, 3) == "JPY") { SymbolBid = MarketInfo("USDJPY" + StringSubstr(Symbol(), 6), MODE_BID); if (SymbolBid > 0.1) LotPrice = SymbolBid; else LotPrice = 84; } //--- if (StringSubstr(AccountCurrency(), 0, 3) == "GBP") { SymbolBid = MarketInfo("GBPUSD" + StringSubstr(Symbol(), 6), MODE_BID); if (SymbolBid > 0.1) LotPrice = 1 / SymbolBid; else LotPrice = 0.6211180124; } //--- if (StringSubstr(AccountCurrency(), 0, 3) == "EUR") { SymbolBid = MarketInfo("EURUSD" + StringSubstr(Symbol(), 6), MODE_BID); if (SymbolBid > 0.1) LotPrice = 1 / SymbolBid; else LotPrice = 0.7042253521; } //--- Параметры на открытие iWPR_Filter_OpenLong_a = iWPR_Filter_Open_a; iWPR_Filter_OpenLong_b = iWPR_Filter_Open_b; iWPR_Filter_OpenShort_a = 100 - iWPR_Filter_Open_a; iWPR_Filter_OpenShort_b = 100 - iWPR_Filter_Open_b; //--- Параметры на закрытие iWPR_Filter_CloseLong = iWPR_Filter_Close; iWPR_Filter_CloseShort = 100 - iWPR_Filter_Close; //--- return (0); } //+--------------------------------------------------------------------------------------------------------------+ //| DEINIT. Удаление объектов на графике. //+--------------------------------------------------------------------------------------------------------------+ int deinit() { //+--------------------------------------------------------------------------------------------------------------+ if (ObjectFind("BKGR") >= 0) ObjectDelete("BKGR"); if (ObjectFind("BKGR2") >= 0) ObjectDelete("BKGR2"); if (ObjectFind("BKGR3") >= 0) ObjectDelete("BKGR3"); if (ObjectFind("BKGR4") >= 0) ObjectDelete("BKGR4"); if (ObjectFind("LV") >= 0) ObjectDelete("LV"); //--- return (0); } //+--------------------------------------------------------------------------------------------------------------+ //| START. Проверка на ошибки, а также старт функции Scalper. //+--------------------------------------------------------------------------------------------------------------+ int start() { //+--------------------------------------------------------------------------------------------------------------+ if((Ask-Bid)>MaxSpread*Point*K) { ObjectCreate("Spread", OBJ_LABEL, 0, 0, 0, 0, 0); ObjectSet("Spread", OBJPROP_CORNER, 2); ObjectSet("Spread", OBJPROP_YDISTANCE, 45); ObjectSet("Spread", OBJPROP_XDISTANCE, 10); ObjectSetText("Spread", "Spread ! " + DoubleToStr((Ask - Bid) / Point, 0), 20, "Tahoma", Red); } if((Ask-Bid)0&&iVolume(Symbol(),1,0)>Tick)return(0); CloseOrders(); //--- Сопровождение ордеров ModifyOrders(); //--- Вывод в безубыток //--- Инициализация объёма сдеки if (AutoMM > 0.0 && (!RecoveryMode)) LotSize = MathMax(MinLot, MathMin(MaxLot, MathCeil(MathMin(AutoMM_Max, AutoMM) / LotPrice / 100.0 * AccountFreeMargin() / LotStep / (LotValue / 100)) * LotStep)); if (AutoMM > 0.0 && RecoveryMode) LotSize = CalcLots(); //--- Если включен RecoveryMode используем CalcLots if (AutoMM == 0.0) LotSize = FixedLot; //--- Проверка наличия исторических данных для таймфрейма M15 if(iBars(Symbol(), PERIOD_M15) < iMA_Period || iBars(Symbol(), PERIOD_M15) < iWPR_Period || iBars(Symbol(), PERIOD_M15) < iATR_Period || iBars(Symbol(), PERIOD_M15) < iCCI_Period) { Print("Недостаточно исторических данных для торговли"); return; } //--- if (DayOfWeek() == 1 && iVolume(NULL, PERIOD_D1, 0) < 5.0) return (0); if (StringLen(EASymbol) < 6) return (0); //--- if ((!IsTesting()) && IsStopped()) return (0); if ((!IsTesting()) && !IsTradeAllowed()) return (0); if ((!IsTesting()) && IsTradeContextBusy()) return (0); //--- HideTestIndicators(TRUE); //--- if(iATR(Symbol(),1440,2,0)>0.01||iATR(Symbol(),1440,2,0)>iATR(Symbol(),1440,2,1)) Scalper(); //--- return (0); } //+--------------------------------------------------------------------------------------------------------------+ //| Scalper. Основная функция. Сначало производится проверка спреда, далее проверка сигналов на вход. //+--------------------------------------------------------------------------------------------------------------+ void Scalper() { //+--------------------------------------------------------------------------------------------------------------+ //--- Сообщение о превышенном спреде if (MaxSpreadFilter()) { if (!CheckSpreadRule && WriteDebugLog) CheckSpreadRule = TRUE; //--- } else { //--- CheckSpreadRule = FALSE; if (OpenLongSignal() && LongTrade) OpenPosition(OP_BUY);//&& OpenTradeCount() if (OpenShortSignal() && ShortTrade) OpenPosition(OP_SELL);//&& OpenTradeCount() //--- } //--- Закрытие if (MaxSpreadFilter) } //+--------------------------------------------------------------------------------------------------------------+ //| OpenPosition. Функция открытия позиции. //+--------------------------------------------------------------------------------------------------------------+ int OpenPosition(int OpType) { //+--------------------------------------------------------------------------------------------------------------+ int RandomOpenTime; //--- Задержка по времени на открытие double DistLevel; //--- Цена покупки или продажи. Необходима для проверки дистанции открытия color OpenColor; //--- Цвет открытия позиции. Если Buy то голубая, если Sell то красная int OpenOrder; //--- Открытие позиции int OpenOrderError; //--- Ошибка открытия string OpTypeString; //--- Преобразования вида позиции в текстовое значение double OpenPrice; //--- Цена открытия double OpenPricel; double OpenPriceb; int OpTypel; int OpTypeb; //--- double TP, SL; double OrderTP = NormalizeDouble (TakeProfit * pp , pd); //--- Преобразуем тейк-профит в вид Points double OrderSL = NormalizeDouble (StopLoss * pp , pd); //--- Преобразуем стоп-лосс в вид Points double OpenLotSize = LotSize; //--- Расчет объёма позиции double OpenLotSizel = LotSize; double OpenLotSizeb = LotSize; int b=0,s=0,z=0,r=0,r1=0; double c = iClose(Symbol(),1,0); double Klot =1; double Klot1=1; double Klotb=1; double LB; double W = iWPR(NULL,1440,7, 0); //--------------------------------------------------------------------------- int ns=0,nb=0,bl=0,sl=0,db=0,ds=0,bs=0,ss=0,nss=0,nbs=0,nbl=0,nsl=0,rz=0; int trade = OrdersTotal() - 1; for (int i = trade; i >= 0; i--) { if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) { if (OrderMagicNumber() == MagicNumber && OrderSymbol() == EASymbol) { if (OrderType()==OP_BUY)b=1; if (OrderType()==OP_SELL)s=1; if (OrderType()==OP_BUY&&AskOrderOpenPrice()+DOP*Point*K)ns=1; if (OrderType()==OP_BUY&&AskOrderOpenPrice()+DOPS*Point*K)nss=1; if (OrderType()==OP_BUYLIMIT&&nb==0)bl=1; if (OrderType()==OP_SELLLIMIT&&ns==0)sl=1; if (OrderType()==OP_BUYLIMIT)nbl=1; if (OrderType()==OP_SELLLIMIT)nsl=1; if (OrderType()==OP_BUYSTOP)bs=1; if (OrderType()==OP_SELLSTOP)ss=1; if (OrderType()==OP_BUYLIMIT&&TimeCurrent()-OrderOpenTime()>TimeL*60)OrderDelete(OrderTicket()); if (OrderType()==OP_SELLLIMIT&&TimeCurrent()-OrderOpenTime()>TimeL*60)OrderDelete(OrderTicket()); if (OrderType()==OP_BUYSTOP&&TimeCurrent()-OrderOpenTime()>TimeS*60)OrderDelete(OrderTicket()); if (OrderType()==OP_SELLSTOP&&TimeCurrent()-OrderOpenTime()>TimeS*60)OrderDelete(OrderTicket()); if (OrderType()==OP_BUY&&DeleteLimit==TRUE&&OrderStopLoss()>OrderOpenPrice())db=1; if (OrderType()==OP_SELL&&DeleteLimit==TRUE&&OrderStopLoss()OrderOpenPrice()+(LimitOrder+SecureProfitTriger)*Point*K)OrderDelete(OrderTicket()); if (OrderType()==OP_SELLLIMIT&&DeleteLimit==TRUE&&AskStopOrder*Point*K) OrderModify(OrderTicket(),Ask+StopOrder*Point*K,0,0,0,CLR_NONE); if (OrderType()==OP_SELLSTOP&&ModifStop==TRUE&&Bid-OrderOpenPrice()>StopOrder*Point*K) OrderModify(OrderTicket(),Bid-StopOrder*Point*K,0,0,0,CLR_NONE); if (Margin == TRUE&&AccountEquity()>AccountBalance()+AccountMargin()*ProfitMargin)rz=1; } } } //---------------------------------------------------------------------------- RefreshRates(); //--- Если длинная позиция, то if (OpType == OP_BUY) { OpenPrice = NormalizeDouble(Ask, Digits); OpenPricel = NormalizeDouble(Bid-LimitOrder*Point*K, Digits); OpenPriceb = NormalizeDouble(Ask+StopOrder*Point*K, Digits); OpenColor = OpenBuyColor; if (bl==0){OpTypel=OP_BUYLIMIT;r=1;} if (bs==0&&nbs==1){OpTypeb=OP_BUYSTOP;r1=1;} if (W>-5)MarketOrder=FALSE; if (b==0||(DOP>0&&nb==1)||rz==1)z=1; //--- if (MinimLot == TRUE&&nb==0)OpenLotSize=MarketInfo(Symbol(),MODE_MINLOT); if (MinimLot == TRUE&&nbl==0&&b==0&&MarketOrder==FALSE)OpenLotSizel=MarketInfo(Symbol(),MODE_MINLOT); if (nb==1) { Klot=KDOP; if (Klot*OpenLotSize>MarketInfo(Symbol(),MODE_MAXLOT))Klot=MarketInfo(Symbol(),MODE_MAXLOT)/OpenLotSize; } Klot1=KLimit; if (Klot1*OpenLotSizel>MarketInfo(Symbol(),MODE_MAXLOT))Klot1=MarketInfo(Symbol(),MODE_MAXLOT)/OpenLotSizel; Klotb=KStop; if (Klotb*OpenLotSizel>MarketInfo(Symbol(),MODE_MAXLOT))Klotb=MarketInfo(Symbol(),MODE_MAXLOT)/OpenLotSizeb; if (UseStopLevels) { //--- Если включены стоп-уровни (стоп-лосс и тейк-профит) TP = NormalizeDouble(OpenPrice + OrderTP, Digits); //--- То расчитывает тейк-профит SL = NormalizeDouble(OpenPrice - OrderSL, Digits); //--- и стоп-лосс //--- } else {TP = 0; SL = 0;} //--- Если короткая позиция, то } else { OpenPrice = NormalizeDouble(Bid, Digits); OpenPricel = NormalizeDouble(Ask+LimitOrder*Point*K, Digits); OpenPriceb = NormalizeDouble(Bid-StopOrder*Point*K, Digits); OpenColor = OpenSellColor; if (sl==0){OpTypel=OP_SELLLIMIT;r=1;} if (ss==0&&nss==1){OpTypel=OP_SELLSTOP;r1=1;} if (W<-92)MarketOrder=FALSE; if (s==0||(DOP>0&&ns==1)||rz==1)z=1; //--- if (MinimLot == TRUE&&ns==0)OpenLotSize=MarketInfo(Symbol(),MODE_MINLOT); if (MinimLot == TRUE&&nsl==0&&s==0&&MarketOrder==FALSE)OpenLotSizel=MarketInfo(Symbol(),MODE_MINLOT); if (ns==1) { Klot=KDOP; if (Klot*OpenLotSize>MarketInfo(Symbol(),MODE_MAXLOT))Klot=MarketInfo(Symbol(),MODE_MAXLOT)/OpenLotSize; } Klot1=KLimit; if (Klot1*OpenLotSizel>MarketInfo(Symbol(),MODE_MAXLOT))Klot1=MarketInfo(Symbol(),MODE_MAXLOT)/OpenLotSizel; Klotb=KStop; if (Klotb*OpenLotSizel>MarketInfo(Symbol(),MODE_MAXLOT))Klotb=MarketInfo(Symbol(),MODE_MAXLOT)/OpenLotSizeb; if (UseStopLevels) { TP = NormalizeDouble(OpenPrice - OrderTP, Digits); SL = NormalizeDouble(OpenPrice + OrderSL, Digits); } //--- else {TP = 0; SL = 0;} } if (Market == TRUE ){TP = 0; SL = 0;} int MaximumTradesCount = MaximumTrades; //--- Счетчик открытых позиций while (MaximumTradesCount > 0 ) { //&& OpenTradeCount() //--- if (MarketOrder == TRUE&&z==1)OpenOrder = OrderSend(EASymbol, OpType, Klot*OpenLotSize, OpenPrice, SP, SL, TP, OpenOrderComment, MagicNumber, 0, OpenColor); if (LimitOrder >0&&r==1)OpenOrder = OrderSend(EASymbol, OpTypel, Klot1*OpenLotSizel, OpenPricel, SP, 0, 0, OpenOrderComment, MagicNumber, 0, OpenColor); if (StopOrder >0&&r1==1)OpenOrder = OrderSend(EASymbol, OpTypeb, Klotb*OpenLotSizeb, OpenPriceb, SP, 0, 0, OpenOrderComment, MagicNumber, 0, OpenColor); //--- // Sleep(MathRand() / 1000); //--- Задержка в несколько секунд после открытия //--- if (OpenOrder < 0) { if (!(OpenAddOrderRule)) break; //--- Если нет разрешения на открытие позиции, то прекращаем цикл //--- Sleep(6000); //--- Делаем паузу RefreshRates(); //--- и обновляем котировки //--- if (OpType == OP_BUY) DistLevel = NormalizeDouble(Ask, Digits); //--- Получаем новые цены покупки и продажи else DistLevel = NormalizeDouble(Bid, Digits); //--- if (NormalizeDouble(MathAbs((DistLevel - OpenPrice) / pp), 0) > Dist) break; //--- Вначале возвращает абсолютное значение разницы между текущим курсом и ценой открытия, далее сравнивает полученное с значение со значением переменной Dist //--- OpenPrice = DistLevel; //--- Получаем новое значение OpenPrice MaximumTradesCount--; //--- И вычитаем -1 из счетчика MaximumTrades } else { if (OrderSelect(OpenOrder, SELECT_BY_TICKET)) OpenPrice = OrderOpenPrice(); break; } //--- Закрытие else { при OpenOrder > 0 } //--- Закрытие цикла while (MaximumTradesCount > 0) //--- return (OpenOrder); } //+--------------------------------------------------------------------------------------------------------------+ //| ModifyOrders. Модификация ордеров в безубыток. //+--------------------------------------------------------------------------------------------------------------+ void ModifyOrders() { //+--------------------------------------------------------------------------------------------------------------+ bool TicketModify; //--- Закрытие ордера int total = OrdersTotal() - 1; int ModifyError = GetLastError(); int ModifyTicketID = OrderTicket(); string ModifyOrderType = OrderType(); //--- for (int i = total; i >= 0; i--) { //--- Счетчик открытых ордеров if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) { if (OrderType() == OP_BUY&&OrderStopLoss()==0&&OrderMagicNumber() == MagicNumber && OrderSymbol() == EASymbol) OrderModify(OrderTicket(), OrderOpenPrice(), OrderOpenPrice()- StopLoss*Point*K,OrderOpenPrice()+TakeProfit*Point*K , 0, CLR_NONE); if (OrderType() == OP_SELL&&OrderStopLoss()==0&&OrderMagicNumber() == MagicNumber && OrderSymbol() == EASymbol) OrderModify(OrderTicket(), OrderOpenPrice(), OrderOpenPrice()+ StopLoss*Point*K,OrderOpenPrice()-TakeProfit*Point*K , 0, CLR_NONE); if(Трейлинг>0) { if(OrderType() == OP_SELL&&OrderMagicNumber() == MagicNumber && OrderSymbol() == EASymbol)//&&(OrderMagicNumber()==Magic_2||OrderMagicNumber()==Magic_3)) { if(OrderOpenPrice() - Ask > Профит_срабатывания*Point*K) { if(OrderStopLoss() > Ask + (OrderOpenPrice()*Трейлинг-Ask*Трейлинг) ) { OrderModify(OrderTicket(), OrderOpenPrice(), Ask + OrderOpenPrice()*Трейлинг-Ask*Трейлинг, OrderTakeProfit(),0, CLR_NONE); // return(0); } } } else if(OrderType() == OP_BUY&&OrderMagicNumber() == MagicNumber && OrderSymbol() == EASymbol)//&&(OrderMagicNumber()==Magic_2||OrderMagicNumber()==Magic_3)) { if(Bid - OrderOpenPrice() > Профит_срабатывания*Point*K) { if(OrderStopLoss() < Bid - (Bid - OrderOpenPrice())*Трейлинг) { OrderModify(OrderTicket(), OrderOpenPrice(), Bid - Bid*Трейлинг + OrderOpenPrice()*Трейлинг , OrderTakeProfit() ,0, CLR_NONE); } } } } //--- Модификация ордера на покупку if (OrderType() == OP_BUY) { if (OrderMagicNumber() == MagicNumber && OrderSymbol() == EASymbol) { if (Bid - OrderOpenPrice() > SecureProfitTriger * pp && MathAbs(OrderOpenPrice() + SecureProfit * pp - OrderStopLoss()) >= Point) { //--- Модифицируем ордер TicketModify = OrderModify(OrderTicket(), OrderOpenPrice(), NormalizeDouble(OrderOpenPrice() + SecureProfit * pp, Digits), OrderTakeProfit(), 0, Blue); } } } //--- Закрытие if (OrderType() == OP_BUY) //--- Модификация ордера на продажу if (OrderType() == OP_SELL) { if (OrderMagicNumber() == MagicNumber && OrderSymbol() == EASymbol) { if (OrderOpenPrice() - Ask > SecureProfitTriger * pp && MathAbs(OrderOpenPrice() - SecureProfit * pp - OrderStopLoss()) >= Point) { //--- Модифицируем ордер TicketModify = OrderModify(OrderTicket(), OrderOpenPrice(), NormalizeDouble(OrderOpenPrice() - SecureProfit * pp, Digits), OrderTakeProfit(), 0, Red); } } } //--- Закрытие if (OrderType() == OP_SELL) } } //--- Закрытие for (int i = total - 1; i >= 0; i--) } //+--------------------------------------------------------------------------------------------------------------+ //| CloseTrades. Виртуальный тейк-профит и стоп-лосс. //| Если включена функция UseStopLevels, то используется как функция резервного закрытия. //+--------------------------------------------------------------------------------------------------------------+ void CloseOrders() { //+--------------------------------------------------------------------------------------------------------------+ bool TicketClose; //--- Закрытие ордера int total = OrdersTotal() - 1; int OpenLongOrdersCount = 0; int OpenShortOrdersCount = 0; int MaxCount = 3; int CloseError = GetLastError(); int CloseTicketID = OrderTicket(); string CloseOrderType = OrderType(); //--- for (int i = total; i >= 0; i--) { //--- Счетчик открытых ордеров if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) { //--- Закрытие по профиту или лоссу ордеров на покупку if (OrderType() == OP_BUY&&TimeCurrent()-OrderOpenTime()>TIME) { OpenLongOrdersCount++; if (OrderMagicNumber() == MagicNumber && OrderSymbol() == EASymbol) { if (Bid >= OrderOpenPrice() + TakeProfit * pp || Bid <= OrderOpenPrice() - StopLoss * pp || CloseLongSignal(OrderOpenPrice(), ExistPosition())) { //--- for (int MinCount = 1; MinCount <= MathMax(1, MaxCount); MinCount++) { RefreshRates(); if (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), CloseSP, CloseBuyColor)) { OpenLongOrdersCount--; //--- Обнуляем счетчик break; //--- } } } } } //--- Закрытие if (OrderType() == OP_BUY) //--- Закрытие по профиту или лоссу ордеров на продажу if (OrderType() == OP_SELL&&TimeCurrent()-OrderOpenTime()>TIME) { OpenShortOrdersCount++; if (OrderMagicNumber() == MagicNumber && OrderSymbol() == EASymbol) { if (Ask <= OrderOpenPrice() - TakeProfit * pp || Ask >= OrderOpenPrice() + StopLoss * pp || CloseShortSignal(OrderOpenPrice(), ExistPosition())) { //--- for (MinCount = 1; MinCount <= MathMax(1, MaxCount); MinCount++) { RefreshRates(); if (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), CloseSP, CloseSellColor)) { OpenShortOrdersCount--; //--- Обнуляем счетчик break; //--- } } } } } //--- Закрытие if (OrderType() == OP_SELL) } } //--- Закрытие for (int i = total - 1; i >= 0; i--) { } //+--------------------------------------------------------------------------------------------------------------+ //| OpenLongSignal. Сигнал на открытие длинной позиции. //+--------------------------------------------------------------------------------------------------------------+ bool OpenLongSignal() { //+--------------------------------------------------------------------------------------------------------------+ bool result = false; bool result1 = false; bool result2 = false; bool result3 = false; //--- Расчет основных сигналов на вход double iClose_Signal = iClose(NULL, PERIOD_M15, 1); double iMA_Signal = iMA(NULL, PERIOD_M15, iMA_Period, 0, MODE_SMMA, PRICE_CLOSE, 1); double iWPR_Signal = iStochastic(NULL, PERIOD_M15,iWPR_Period,M,Z, MODE_SMA, 0, MODE_SIGNAL,1);//iWPR(NULL, PERIOD_M15, iWPR_Period, 1); double iATR_Signal = iATR(NULL, PERIOD_M15, iATR_Period, 1); double iCCI_Signal = iCCI(NULL, TFCCI, iCCI_Period, PRICE_TYPICAL, 1); //--- double iMA_Filter_a = NormalizeDouble(iMA_Filter_Open_a*pp,pd); double iMA_Filter_b = NormalizeDouble(iMA_Filter_Open_b*pp,pd); double BidPrice = Bid; //--- (iClose_Signal >= BidPrice) Сравнение идёт именно с Bid (а не с Ask, как должно быть), так как цена закрытия свечи iClose_Signal формируется на основании значения Bid //--- double W = iWPR(NULL,15,17, 0); //--- Сверяем сигнал по АТР с его фильтром if (iATR_Signal <= FilterATR * pp) return (0); //--- if (iClose_Signal - iMA_Signal > iMA_Filter_a && iClose_Signal - BidPrice >= - cf && iWPR_Filter_OpenLong_a > iWPR_Signal) result1 = true; else result1 = false; //--- if (iClose_Signal - iMA_Signal > iMA_Filter_b && iClose_Signal - BidPrice >= - cf && - iCCI_OpenFilter > iCCI_Signal) result2 = true; else result2 = false; //--- if (iClose_Signal - iMA_Signal > iMA_Filter_b && iClose_Signal - BidPrice >= - cf && iWPR_Filter_OpenLong_b > iWPR_Signal) result3 = true; else result3 = false; //---W<-10&& if ((result1 == true || result2 == true || result3 == true)) result = true; else result = false; //--- return (result); } //+--------------------------------------------------------------------------------------------------------------+ //| OpenShortSignal. Сигнал на открытие короткой позиции. //+--------------------------------------------------------------------------------------------------------------+ bool OpenShortSignal() { //+--------------------------------------------------------------------------------------------------------------+ bool result = false; bool result1 = false; bool result2 = false; bool result3 = false; //--- Расчет основных сигналов на вход double iClose_Signal = iClose(NULL, PERIOD_M15, 1); double iMA_Signal = iMA(NULL, PERIOD_M15, iMA_Period, 0, MODE_SMMA, PRICE_CLOSE, 1); double iWPR_Signal = iStochastic(NULL, PERIOD_M15,iWPR_Period,M,Z, MODE_SMA, 0, MODE_SIGNAL,1);//iWPR(NULL, PERIOD_M15, iWPR_Period, 1); double iATR_Signal = iATR(NULL, PERIOD_M15, iATR_Period, 1); double iCCI_Signal = iCCI(NULL, TFCCI, iCCI_Period, PRICE_TYPICAL, 1); //--- double iMA_Filter_a = NormalizeDouble(iMA_Filter_Open_a*pp,pd); double iMA_Filter_b = NormalizeDouble(iMA_Filter_Open_b*pp,pd); double BidPrice = Bid; //--- double W = iWPR(NULL,240, 5, 0); //--- Сверяем сигнал по АТР с его фильтром if (iATR_Signal <= FilterATR * pp) return (0); //--- if (iMA_Signal - iClose_Signal > iMA_Filter_a && iClose_Signal - BidPrice <= cf && iWPR_Signal > iWPR_Filter_OpenShort_a) result1 = true; else result1 = false; //--- if (iMA_Signal - iClose_Signal > iMA_Filter_b && iClose_Signal - BidPrice <= cf && iCCI_Signal > iCCI_OpenFilter) result2 = true; else result2 = false; //--- if (iMA_Signal - iClose_Signal > iMA_Filter_b && iClose_Signal - BidPrice <= cf && iWPR_Signal > iWPR_Filter_OpenShort_b) result3 = true; else result3 = false; //---W>-90&& if ((result1 == true || result2 == true || result3 == true)) result = true; else result = false; //--- return (result); } //+--------------------------------------------------------------------------------------------------------------+ //| CloseLongSignal. Сигнал на закрытие длинной позиции. //+--------------------------------------------------------------------------------------------------------------+ bool CloseLongSignal(double OrderPrice, int CheckOrders) { //+--------------------------------------------------------------------------------------------------------------+ bool result = false; bool result1 = false; bool result2 = false; //--- double iWPR_Signal = iStochastic(NULL, PERIOD_H1,iWPR_Period,1,1, MODE_SMA, 0, MODE_SIGNAL,1);//iWPR(NULL, PERIOD_H1, iWPR_Period, 1);// double iClose_Signal = iClose(NULL, PERIOD_H1, 1);// double iOpen_CloseSignal = iOpen(NULL, PERIOD_M1, 1); double iClose_CloseSignal = iClose(NULL, PERIOD_M1, 1); //--- double MaxLoss = NormalizeDouble(-MaxLossPoints * pp,pd); //--- double Price_Filter = NormalizeDouble(Price_Filter_Close*pp,pd); double BidPrice = Bid; //--- //--- if (OrderPrice - BidPrice <= MaxLoss && iClose_Signal - BidPrice <= cf && iWPR_Signal > iWPR_Filter_CloseLong && CheckOrders == 1) result1 = true; else result1 = false; //--- if (iOpen_CloseSignal > iClose_CloseSignal && BidPrice - OrderPrice >= Price_Filter && CheckOrders == 1) result2 = true; else result2 = false; //--- if (result1 == true || result2 == true) result = true; else result = false; //--- return (result); } //+--------------------------------------------------------------------------------------------------------------+ //| CloseShortSignal. Сигнал на закрытие короткой позиции. //+--------------------------------------------------------------------------------------------------------------+ bool CloseShortSignal(double OrderPrice, int CheckOrders) { //+--------------------------------------------------------------------------------------------------------------+ bool result = false; bool result1 = false; bool result2 = false; //--- double iWPR_Signal = iStochastic(NULL, PERIOD_H1,iWPR_Period,1,1, MODE_SMA, 0, MODE_SIGNAL,1);//iWPR(NULL, PERIOD_H1, iWPR_Period, 1);// double iClose_Signal = iClose(NULL, PERIOD_H1, 1);// double iOpen_CloseSignal = iOpen(NULL, PERIOD_M1, 1); double iClose_CloseSignal = iClose(NULL, PERIOD_M1, 1); //--- double MaxLoss = NormalizeDouble(-MaxLossPoints*pp,pd); //--- double Price_Filter = NormalizeDouble(Price_Filter_Close*pp,pd); double BidPrice = Bid; double AskPrice = Ask; //--- //--- if (AskPrice - OrderPrice <= MaxLoss && iClose_Signal - BidPrice >= - cf && iWPR_Signal < iWPR_Filter_CloseShort && CheckOrders == 1) result1 = true; else result1 = false; //--- if (iOpen_CloseSignal < iClose_CloseSignal && OrderPrice - AskPrice >= Price_Filter && CheckOrders == 1) result2 = true; else result2 = false; //--- if (result1 == true || result2 == true) result = true; else result = false; //--- return (result); } //+--------------------------------------------------------------------------------------------------------------+ //| CalcLots. Функция расчета обьема лота. //| При AutoMM > 0.0 && RecoveryMode функция CalcLots расчитывает объём лота относительно свободных средств. //| //| Также расчет лота производиться исходя из числа открытых в прошлом ордеров. То есть увеличение лота теперь //| зависит не только от свободных средств, но и от числа открытых в прошлом советником ордеров. //| //| Помимо простого ММ, функция рассчитывает лот исходя из произошедших ранее стоп-лоссов при включенном //| параметре RecoveryMode, то есть, при желании можно включить режим восстановления депозита. //+--------------------------------------------------------------------------------------------------------------+ double CalcLots() { //+--------------------------------------------------------------------------------------------------------------+ double SumProfit; //--- Суммарный профит int OldOrdersCount; //--- Текущее кол-во закрытых советником ордеров double loss; //--- Просадка int LossOrdersCount; //--- Число лосей в прошлом double pr; //--- Профит int ProfitOrdersCount; //--- Кол-во прибыльных ордеров ы прошлом double LastPr; //--- Предыдущее значение профит int LastCount; //--- Предыдущее значение счетчика ордеров double MultiLot = 1; //--- Обнуление значения умножения лота //--- //--- Если ММ включен, то if (MultiLotPercent > 0.0 && AutoMM > 0.0) { //--- Обнуляем значения SumProfit = 0; OldOrdersCount = 0; loss = 0; LossOrdersCount = 0; pr = 0; ProfitOrdersCount = 0; //--- //--- Выбираем закрытие ранее ордера for (int i = OrdersHistoryTotal() - 1; i >= 0; i--) { if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) { if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber) { OldOrdersCount++; //--- Считаем ордера SumProfit += OrderProfit(); //--- и суммарный профит //--- Если суммарный профит больше pr (для начала больше 0) if (SumProfit > pr) { //--- Инициализируем профит и счетчик прибыльных ордеров pr = SumProfit; ProfitOrdersCount = OldOrdersCount; } //--- Если суммарный профит меньше loss (для начала больше 0) if (SumProfit < loss) { //--- Инициализируем просадку и счетчик убыточных ордеров loss = SumProfit; LossOrdersCount = OldOrdersCount; } //--- Если текущее кол-во подсчитанных ордеров больше или равно MaxAnalizCount (50), то в будущем считаем только свеженькие ордера а старые вычитаем. if (OldOrdersCount >= MaxAnalizCount) break; } } } //--- Закрытие for (int i = OrdersHistoryTotal() - 1; i >= 0; i--) { //--- Если число прибыльных ордеров меньше или равно числу лосей, то расчитываем значение умножения лота MultiLot if (ProfitOrdersCount <= LossOrdersCount) MultiLot = MathPow(MultiLotPercent, LossOrdersCount); //--- Если нет, то else { //--- Инициализируем параметры по профиту SumProfit = pr; OldOrdersCount = ProfitOrdersCount; LastPr = pr; LastCount = ProfitOrdersCount; //--- Выбираем закрытие ранее ордера (минус число прибыльных ордеров) for (i = OrdersHistoryTotal() - ProfitOrdersCount - 1; i >= 0; i--) { if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) { if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber) { //--- Если выбрано более 50 ордеров прекразщаем выбирать if (OldOrdersCount >= MaxAnalizCount) break; //--- OldOrdersCount++; //--- Считаем кол-во ордеров SumProfit += OrderProfit(); //--- и профит //--- Если новый профит меньше предыдущего (LastPr), то if (SumProfit < LastPr) { //--- Переинициализируем значения профита и кол-во ордеров LastPr = SumProfit; LastCount = OldOrdersCount; } } } } //--- Закрытие for (i = OrdersHistoryTotal() - ProfitOrdersCount - 1; i >= 0; i--) { //--- Если значение счетчика LastCount равно счетчику прибыльных ордеров или прошлый профит равен текщему, то if (LastCount == ProfitOrdersCount || LastPr == pr) MultiLot = MathPow(MultiLotPercent, LossOrdersCount); //--- расчитываем значение умножения лота MultiLot //--- Если нет, то else { //--- Делим положительный (loss - pr) на положительный (LastPr - pr) и сравниваем с риском, после расчитываем умножение лота MultiLot if (MathAbs(loss - pr) / MathAbs(LastPr - pr) >= (Risk + 100.0) / 100.0) MultiLot = MathPow(MultiLotPercent, LossOrdersCount); else MultiLot = MathPow(MultiLotPercent, LastCount); } } } //--- Закрытие if (MultiLotPercent > 0.0 && AutoMM > 0.0) { //--- Получаем финальный объём лота, исходя из выполненных выше действий for (double OpLot = MathMax(MinLot, MathMin(MaxLot, MathCeil(MathMin(AutoMM_Max, MultiLot * AutoMM) / 100.0 * AccountFreeMargin() / LotStep / (LotValue / 100)) * LotStep)); OpLot >= 2.0 * MinLot && 1.05 * (OpLot * FreeMargin) >= AccountFreeMargin(); OpLot -= MinLot) { } return (OpLot); } //+--------------------------------------------------------------------------------------------------------------+ //| MaxSpreadFilter. Функция для расчета размера спреда и сравнения его со значением MaxSpread. //| Если текущий спред превышен, то возвращаем TRUE. //+--------------------------------------------------------------------------------------------------------------+ bool MaxSpreadFilter() { //+--------------------------------------------------------------------------------------------------------------+ RefreshRates(); if (NormalizeDouble(Ask - Bid, Digits) > NDMaxSpread) return (TRUE); //--- else return (FALSE); } //+--------------------------------------------------------------------------------------------------------------+ //| ExistPosition. Функция проверки открытых ордеров. //| Если открыт ордер возвращает True, если нет, дает разрешение (False, 0) на открытие. //+--------------------------------------------------------------------------------------------------------------+ int ExistPosition() { //+--------------------------------------------------------------------------------------------------------------+ int trade = OrdersTotal() - 1; for (int i = trade; i >= 0; i--) { if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) { if (OrderMagicNumber() == MagicNumber) { if (OrderSymbol() == EASymbol) if (OrderType() <= OP_SELL) return (1); } } } //--- return (0); }