Ковалев Сергей. Программирование на алгоритмическом языке MQL4
Подождите немного. Документ загружается.
681
средство для модификации ордера StopLoss - Трейлинг-стоп. Этот инструмент позволяет
модифицировать StopLoss, продвигая его вслед за курсом на определённом
фиксированном расстоянии (см. Руководство клиентского терминала).
Функция модификации ордеров OrderModify() значительно расширяет возможности
модификации: допускается изменение заявленных цен обоих стоп-приказов как в сторону
приближения их к рыночной цене, так и удаление. Ограничением при модификации
рыночного ордера является минимально допустимая дистанция между стоп-приказом и
рыночной ценой, устанавливаемая дилинговым центром (см. Характеристики ордеров и
Требования и ограничения торговых операций). В случае, если программа пытается
изменить положение стоп-приказа так, что он оказывается ближе к рынку, чем на
минимально допустимую дистанцию, то такой торговый приказ будет отклонён
клиентским терминалом, и исполнение функции OrderModify() закончится неудачей
(ошибка 130). Поэтому в программе обязательно должен быть предусмотрен блок
вычислений, учитывающий это ограничение.
Пример простого эксперта, модифицирующего StopLoss всех рыночных
ордеров, для которых дистанция между заявленной ценой StopLoss и
рыночной котировкой оказывается больше заданной (modifystoploss.mq4)
//--------------------------------------------------------------------
// modifystoploss.mq4
// Предназначен для использования в качестве примера в учебнике MQL4.
//--------------------------------------------------------------------
extern int Tral_Stop=10; // Дист. преследования
//--------------------------------------------------------------- 1 --
int start() // Спец. функция start
{
string Symb=Symbol(); // Финанс. инструмент
//--------------------------------------------------------------- 2 --
for(int i=1; i<=OrdersTotal(); i++) // Цикл перебора ордер
{
if (OrderSelect(i-1,SELECT_BY_POS)==true) // Если есть следующий
{ // Анализ ордеров:
int Tip=OrderType(); // Тип ордера
if(OrderSymbol()!=Symb||Tip>1)continue;// Не наш ордер
682
double SL=OrderStopLoss(); // SL выбранного орд.
//------------------------------------------------------ 3 --
while(true) // Цикл модификации
{
double TS=Tral_Stop; // Исходное значение
int Min_Dist=MarketInfo(Symb,MODE_STOPLEVEL);//Миним. дист
if (TS < Min_Dist) // Если меньше допуст.
TS=Min_Dist; // Новое значение TS
//--------------------------------------------------- 4 --
bool Modify=false; // Не назначен к модифи
switch(Tip) // По типу ордера
{
case 0 : // Ордер Buy
if (NormalizeDouble(SL,Digits)< // Если ниже желаем.
NormalizeDouble(Bid-TS*Point,Digits))
{
SL=Bid-TS*Point; // то модифицируем его
string Text="Buy "; // Текст для Buy
Modify=true; // Назначен к модифи.
}
break; // Выход из switch
case 1 : // Ордер Sell
if (NormalizeDouble(SL,Digits)> // Если выше желаем.
NormalizeDouble(Ask+TS*Point,Digits)
|| NormalizeDouble(SL,Digits)==0)//или равно нулю
{
SL=Ask+TS*Point; // то модифицируем его
Text="Sell "; // Текст для Sell
Modify=true; // Назначен к модифи.
}
} // Конец switch
if (Modify==false) // Если его не модифи
break; // Выход из while
//--------------------------------------------------- 5 --
double TP =OrderTakeProfit(); // TP выбранного орд.
double Price =OrderOpenPrice(); // Цена выбранн. орд.
int Ticket=OrderTicket(); // Номер выбранн. орд.
Alert ("Модификация ",Text,Ticket,". Ждём ответ..");
bool Ans=OrderModify(Ticket,Price,SL,TP,0);//Модифи его!
//--------------------------------------------------- 6 --
if (Ans==true) // Получилось :)
{
Alert ("Ордер ",Text,Ticket," модифицирован:)");
break; // Из цикла модифи.
}
683
//--------------------------------------------------- 7 --
int Error=GetLastError(); // Не получилось :(
switch(Error) // Преодолимые ошибки
{
case 130:Alert("Неправильные стопы. Пробуем ещё раз.");
RefreshRates(); // Обновим данные
continue; // На след. итерацию
case 136:Alert("Нет цен. Ждём новый тик..");
while(RefreshRates()==false) // До нового тика
Sleep(1); // Задержка в цикле
continue; // На след. итерацию
case 146:Alert("Подсистема торгов занята.Пробуем ещё");
Sleep(500); // Простое решение
RefreshRates(); // Обновим данные
continue; // На след. итерацию
// Критические ошибки
case 2 : Alert("Общая ошибка.");
break; // Выход из switch
case 5 : Alert("Старая версия клиентского терминала.");
break; // Выход из switch
case 64: Alert("Счет заблокирован.");
break; // Выход из switch
case 133:Alert("Торговля запрещена");
break; // Выход из switch
default: Alert("Возникла ошибка ",Error);//Др. ошибки
}
break; // Из цикла модифи.
} // Конец цикла модифи.
//------------------------------------------------------ 8 --
} // Конец анализа орд.
} // Конец перебора орд.
//--------------------------------------------------------------- 9 --
return; // Выход из start()
}
//-------------------------------------------------------------- 10 --
Представленная для примера программа - эксперт. В случае необходимости ничего не
мешает реализовать функцию модификации ордеров и в скрипте. Однако использование
обычного скрипта в данном случае не удобно - после выполнения торговых операций
скрипт закончит работу. Использование скрипта может быть оправданно в том случае,
если в программе реализуется выполнение разовой операции - например, открытие или
закрытие ордеров. В данном случае решается задача, требующая постоянного контроля
ситуации - изменить положение стоп-приказа, если выполняется некоторое условие, а
именно, дистанция между рыночным курсом и заявленным значением стоп-приказа
684
превышает некоторую заданную величину (в нашем случае 10 пунктов). Для длительного
использования гораздо удобнее использовать эксперт, который запускается на исполнение
на каждом тике, а прекращает работу только в результате прямого указания пользователя.
Алгоритм представленного эксперта modifystoploss.mq4 очень прост. Основные
вычисления выполняются в цикле перебора ордеров (блок 2-9). Выбор ордера ведётся
среди рыночных и отложенных ордеров (параметр pool в вызове функции OrderSelect() не
указан явно). В блоке 2-3 отсортировываются отложенные ордера, а также ордера,
открытые по другому финансовому инструменту; для ордеров, прошедших отбор,
определяется значение StopLoss.
Блок 3-9 представляет цикл модификации выбранного ордера. В блоке 3-4 определяется
новое текущее значение ограничивающей дистанции (брокер может изменить это
значение в любой момент). В блоке 4-5 вычисляется необходимость модификации
отобранного ордера (текущего обрабатываемого в цикле for), а также новое значение
StopLoss. Если текущий ордер не требует модификации, то в конце блока 4-5
осуществляется выход из цикла while, и модификация этого ордера (в блоке 5-6) не
осуществляется. Если же ордер требует модификации, то управление передаётся в блок 5-
6, в котором вычисляются необходимые параметры и выполняется обращение к функции
OrderModify(), которая и формирует торговый приказ.
Если торговая операция завершилась успешно, то оператор break в блоке 6-7 заканчивает
исполнение цикла while, что приводит к окончанию текущей итерации цикла перебора
ордеров for (и на следующей итерации начинается обработка очередного ордера). Если же
торговая операция закончилась неудачей, то производится обработка ошибок. В случае,
когда ошибка оказывается не критической, попытка повторить торговую операцию
повторяется. Если же ошибка оценивается как критическая, то управление передаётся за
пределы цикла модификации для обработки следующего ордера (в цикле for).
Здесь необходимо обратить внимание на небольшую особенность, касающуюся
модификации рыночных ордеров. Функция OrderModify() устанавливает новые значения
цен одновременно для обоих стоп-приказов. При этом требование соблюдения
минимальной дистанции касается только того стоп-приказа, новое значение которого
отличается от текущего. Если же новое значение остаётся таким же, как текущее, то такой
стоп-приказ может находиться на любом расстоянии от рыночной цены, а
соответствующий торговый приказ является корректным.
685
Например, имеется рыночный ордер Buy, открытый по цене 1.295467, со стоп-приказами
StopLoss = 1.2958 и TakeProfit = 1.2960. Минимальная дистанция, установленная
брокером, равна 5 пунктов. При рыночной цене Bid = 1.2959 возникают условия для
модификации ордера, а именно для установки StopLoss = 1.2949 (Bid - 10 пунктов). Для
исполнения функции OrderModify() требуется указать и новое значение TakeProfit. Наш
советник не изменяет положение TakeProfit, поэтому в функции задаётся текущее
значение TakeProfit = 1.2960.
Несмотря на то, что новое заявленное значение TakeProfit = 1.2960 находится близко к
рыночной цене Bid (всего 1 пункт, т.е меньше допустимой дистанции 5 пунктов), это
значение не отличается от текущего значения TakeProfit = 1.2960, поэтому торговый
приказ будет признан корректным и исполнен на сервере (в общем случае торговый
приказ может быть отклонён, но по другим причинам). На рис. 102 и 103 представлены
результаты успешной модификации ордера в этой ситуации.
Рис. 102. Вид окна сообщений и окна финансового инструмента при модификации ордера
экспертом modifystoploss.mq4 в момент, когда рыночный курс находится вблизи от
заявленного значения TakeProfit.
Рис. 103. Модифицированный ордер в окне Терминала.
686
На Рис. 103 видно, что в результате модификации новое значение StopLoss = 1.2949, а
текущая цена Bid = 1.2959 находится на расстоянии 1 пункта от значения TakeProfit.
Отдельно нужно заметить, что сама по себе модификация (и рыночных и отложенных)
ордеров в отрыве от анализа рыночной ситуации производиться не должна. Подобная
модификация может быть полезна только в случае резкого и однонаправленного
движения рыночного курса, которое случается в результате выхода важных новостей.
Если же торговля ведётся на "обычном" рынке, то решение о необходимости
модификации ордеров должно приниматься на основе рыночных критериев. В эксперте
modifystoploss.mq4 тоже используется критерий (StopLoss от рыночной цены дальше
желаемого), по которому принимается решение о модификации, однако он слишком
простой и жёсткий, поэтому не может рассматриваться как критерий, характеризующий
рыночную ситуацию.
10.5.3 Модификация отложенных ордеров
Модификация отложенных ордеров несколько отличается от модификации рыночных.
Существенное отличие состоит в том, что возможно изменить заявленную цену самого
ордера. Обязательно соблюдение правил, ограничивающих положение отложенного
ордера относительно рыночной цены и стоп-приказов ордера относительно заявленной
цены ордера (см. Характеристики ордеров и Требования и ограничения торговых
операций). При этом все характеристики отложенного ордера оцениваются как вновь
заявленные, независимо от предыдущей истории событий, связанных с этим ордером.
Например, имеется отложенный ордер BuyStop = 1.2030, имеющий StopLoss = 1.2025 и
TakeProfit = 1.2035. Минимально допустимая дистанция установлена брокером в размере
5 пунктов. Нетрудно заметить, что стоп-приказы ордера стоят на допустимой границе,
поэтому любая модификация заявленной цены открытия ордера повлечёт обязательную
модификацию по крайней мере одного из стоп-приказов. Если же будет сформирован
торговый приказ, в соответствии с которым предполагается изменить заявленную цену
ордера, а значения стоп-приказов оставить без изменения, то такой торговый приказ будет
признан клиентским терминалом как ошибочный и не будет отправлен на сервер для
исполнения. Например, если в торговом приказе указаны значения BuyStop = 1. 2028,
StopLoss = 1.2025 и TakeProfit = 1.2035, то этот торговый приказ является ошибочным,
несмотря на то, что значения стоп-приказов не изменились - в данном случае нарушено
687
правило соблюдения минимальной дистанции между заявленной ценой открытия ордера и
ценой одного из стоп-приказов (см. Требования и ограничения торговых операций).
Посмотрим, как может выглядеть скрипт, модифицирующий отложенный ордер для
приближения заявленной цены ордера к рыночной цене на некоторое заданное
расстояние. Зададим расстояние 10 пунктов. Для указания программе ордера,
назначенного к модификации (в окне может находиться несколько отложенных ордеров),
используем цену прикрепления скрипта в окно финансового инструмента.
Пример простого скрипта, модифицирующего отложенный ордер,
заявленная цена которого находится ближе к месту прикрепления
скрипта, чем цены других отложенных ордеров (modifyorderprice.mq4).
//--------------------------------------------------------------------
// modifyorderprice.mq4
// Предназначен для использования в качестве примера в учебнике MQL4.
//--------------------------------------------------------------- 1 --
int start() // Спец.функция start
{
int Tral=10; // Дист. приближения
string Symb=Symbol(); // Финанс. инструмент
double Dist=1000000.0; // Предустановка
double Win_Price=WindowPriceOnDropped(); // Здесь брошен скрипт
//--------------------------------------------------------------- 2 --
for(int i=1; i<=OrdersTotal(); i++) // Цикл перебора ордер
{
if (OrderSelect(i-1,SELECT_BY_POS)==true) // Если есть следующий
{ // Анализ ордеров:
//------------------------------------------------------ 3 --
if (OrderSymbol()!= Symb) continue; // Не наш фин.инструм.
if (OrderType()<2) continue; // Рыночный ордер
//------------------------------------------------------ 4 --
if(NormalizeDouble(MathAbs(OrderOpenPrice()-Win_Price),Digits)
< NormalizeDouble(Dist,Digits)) // Выбираем ближайший
{
Dist=MathAbs(OrderOpenPrice()-Win_Price);// Новое значение
int Tip =OrderType(); // Тип выбранного орд.
int Ticket=OrderTicket(); // Номер выбранн. орд.
double Price =OrderOpenPrice(); // Цена выбранн. орд.
double SL =OrderStopLoss(); // SL выбранного орд.
double TP =OrderTakeProfit(); // TP выбранного орд.
688
} // Конец if
} // Конец анализа ордера
} // Конец перебора орд.
//--------------------------------------------------------------- 5 --
if (Tip==0) // Если отложенных нет
{
Alert("По ",Symb," отложенных ордеров нет");
return; // Выход из программы
}
//--------------------------------------------------------------- 6 --
while(true) // Цикл закрытия орд.
{
RefreshRates(); // Обновим данные
//--------------------------------------------------------- 7 --
double TS=Tral; // Исходное значение
int Min_Dist=MarketInfo(Symb,MODE_STOPLEVEL);//Миним. дистанция
if (TS < Min_Dist) // Если меньше допуст.
TS=Min_Dist; // Новое значение TS
//--------------------------------------------------------- 8 --
string Text=""; // Не назначен к модифи
double New_SL=0;
double New_TP=0;
switch(Tip) // По типу ордера
{
case 2: // BuyLimit
if (NormalizeDouble(Price,Digits) < // Если дальше, чем на
NormalizeDouble(Ask-TS*Point,Digits))//..заданное знач
{
double New_Price=Ask-TS*Point; // Новая его цена
if (NormalizeDouble(SL,Digits)>0)
New_SL=New_Price-(Price-SL); // Новый StopLoss
if (NormalizeDouble(TP,Digits)>0)
New_TP=New_Price+(TP-Price); // Новый TakeProfit
Text= "BuyLimit "; // Будем его модифи.
}
break; // Выход из switch
case 3: // SellLimit
if (NormalizeDouble(Price,Digits) > // Если дальше, чем на
NormalizeDouble(Bid+TS*Point,Digits))//..заданное знач
{
New_Price=Bid+TS*Point; // Новая его цена
if (NormalizeDouble(SL,Digits)>0)
New_SL=New_Price+(SL-Price); // Новый StopLoss
if (NormalizeDouble(TP,Digits)>0)
New_TP=New_Price-(Price-TP); // Новый TakeProfit
Text= "SellLimit "; // Будем его модифи.
689
}
break; // Выход из switch
case 4: // BuyStopt
if (NormalizeDouble(Price,Digits) > // Если дальше, чем на
NormalizeDouble(Ask+TS*Point,Digits))//..заданное знач
{
New_Price=Ask+TS*Point; // Новая его цена
if (NormalizeDouble(SL,Digits)>0)
New_SL=New_Price-(Price-SL); // Новый StopLoss
if (NormalizeDouble(TP,Digits)>0)
New_TP=New_Price+(TP-Price); // Новый TakeProfit
Text= "BuyStopt "; // Будем его модифи.
}
break; // Выход из switch
case 5: // SellStop
if (NormalizeDouble(Price,Digits) < // Если дальше, чем на
NormalizeDouble(Bid-TS*Point,Digits))//..заданное знач
{
New_Price=Bid-TS*Point; // Новая его цена
if (NormalizeDouble(SL,Digits)>0)
New_SL=New_Price+(SL-Price); // Новый StopLoss
if (NormalizeDouble(TP,Digits)>0)
New_TP=New_Price-(Price-TP); // Новый TakeProfit
Text= "SellStop "; // Будем его модифи.
}
}
if (NormalizeDouble(New_SL,Digits)<0) // Проверка SL
New_SL=0;
if (NormalizeDouble(New_TP,Digits)<0) // Проверка TP
New_TP=0;
//--------------------------------------------------------- 9 --
if (Text=="") // Если его не модифи
{
Alert("Нет условий для модификации.");
break; // Выход из while
}
//-------------------------------------------------------- 10 --
Alert ("Модификация ",Text,Ticket,". Ждём ответ..");
bool Ans=OrderModify(Ticket,New_Price,New_SL,New_TP,0);//Модифи!
//-------------------------------------------------------- 11 --
if (Ans==true) // Получилось :)
{
Alert ("Модифицирован ордер ",Text," ",Ticket," :)");
break; // Выход из цикла закр
}
//-------------------------------------------------------- 12 --
int Error=GetLastError(); // Не получилось :(
690
switch(Error) // Преодолимые ошибки
{
case 4: Alert("Торговый сервер занят. Пробуем ещё раз..");
Sleep(3000); // Простое решение
continue; // На след. итерацию
case 137:Alert("Брокер занят. Пробуем ещё раз..");
Sleep(3000); // Простое решение
continue; // На след. итерацию
case 146:Alert("Подсистема торговли занята. Пробуем ещё..");
Sleep(500); // Простое решение
continue; // На след. итерацию
}
switch(Error) // Критические ошибки
{
case 2 : Alert("Общая ошибка.");
break; // Выход из switch
case 64: Alert("Счет заблокирован.");
break; // Выход из switch
case 133:Alert("Торговля запрещена");
break; // Выход из switch
case 139:Alert("Ордер заблокирован и уже обрабатывается");
break; // Выход из switch
case 145:Alert("Модификация запрещена. ",
"Ордер слишком близок к рынку");
break; // Выход из switch
default: Alert("Возникла ошибка ",Error);//Другие варианты
}
break; // Выход из цикла закр
} // Конец цикла закр.
//-------------------------------------------------------------- 13 --
Alert ("Скрипт закончил работу -----------------------");
return; // Выход из start()
}
//-------------------------------------------------------------- 14 --
Расстояние между рыночной ценой и заявленной ценой отложенного ордера задано в
переменной Tral. Переменная Win_Price содержит значение цены, на которой в окно
финансового инструмента прикреплён скрипт. В цикле перебора ордеров (блок 2-5)
вычисляются характеристики отложенного ордера, находящегося ближе других к месту
прикрепления скрипта. Блок 6-13 представляет цикл закрытия ордеров. В блоке 8-9
определяется, нужно ли модифицировать выбранный ордер, и, если необходимо,
вычисляются новые значения заявленной цены и стоп-приказов. Приказ на модификацию
отдаётся с помощью функции OrderModify() в блоке 10-11. В блоке 11-13 реализована
обработка ошибок.