Как написать советника для mt5 своими руками

Введение

Эта статья предназначена для начинающих, для тех, кто хочет научиться написанию простых советников на новом языке MQL5. Сначала мы определимся с тем, что требуется от нашего советника, а затем приступим к написанию того, каким образом он будет это делать.

1. Торговая стратегия

Что будет делать наш советник:

• Он будет следить за некоторыми индикаторами и при определенном условии (или условиях) помещать торговый запрос (на продажу или покупку) в зависимости от условий.

Это называется торговой стратегией. Перед тем, как писать советник, сначала нужно разработать стратегию, которую вы хотите автоматизировать в советнике. Давайте конкретизируем нашу стратегию, которую будем применять в советнике.

1. Мы будем использовать индикатор Moving Average (скользящие средние) с периодом 8 (вы можете выбрать любой период, но в данной стратегии мы будем использовать период 8).
2. Мы хотим, чтобы наш советник покупал, если 8-периодная скользящая средняя (далее для удобства будем называть ее MA-8) возрастает и текущая цена закрытия находится выше ее; советник должен продавать, когда MA-8 падает и цена закрытия находится ниже MA-8.
3. Также мы собираемся использовать другой индикатор, называемый Average Directional Movement (ADX) с периодом 8 для определения факта наличия тренда на рынке. Это нужно для того, чтобы входить в рынок, когда он находится в состоянии тренда. Для того, чтобы это реализовать, мы будем помещать торговый запрос (на покупку или продажу) при наступлении условий, указанных выше, а также при значениях ADX, больших 22. Если ADX>22, но уменьшается или ADX<22, мы не будем помещать торговые запросы даже при наступлении условий, изложенных в пункте 2.
4. Мы хотим защитить себя установкой ордеров Stop Loss в 30 пунктов, Take Proft установим на уровне 100 пунктов.
   
5. Также мы хотим, чтобы советник проверял возможности для продажи/покупки только при формировании нового бара, при этом советник должен помещать ордер на покупку только в случае сигнала на покупку и отсутствия открытых длинных позиций. Аналогично в случае продажи — условия на продажу и отсутствие открытых коротких позиций.
   

Стратегия разработана, теперь время начать писать код.

2. Пишем советник

2.1 Мастер MQL5

Начнем с запуска редактора MetaQuotes Language Editor 5. Затем нажимаем Ctrl-N или на кнопку «Создать» в панели инструментов.

Рисунок 1. Создание нового документа MQL5

В окне Мастера MQL5 выбираем «Советник» и нажимаем «Далее», как показано на рис. 2:

Рисунок 2. Выбор типа создаваемой программы

В следующем окне в поле «Имя» напишите имя, которое вы хотите дать вашему советнику, я написал «My_First_EA«. Вы можете указать свое имя в поле «Автор» и адрес в виде ссылки на ваш сайт или e-mail (если есть).

Рисунок 3. Общие параметры советника

Поскольку мы хотим иметь возможность менять некоторые параметры нашего советника, для того, чтобы найти лучшие, мы добавим их при помощи кнопки «Добавить».

Рисунок 4. Входные параметры советника

В нашем советнике нам нужно иметь возможность изменять Stop Loss, Take Profit, ADX Period and Moving Average Period, так что укажем их здесь.

Дважды кликнем мышкой по колонке «Имя» в параметрах и напишем наименование параметра, аналогично в колонках «Тип» и «Начальное значение» укажем тип данных параметра и начальные значения.

После этого, результат будет примерно следующий:

Рисунок 5. Типы данных входных параметров советника

Как видно, мы выбрали тип integer (int) для всех параметров. Рассмотрим подробнее типы данных.

• char: Целый тип char занимает в памяти 1 байт (8 бит) и позволяет выразить в двоичной системе счисления 2^8 значений=256. Тип char может содержать как положительные, так и отрицательные значения. Диапазон изменения значений составляет от -128 до 127.
• uchar: Целый тип uchar также занимает в памяти 1 байт, как и тип char, но в отличие от него, uchar предназначен только для положительных значений. Минимальное значение равно нулю, максимальное значение равно 255. Первая буква u в названии типа uchar является сокращением слова unsigned (беззнаковый).
• short: Целый тип short имеет размер 2 байта(16 бит) и, соответственно, позволяет выразить множество значений равное 2 в степени 16:  2^16=65 536. Так как тип short является знаковым и содержит как положительные, так и отрицательные значения, то диапазон значений находится между -32 768 и 32 767.
• ushort: Беззнаковым типом short является тип ushort, который также имеет размер 2 байта. Минимальное значение равно 0, максимальное значение 65 535.
• int: Целый тип int имеет размер 4 байта (32 бита). Минимальное значение -2 147 483 648, максимальное значение 2 147 483 647.
• uint: Беззнаковый целый тип uint занимает в памяти 4 байта и позволяет выражать целочисленные значения от 0 до 4 294 967 295.
• long: Целый тип long имеет размер 8 байт (64 бита). Минимальное значение -9 223 372 036 854 775 808, максимальное значение 9 223 372 036 854 775 807.
• ulong: Целый тип ulong также занимает 8 байт и позволяет хранить значения от 0 до 18 446 744 073 709 551 615.

Как видно из описания различных типов данных, беззнаковые целые (uint) не предназначены для хранения отрицательных значений, любые попытки установить отрицательные значения могут привести к непредсказуемым результатам. Например, если вы хотите хранить отрицательные значения, нельзя для них использовать переменные типа uchar, uint, ushort, ulong.

Вернемся к нашему советнику. Для значений, меньших 127 или 255, для экономии памяти можно использовать значения типа char or uchar, соответственно, однако для удобства мы зададим их значения как тип int.

После того, как закончено определение необходимых входных параметров индикатора, нажмем на кнопку «Finish» и MetaQuotes Editor5 создаст шаблон кода, представленный ниже:

Для лучшего понимания, рассмотрим отдельно различные секции кода.

В верхней части кода (заголовок) определяются свойства советника. Как видно, это значения, которые были установлены в Мастере MQL5 на рис. 3.

В этой части кода также можно задать дополнительные параметры, например description (текст с кратким описанием советника), определить константы, включить дополнительные файлы или импортируемые функции.

Для выражений, начинающихся с символа «#», не нужно ставить точку с запятой в конце строки, это директивы препроцессора. Другой пример:

• #define
  Директива #define используется для определения констант. Записывается в виде:
• #define identifier token_string
  Это означает, что компилятор заменит в коде переменные identifier численным значением, равным token_string.

Например:

#define ABC               100
#define COMPANY_NAME      «MetaQuotes Software Corp.»

В данном случае COMPANY_NAME будет означать строку «MetaQuotes Software Corp.», вместо ABC будет подразумеваться число, равное 100.

Более подробнее о директивах препроцессора можно прочитать в руководстве по MQL5. Идем далее.

Вторая часть заголовка в нашем коде — это секция входных параметров.

 

Здесь мы задаем входные параметры, которые будут использоваться в советнике как переменные, они могут быть использованы во всех функциях нашего советника.

Переменные, определенные на этом уровне, называются глобальными переменными, поскольку они доступны из любой функции советника. Входные параметры могут быть изменены только вне кода советника при запуске. Также мы можем определить другие переменные, которые будем использовать в нашем советнике, они не будут доступны для модификации извне.

Далее идет функция инициализации советника. Это функция вызывается первой после запуска советника или смены графика и вызывается только один раз.

Этот раздел — лучшее место для проведения проверок, чтобы убедиться в правильности работы нашего советника.

Например, можно проверить, достаточно ли баров на графике для работы нашего советника и т.п.

Также это лучшее место для получения хэндлов технических индикаторов, которые будут использоваться (в нашем случае это индикаторы ADX и Moving Average).

Функция OnDeinit вызывается при удалении советника с графика.

В нашем советнике, в данной функции мы будем освобождать хэндлы индикаторов, созданных в разделе инициализации.

Данная функция производит обработку события NewTick, которое генерируется при приходе новой котировки для символа.

Большая часть кода, отвечающего за реализацию нашей торговой стратегии будет содержаться в данной функции.

Отметим, что советник не сможет производить торговые операции, если в авто-трейдинг не разрешен в клиентском терминале:

Рисунок 6. Торговля советником разрешена

Теперь, когда мы рассмотрели разделы кода нашего советника, начнем добавления кода в шаблон.

2.2. Раздел входных параметров

input int      StopLoss=30;      
input int      TakeProfit=100;   
input int      ADX_Period=8;     
input int      MA_Period=8;      
input int      EA_Magic=12345;   
input double   Adx_Min=22.0;     
input double   Lot=0.1;          

int adxHandle; 
int maHandle;  
double plsDI[],minDI[],adxVal[]; 
double maVal[]; 
double p_close; 
int STP, TKP; 

Как видно, мы добавили новые параметры. Перед тем, как обсудить их предназначение, посмотрим на код. При помощи двойного слэша «//» в код можно помещать комментарии. При помощи комментариев мы можем описывать предназначение наших переменных или производимые нами действия. Комментарии позволяют улучшить понимание кода. Существуют два основных способа написания комментариев:

// глобальные переменные …

Это однострочный комментарий.

Это многострочный комментарий. Многострочные комментарии начинаются с пары символов «/*» и заканчиваются «*/».

При компиляции кода комментарии игнорируются компилятором.

Использование однострочных комментариев для входных параметров позволяет описать предназначение входных параметров. В этом случае вместо наименования параметров будут показаны комментарии, как показано ниже:

Рисунок 7. Входные параметры советника

Вернемся к нашему коду.

Мы решили добавить дополнительные параметры в наш советник. Параметр EA_Magic (Magic Number)  будет использован для всех ордеров нашего советника. Минимальное значение ADX задано как переменная типа double. Значения типа double используются для констант, которые, наряду с целой частью, также могут содержать и дробную часть.

Например:

Количество лотов для торговли (Lot) представляет собой объем финансового инструмента, который мы хотим торговать.

Далее мы также объявили дополнительные переменные, которые будут использованы следующим образом: переменная adxHandle будет использоваться для хранения хэндла индикатора ADX, переменная maHandle для хэндла индикатора Moving Average. Динамические массивы plsDI[], minDI[], adxVal[] are будут использованы для хранения значений +DI, -DI и самого значения ADX для каждого бара графика. Численные значения индикатора Moving Average для каждого бара графика будут храниться в динамическом массиве maVal[].

Кстати, что представляют собой динамические массивы? Динамический массив — это массив, объявленный без указания размера. Другими словами, в квадратных скобках при его описании нет конкретного числа, указывающего его размер.

С другой стороны, для статических массивов их размер определяется при объявлении.

Пример:

double allbars[20]; // этот массив содержит 20 элементов — от 0 до 19

Переменная p_close будет использоваться для хранения численного значения цены Close  для бара, который мы собираемся отслеживать в процессе проверки торговых сигналов на покупку и продажу.

Переменные STP и TKP нужны для установки значений Stop Loss и Take Profit ордеров нашего советника.

2.3. Секция инициализации советника

int OnInit()
  {

   adxHandle=iADX(NULL,0,ADX_Period);

   maHandle=iMA(_Symbol,_Period,MA_Period,0,MODE_EMA,PRICE_CLOSE);

   if(adxHandle<0 || maHandle<0)
     {
      Alert("Ошибка при создании индикаторов - номер ошибки: ",GetLastError(),"!!");
     }

Далее мы получаем хэндлы индикаторов, используя соответствующие функции индикаторов.

Хэндл индикатора ADX получаем при помощи функции iADX. В качестве аргументов ей передается символ графика symbol (NULL  также означает символ текущего графика), период/таймфрейм (0 означает таймфрейм текущего графика), период индикатора ADX,  который будет использоваться для вычисления индикатора (ADX_Period мы определили в разделе входных параметров индикатора):

int  iADX(
   string          symbol,       
   ENUM_TIMEFRAMES  period,       
   int            adx_period     
   );

Хэндл индикатора Moving Average получаем при помощи функции iMA. Аргументы этой функции следующие:

• symbol — Символьное имя инструмента, на данных которого будет вычисляться индикатор (можно использовать _symbol, symbol() или NULL для текущего символа).
• period — Значение периода может быть одним из значений перечисления ENUM_TIMEFRAMES, (можно использовать  _period, period() или 0 для таймфрейма текущего графика).
• ma_period — Период усреднения для вычисления скользящего среднего (который мы определили ранее в разделе входных параметров индикатора).
• ma_shift — Сдвиг индикатора относительно ценового графика (мы используем 0).
• ma_method — Метод усреднения. Может быть любым из значений MODE_SMA, MODE_EMA, MODE_SMMA или MODE_LWMA.
• applied_price — Используемая цена. Может быть любой из ценовых констант ENUM_APPLIED_PRICE или хендлом другого индикатора.

int  iMA(
   string              symbol,        
   ENUM_TIMEFRAMES      period,        
   int                 ma_period,    
   int                 ma_shift,     
   ENUM_MA_METHOD       ma_method,    
   ENUM_APPLIED_PRICE   applied_price  
   );

Для получения более подробной информации, посмотрите справку по этим индикатным функциям в документации по MQL5. Это даст лучшее понимание того, как использовать этот индикатор.

Мы проверяем результат выполнения функций на наличие ошибок, в случае неудачи можем получить ошибку INVALID_HANDLE. В этом случае выводим сообщение об ошибке и ее код, используя функцию   GetlastError и завершаем работу советника.

 

Мы решили хранить значения Stop Loss и Take Profit в определенных ранее переменных STP и TKP. Почему мы это сделали?

Это сделано потому, что значения входных параметров не могут быть модифицированы, они только для чтения.

Мы должны быть уверены в том, что наш советник будет корректно работать со всеми брокерами. Для определения точности цены котировок по текущему символу графика можно воспользоваться

Предопределенной переменной _Digits или функцией Digits(). Для 3-х и 5-ти значных котировок мы умножаем значения Stop Loss и Take Profit на 10.

2.4. Раздел деинициализации советника

Поскольку эта функция вызывается при прекращении работы советника или удалении советника с графика, здесь мы освобождаем хэндлы индикаторов, созданные в процессе инициализации. Мы создали два индикатора, ADX и Moving Average.

Для их удаления мы используем функцию IndicatorRelease(). Эта функция имеет лишь один параметр (хэндл индикатора).

bool  IndicatorRelease(
   int       indicator_handle,     // хэндл индикатора
   );

Функция удаляет хэндл индикатора и освобождает расчетную часть индикатора, если ею больше никто не пользуется.

2.5 Раздел OnTick советника

Первое, что мы здесь делаем — проверяем достаточно ли баров на текущем графике. Количество баров на любом графике можно узнать при помощи функции Bars. У нее есть два входных параметра, первый — symbol, (символ текущего графика можно получить используя предопределенную переменную _Symbol или функцию Symbol()) и period  или timeframe  текущего графика (для текущего графика  — предопределенная переменная _Period или функция Period()).

При количестве баров на графике менее 60, наш советник не будет работать и выйдет из функции OnTick. Функция Alert показывает сообщение в отдельном окне. Эта функция выводит значения аргументов/параметров, разделенных запятыми. В нашем случае выводится только одно значение в виде строки и завершается работа функции OnTick.

void OnTick()
  {

   if(Bars(_Symbol,_Period)<60) 
     {
      Alert("На графике меньше 60 баров, советник не будет работать!!");
      return;
     }





   static datetime Old_Time;
   datetime New_Time[1];
   bool IsNewBar=false;


   int copied=CopyTime(_Symbol,_Period,0,1,New_Time);
   if(copied>0) 
     {
      if(Old_Time!=New_Time[0]) 
        {
         IsNewBar=true;   
         if(MQL5InfoInteger(MQL5_DEBUGGING)) Print("Новый бар",New_Time[0],"старый бар",Old_Time);
         Old_Time=New_Time[0];   
        }
     }
   else
     {
      Alert("Ошибка копирования времени, номер ошибки =",GetLastError());
      ResetLastError();
      return;
     }


   if(IsNewBar==false)
     {
      return;
     }


   int Mybars=Bars(_Symbol,_Period);
   if(Mybars<60) 
     {
      Alert("На графике менее 60 баров, советник работать не будет!!");
      return;
     }


   MqlTick latest_price;       
   MqlTradeRequest mrequest;    
   MqlTradeResult mresult;      
   MqlRates mrate[];           
   ZeroMemory(mrequest);       

Наш советник должен производить торговые операции только при начале нового бара, поэтому нужно решить задачу определения факта появления нового бара. Другими словами, советник не будет работать на каждом тике, проверка условий и торговля будет производиться только после окончания формирования бара.

Мы начнем с объявления статической переменной Old_Time, в которой будем хранить время бара. Мы определили ее статической, поскольку нам нужно, чтобы ее значение сохранялось при новом вызове функции. Тогда у нас будет возможность проверять ее значение с переменной New_Time, которая также объявлена типа datetime, но в виде массива из одного элемента, она будет использоваться для хранения времени текущего бара. Также мы объявляем переменную IsNewBar типа boolean, и устанавливаем ее значение в false. Ее значение будет установлено в true только в  случае определения факта появления нового бара.

Для получения времени бара используется функция CopyTime. Она копирует время бара в массив New_Time, состоящий из одного элемента. В случае успеха, мы сравниваем значение времени бара с сохраненным ранее временем предыдущего бара. Если они различны, это означает, что появился новый бар и переменная IsNewBar устанавливается в true, а значение текущего времени бара сохраняется в переменной Old_Time.

Таким образом, переменная IsNewBar будет указывать на факт появления нового бара. Если ее значение равно false, мы завершаем выполнение функции OnTick.

Обратите внимание на строчку:

if(MQL5InfoInteger(MQL5_DEBUGGING)) Print("Новый бар",New_Time[0],"старый бар",Old_Time);

здесь проверяется исполнение советника в режиме отладки, если он запущен в отладчике, будет выводится сообщение о значениях времен баров, режим отладки мы рассмотрим позже.

Следующее, что мы собираемся cделать — проверить наличие достаточного количества баров для работы. Зачем делать это снова?

Мы хотим быть уверены в том, что наш советник работает корректно.

Следует отметить, что функция OnInit вызывается только один раз при присоединении советника к графику, а функция OnTick вызывается каждый раз при поступлении нового тика (ценовой котировки).

Как можно видеть, мы это делаем по-другому. Мы сохраняем общее количество баров в истории в новой переменной Mybars, определенной внутри функции OnTick:

   int Mybars=Bars(_Symbol,_Period);

Этот тип переменной является локальной переменной, в отличие от переменных, декларированных в разделе входных параметров нашего кода.

Глобальные переменные доступны для всех функций советника, локальные переменные определяются внутри функций, их видимость ограничена лишь функцией, внутри которой они декларированы. Они не могут быть использованы вне функции.

Далее мы определили несколько переменных типа структур MQL5, которые будут использованы в данном разделе нашего советника. В языке MQL5 есть множество готовых структур, что значительно облегчает жизнь разработчикам советников. Давайте последовательно рассмотрим их.

MqlTick

Эта структура используется для хранения последних цен по символу.

struct MqlTick
  {
   datetime     time;          // Время последнего обновления цен
   double       bid;           // Текущая цена Bid
   double       ask;           // Текущая цена Ask
   double       last;          // Текущая цена последней сделки (Last)
   ulong        volume;        // Объем для текущей цены Last
  };

Любая переменная, объявленная типа может быть легко использована для получения текущих значений цен Ask, Bid, Last и Volume, достаточно вызвать функцию SymbolInfoTick.

Мы объявили переменную latest_price как структуру MqlTick, так что мы можем использовать ее для получения цен Bid и Ask.

MqlTradeRequest

Эта структура используется в запросах на проведение торговых операций. Она содержит все поля, необходимые для заключения торговых сделок.

struct MqlTradeRequest
  {
   ENUM_TRADE_REQUEST_ACTIONS    action;       // Тип выполняемого действия
   ulong                         magic;        // Идентификатор magic number эксперта
   ulong                         order;        // Тикет ордера
   string                        symbol;       // Имя торгового инструмента
   double                        volume;       // Запрашиваемый объем сделки в лотах
   double                        price;        // Цена
   double                        stoplimit;    // Уровень StopLimit ордера
   double                        sl;           // Уровень Stop Loss ордера
   double                        tp;           // Уровень Take Profit ордера
   ulong                         deviation;    // Максимально приемлемое отклонение от запрашиваемой цены
   ENUM_ORDER_TYPE               type;          // Тип ордера
   ENUM_ORDER_TYPE_FILLING       type_filling;  // Тип ордера по исполнению
   ENUM_ORDER_TYPE_TIME          type_time;     // Тип ордера по времени действия
   datetime                      expiration;    // Срок истечения ордера (для ордеров типа ORDER_TIME_SPECIFIED)
   string                        comment;       // Комментарий к ордеру
  };

Любая переменная, объявленная как структура MqlTradeRequest может быть использована для отправки запросов на совершение торговых операций. В нашем случае мы объявили переменную mrequest как структуру MqlTradeRequest.

MqlTradeResult

Результат выполнения торговой операции возвращается в специальную предопределенную структуру типа MqlTradeResult. Любая переменная типа MqlTradeResult может быть использована для доступа к результату выполнения торгового запроса.

struct MqlTradeResult
  {
   uint     retcode;          // Код результата операции
   ulong    deal;             // Тикет сделки, если она совершена
   ulong    order;            // Тикет ордера, если он выставлен
   double   volume;           // Объем сделки, подтверждённый брокером
   double   price;            // Цена в сделке, подтверждённая брокером
   double   bid;              // Текущая рыночная цена Bid
   double   ask;              // Текущая рыночная цена Ask
   string   comment;          // Комментарий брокера к операции (по умолчанию заполняется расшифровкой)
  };

В нашем случае переменная mresult объявлена как структура тип MqlTradeResult.

MqlRates

Цены (Open, Close, High, Low), время, объем каждого бара, и спред символа хранятся в этой структуре. Любой массив, определенный как массив типа MqlRates может быть использован для хранения значений цен, объемов и спредов по символу.

Для наших целей мы определили массив mrate[], который будет использоваться для хранения этой информации.

   ArraySetAsSeries(mrate,true);

   ArraySetAsSeries(plsDI,true);

   ArraySetAsSeries(minDI,true);

   ArraySetAsSeries(adxVal,true);

   ArraySetAsSeries(maVal,true);

Здесь мы устанавливаем индексацию как в таймсериях для всех массивов, которые будут использоваться нами. Это позволит нам быть уверенными в том, что скопированные массивы будут иметь нумерацию как в таймсериях (справа налево т.е. 0, 1, 2, 3 и т.д.). Это производится при помощи функции ArraySetAsSeries().

bool  ArraySetAsSeries(
   void  array[],     // массив по ссылке
   bool  set          // true означает обратный порядок индексации
   );

Следует отметить, что это можно сделать однократно в функции инициализации советника. Тем не менее, для последовательности изложения я решил рассмотреть этот вопрос здесь.

   if(!SymbolInfoTick(_Symbol,latest_price))
     {
      Alert("Ошибка получения последних котировок - ошибка:",GetLastError(),"!!");
      return;
     }

Мы используем функцию SymbolInfoTick для получения текущих котировок. Эта функция имеет два аргумента — символ графика и структура типа MqlTick (latest_price). Снова, проверяем корректность выполнения функции и выводим сообщение в случае ошибки.

   if(CopyRates(_Symbol,_Period,0,3,mrate)<0)
     {
      Alert("Ошибка копирования исторических данных - ошибка:",GetLastError(),"!!");
      return;
     }

Затем, при помощи функции CopyRates мы копируем информацию последних трех баров в массив типа MqlRates. Функция CopyRates используется для получения исторических данных по указанному символу, периоду и запрашиваемому количеству данных, которые затем помещаются  в массив типа MqlRates.

int  CopyRates(
   string           symbol_name,       // имя символа
   ENUM_TIMEFRAMES  timeframe,         // период
   int              start_pos,         // откуда начнем
   int              count,             // количество данных для копирования
   MqlRates         rates_array[]      // массив, куда будут скопированы данные
   );

Имя символа и текущий таймфрей получаем используя предопределенные переменные _Symbol и _Period. Начиная с текущего бара Bar 0, имеющего индекс 0, мы возьмем только три бара: Bars 0, 1, и 2. Результат будет помещен в наш массив mrate[].

Массив mrate[] теперь содержит все данные по ценам, времени, объемам и спредам для баров 0, 1 и 2. Поэтому для того, чтобы получить нужное свойство любого бара, мы используем выражение типа:

например, для каждого из этих баров:

В этом коде мы убеждаемся в том, что дальнейшие условия проверки условий для проведения торговых операций производятся только при начале формирования нового бара. Новый бар характеризуется величиной тикового объема, равной 1, если он больше 1, то выполнение функции OnTick завершается.

Далее, используя функцию CopyBuffer, мы копируем значения индикаторов в динамические массивы:

int  CopyBuffer(
   int       indicator_handle,     
   int       buffer_num,           
   int       start_pos,            
   int       count,                
   double    buffer[]              
   );

В качестве хэндла индикатора указывается хэндл, полученный в функции OnInit. Что касается номеров буферов индикатора, то индикатор ADX имеет 3 (три) буфера:

• 0 — MAIN_LINE,
  
• 1 — PLUSDI_LINE,
• 2 — MINUSDI_LINE. 

Индикатор The Moving Average имеет только 1 (один) буфер:

• 0 – MAIN_LINE.

Начиная с текущего бара (0), мы копируем также еще два бара. Таким образом, полное количество баров равно 3 (бары 0-й,1-й и 2-й). Массив buffer[] в параметре функции CopyBuffer, это массив, куда будут помещены данные. В нашем случае это динамические массивы adxVal, plsDI, minDI и maVal.

   if(CopyBuffer(adxHandle,0,0,3,adxVal)<0 || CopyBuffer(adxHandle,1,0,3,plsDI)<0
      || CopyBuffer(adxHandle,2,0,3,minDI)<0)
     {
      Alert("Ошибка копирования буферов индикатора ADX - номер ошибки:",GetLastError(),"!!");
      return;
     }
   if(CopyBuffer(maHandle,0,0,3,maVal)<0)
     {
      Alert("Ошибка копирования буферов индикатора Moving Average - номер ошибки:",GetLastError());
      return;
     }

Как видно, мы должны отслеживать любые ошибки, которые могут произойти в процессе копирования, вывести соответствующее сообщение и завершить работу функции в случае ошибки, поскольку в таком случае нет смысла продолжать исполнение функции.

Важно отметить, что функции CopyBuffer() and the CopyRates() возвращают общее количество скопированных данных или -1 в случае ошибки. Вот почему мы проверяем возвращаемые значения, они будут меньше 0 в случае ошибки.

Теперь мы должны проверить, есть ли в данный момент открытые позиции, иными словами, мы не будем открывать новых позиций на покупку в случае наличия длинной позиции, и позиции на продажу, если короткая позиция уже открыта.

Для того, чтобы реализовать это, сначала объявим две переменные типа boolean (Buy_opened и Sell_opened), которые будут установлены в TRUE в случае наличия соответствующих открытых позиций.

    bool Buy_opened=false;  //  
    bool Sell_opened=false; 
    
    if (PositionSelect(_Symbol) ==true)  
    {
         if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
         {
            Buy_opened = true;  
         }
         else if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
         {
            Sell_opened = true; 
         }
    }

Для того, чтобы узнать наличие открытой позиции, мы использовали функцию PositionSelect, которая возвращает TRUE в случае наличия открытой позиции по указанному символу и FALSE при отсутствии открытой позиции.

bool  PositionSelect(
   string  symbol      
   );

В качестве основного аргумента функции передается наименование символа, наличие позиции по которому следует проверить. Здесь для имени символа мы использовали предопределенную переменную _Symbol.

В случае, если функция вернула TRUE (позиция существует), мы хотим проверить ее тип (покупка или продажа). Для этого мы используем функцию PositionGetInteger, она возвращает тип открытой позиции, в случае, если в качестве параметра задан запрос свойства POSITION_TYPE. В результате возвращается одно из значений перечисления  ENUM_POSITION_PROPERTY_INTEGER: POSITION_TYPE_BUY или POSITION_TYPE_SELL.

long  PositionGetInteger(
   ENUM_POSITION_PROPERTY  property_id    
   );

В нашем случае, мы используем это для того, чтобы определить факт наличия уже открытой позиции. Если открыта позиция на продажу, мы устанавливаем значение переменной Sell_opened в TRUE, если открыта позиция на покупку, мы устанавливаем значение переменной Buy_opened в TRUE. В дальнейшем мы используем значения этих переменных при проверке условий открытия позиций.

Теперь пришло время поместить цену закрытия бара в переменную, которую мы будем использовать для проверки условий торговли. Вспомним, что переменная p_close была определена ранее.

p_close=mrate[1].close;  

После того, как это сделано, перейдем к следующему шагу.

   bool Buy_Condition_1 = (maVal[0]>maVal[1]) && (maVal[1]>maVal[2]); 
   bool Buy_Condition_2 = (p_close > maVal[1]);         
   bool Buy_Condition_3 = (adxVal[0]>Adx_Min);          
   bool Buy_Condition_4 = (plsDI[0]>minDI[0]);          


   if (Buy_Condition_1 && Buy_Condition_2)
     {
      if(Buy_Condition_3 && Buy_Condition_4)
        {
         
         if (Buy_opened) 
         {
            Alert("Уже есть позиция на покупку !!!");
            return; 
         }
         mrequest.action = TRADE_ACTION_DEAL;                                 
         mrequest.price = NormalizeDouble(latest_price.ask,_Digits);          
         mrequest.sl = NormalizeDouble(latest_price.ask - STP*_Point,_Digits); 
         mrequest.tp = NormalizeDouble(latest_price.ask + TKP*_Point,_Digits); 
         mrequest.symbol = _Symbol;                                         
         mrequest.volume = Lot;                                            
         mrequest.magic = EA_Magic;                                        
         mrequest.type = ORDER_TYPE_BUY;                                     
         mrequest.type_filling = ORDER_FILLING_FOK;                          
         mrequest.deviation=100;                                           
         
         OrderSend(mrequest,mresult);

Рассмотрим условия покупки.

Отметим, что выражения, приведенные выше, соответствуют стратегии, которая обсуждалась ранее. Мы объявили переменные типа bool для каждого из условий, которые должны быть выполнены перед установкой ордера. Переменные типа bool могут принимать только одно из значений: TRUE или FALSE.

Поэтому, наша стратегия на покупку может быть представлена как одновременное выполнение четырех условий. Если условие выполнено, то соответствующая переменная примет значение TRUE, иначе FALSE. Рассмотрим подробнее каждое из условий.

bool Buy_Condition_1 = (maVal[0]>maVal[1]) && (maVal[1]>maVal[2]);

Здесь мы проверяем значение скользящей средней MA-8 на барах 0, 1 и 2. Если значение MA-8 на текущем баре больше, чем на предыдущем (бар 1), и при этом значение MA-8 на баре 1 больше, чем на баре 2, это означает, что скользящая средняя MA-8 возрастает. Это одно из условий покупки.

bool Buy_Condition_2 = (p_close > maVal[1]); 

Это выражение — проверка факта, является ли цена закрытия бара 1 (предыдущий завершенный бар) больше, чем значение скользящей средней MA-8 того же периода (периода бара 1). Если цена закрытия выше, значит второе наше условие выполняется. Если оба этих условий не выполнены, в принципе не имеет смысла проверять следующие.

bool Buy_Condition_3 = (adxVal[0]>Adx_Min);

Теперь мы хотим проверить, является ли значение ADX (ADX для бара 0), больше, чем минимальное значение, указанное во входных параметрах советника. Если это условие выполнено, это означает, что текущее значение ADX больше минимального необходимого, также нам нужно убедиться в том, что значение plusDI больше, чем minusDI. Это производится следующим выражением:

bool Buy_Condition_4 = (plsDI[0]>minDI[0]);

Если все эти условия соблюдаются, то в случае наличия открытой позиции на покупку сообщаем о ее наличии и завершаем выполнение функции. Если нет открытой длинной позиции, для отправки торгового запроса мы подготавливаем переменную mrequest типа MqlTradeRequest, которая была объявлена ранее.

• Поле action, являющееся типом торговой операции задается как TRADE_ACTION_DEAL, поскольку мы помещаем ордер в режиме немедленного исполнения. Для модификации ранее установленного отложенного ордера нужно указать TRADE_ACTION_MODIFY, для его удаления — TRADE_ACTION_REMOVE. Для цены открытия ордера мы используем значение поля Ask структуры latest_price. Значение цены Stop Loss получается вычистанием из цены Ask заданного значения StopLoss в пунктах. Цена Take Profit вычисляется прибавлением заданного значения TakeProfit в пунктах. Как видно, при указании цен мы использовали функцию NormalizeDouble, которая округляет числа до заданной точности — при отправке запроса на торговый сервер следует указывать нормализованные цены.
  
• В поле symbol указывается текущий символ (_Symbol или Symbol()),
• В поле type — тип ордера, здесь ORDER_TYPE_BUY. Для ордера на продажу нужно указать тип ORDER_TYPE_SELL.
• В поле type_filling — тип  исполнения ордера, значение ORDER_FILLING_FOK означает что сделка должна быть выполнена в указанном объеме по указанной (или лучше) цене. Если на рынке отсутствует возможность исполнить указанный объем, ордер не будет выполнен.

У функции OrderSend() два аргумента — переменные типа  MqlTradeRequest и MqlTradeResult.

bool  OrderSend(
   MqlTradeRequest&  request      // структура запроса
   MqlTradeResult&   result       // структура ответа
   );

Как видно, мы использовали наши переменные mrequest и mresult в качестве аргументов функции OrderSend().

         
         if(mresult.retcode==10009 || mresult.retcode==10008) 
           {
            Alert("Ордер Buy успешно помещен, тикет ордера #:",mresult.order,"!!");
           }
         else
           {
            Alert("Запрос на установку ордера Buy не выполнен - код ошибки:",GetLastError());
            return;
           }

После отправки ордера, мы теперь используем значение переменной mresult для проверки результата. Если наш ордер был успешно выполнен, нужно дать об этом знать, также в случае ошибки также нужно информировать о результате. Доступ к коду ошибки и номеру ордера можно получить, используя поля mresult.retcode и mresult,order соответственно.

Код возврата торгового сервера 10009 означает, что запрос OrderSend был успешно выполнен, а код 10008 показывает, что ордер помещен в очередь на исполнение. Поэтому мы должны проверить любой из этих вариантов — в таком случае мы уверены в том, что ордер был выполнен или помещен в очередь на исполнение.

Для проверки условий для продажи, мы производим проверку, противоположную той, которая была для покупки, за исключением того, что DI- должен быть больше, чем DI+.

   bool Sell_Condition_1 = (maVal[0]<maVal[1]) && (maVal[1]<maVal[2]);  
   bool Sell_Condition_2 = (p_close <maVal[1]);                         
   bool Sell_Condition_3 = (adxVal[0]>Adx_Min);                         
   bool Sell_Condition_4 = (plsDI[0]<minDI[0]);                         
   
 
   if (Sell_Condition_1 && Sell_Condition_2)
       {
         if (Sell_Condition_3 && Sell_Condition_4)
           {
            
            if (Sell_opened) 
            {
               Alert("Уже есть позиция на продажу!!!");
               return; 
            }
            mrequest.action = TRADE_ACTION_DEAL;                                
            mrequest.price = NormalizeDouble(latest_price.bid,_Digits);          
            mrequest.sl = NormalizeDouble(latest_price.bid + STP*_Point,_Digits); 
            mrequest.tp = NormalizeDouble(latest_price.bid - TKP*_Point,_Digits); 
            mrequest.symbol = _Symbol;                                         
            mrequest.volume = Lot;                                            
            mrequest.magic = EA_Magic;                                        
            mrequest.type= ORDER_TYPE_SELL;                                     
            mrequest.type_filling = ORDER_FILLING_FOK;                          
            mrequest.deviation=100;                                           
            
            OrderSend(mrequest,mresult);

Точно так же, в разделе выше, мы объявили переменные типа bool для каждого из условий, которые должны удовлетворяться для помещения ордера на продажу. Поэтому торговая стратегия для продажи также состоит из четырех условий. Если условие выполняется, соответствующая переменная устанавливается в TRUE, иначе FALSE. Как и для случая с покупкой, рассмотрим их подробней.

   bool Sell_Condition_1 = (maVal[0]<maVal[1]) && (maVal[1]<maVal[2]);

Здесь мы проверяем значения MA-8 для баров 0, 1 и 2. Если значение MA-8 текущего бара (0) меньше, чем значение предыдущего бара 1, а также MA-8 для бара 1 меньше, чем значение для бара 2, это значит, что MA-8 падает. В этом случае одно условий для продажи удовлетворяется.

   bool Sell_Condition_2 = (p_close <maVal[1]); 

В этом выражении проверяется условие того, что цена закрытия меньше чем значение MA-8 соответствующего бара (бара 1). Если цена закрытия меньше значения скользящей средней, это значит второе условие удовлетворяется. Затем проверяются следующие условия.

   bool Sell_Condition_3 = (adxVal[0]>Adx_Min); 

Здесь проверяется условие того, что текущее значение ADX (бара 0) больше чем значение, указанное во входных параметрах советника. Также нужно проверить условие того, что значение MinusDI больше, чем plusDI. Это делается следующим образом:

bool Sell_Condition_4 = (plsDI[0]<minDI[0]);

Если одновременно выполняются все эти условия, подготавливаем запрос на продажу тем же способом, как и в случае покупки.

Главное отличие в способе вычисления цен Stop Loss и Take Profit. Поскольку производится продажа, используется Bid цена, которая была получена ранее в структуру latest_price. Также здесь указан другой тип ордера — ORDER_TYPE_SELL.

Аналогично, мы используем функцию NormalizedDouble для цены ордера и цен StopLoss и TakeProfit — всегда нужно использовать нормализованные цены при отсылке запроса на торговый сервер.

Так же, как и для ордеров Buy, мы должны проверить результат торгового запроса. Мы используем тот же код, как и для случая покупки.

         
         if(mresult.retcode==10009 || mresult.retcode==10008) 
           {
            Alert("Ордер Sell успешно помещен, тикет ордера #:",mresult.order,"!!");
           }
         else
           {
            Alert("Запрос на установку ордера Sell не выполнен - код ошибки:",GetLastError());
            return;
           }

3. Отладка и тестирование советника

В этом разделе мы разберем, как можно проверить работает ли наша стратегия или нет. Также возможно, что в коде советника могут быть и ошибки, есть возможность отлаживать работу программ на MQL5.

3.1 Отладка

Режим отладки позволяет нам увидеть построчное исполнение нашего кода (если мы установили точки останова, breakpoints) и затем, в случае ошибок быстро сделать необходимые правки перед тем, как использовать его в реальной торговле.

Далее мы рассмотрим процесс отладки советника, сначала без установки точек останова, затем с ними. Для этого, нужно в редакторе выбрать таймфрейм, на котором будет производится отладка нашего советника. В меню «Сервис» главного меню нужно выбрать «Настройки…»:

Рисунок 8. Настройка параметров отладки

После появления окна «Параметры», выберите валютную пару, нужный период/таймфрейм и нажмите кнопку OK:

Рисунок 9. Установка параметров отладки

Перед тем, как начать отладку установим точки останова. Точки останова позволяют нам следить за работой определенных строк кода. В отличие от обычного запуска программы, при отладке в случае наличия точек останова отладчик остановит работу, ожидая дальнейших действий. Таким образом мы способны проанализировать работу нашего кода и следить за  текущими значениями переменных в каждой из точек останова для того, чтобы проверить, работает ли все так, как следует.

Для того, чтобы добавить точку останова, нужно перейти к строке, на которой нужно остановиться. В левой части редактора, рядом с границей редактора кода, нужно дважды кликнуть мышкой, при этом появится маленький голубой круг с белым квадратом внутри (рис. 10). Альтернативным вариант добавления точки останова — перейти на строку и нажать клавишу F9. Для того, чтобы убрать точку останова следует повторно нажать F9, либо дважды кликнуть по кругу.

Рисунок 10. Ставим точку останова

В нашем коде мы собираемся установить точки останова на 5 различных строк кода. 

Для удобства описания, они пронумерованы от 1 до 5.

Установим эти 5 точек останова на строки, указанные на рис. 11. Точку останова 1 мы установили ранее.

Рисунок 11. Установка дополнительных точек останова

Мы закончили установку точек останова, теперь время начать отладку нашего кода.

Для начала запуска режима отладки, нажмите клавишу F5 или зеленкую кнопку в панели инструментов редактора MetaEditor:

Рисунок 12. Запуск отладчика

Сначала редактор откомпилирует код, если при компиляции не возникло ошибок, он покажет их в отчете во вкладке «Ошибки»:

Рисунок 13. Отчет компиляции

Имейте ввиду, что факт успешной компиляции не означает отсутствия ошибок в коде. В зависимости от того, как написан ваш код, могут возникать ошибки времени выполнения (runtime errors). Например, некоторые выражения могут компилироваться правильно, но работать неверно. Давайте лучше посмотрим режим отладки в работе.

После того, как компиляция кода завершена, отладчик передает управление клиентскому терминалу и присоединяет советник к графику, который был указан в настройках отладчика MetaEditor. В то же время, он показывает входные параметры советника. Поскольку нашей целью не является улучшение параметров, нажмем кнопку OK.

Рисунок 14. Установка входных параметров советника для отладки

В левом верхнем углу графика видно, что советник присоеден к графику.

При запуске функции OnTick(), произойдет остановка работы советника, он остановится в точку останова 1.

Рисунок 15. Режим отладки: остановка работы советника в первой точке останова

Об этом свидетельствует зеленая стрелка в строке. Она говорит нам о том, что предыдущая строка была выполнена, теперь будет выполнена текущая строка.

Перед тем, как продолжить, имеет смысл познакомиться с командами отладчика. Если посмотреть на панель инструментов редактора MetaEditor, можно увидеть, что теперь стали доступны три кнопки, которые ранее были серого цвета. Причина этого в том, что теперь мы находимся в режиме отладки. Эти три команды используются для исполнения в режиме отладки (Step into, Step over, Step out)»

Рисунок 16. Режим отладки: команда «Step into» (Шаг с заходом)

Команда Step Into (Шаг с заходом) переходит к следующему шагу, при этом производится заход внутрь любой вызываемой функции в коде. Для исполнения данной команды, нажмите эту кнопку или клавишу F11. Далее мы будем использовать данную команду при пошаговой отладке нашего кода.

Рисунок 17. Режим отладки: команда «Step over» (Шаг с обходом)

Команда Step over (Шаг с обходом), в свою очередь, не производит заход отладчика в функции, которые вызываются в коде. Для исполнения данной команды нужно нажать эту кнопку или клавишу F10.

Рисунок 18. Режим отладки: команда «Step out» (Шаг наружу)

Для перехода к выполнению одного шага программы на один уровень выше есть команда Step Out (Шаг наружу), которая вызывается нажатием на соответствующую кнопку или комбинацией клавиш Shift+F11.

В нижней части редактора, вы видите окно «Инструменты»(Toolbox). Вкладка «Отладка» содержит следующие колонки:

• Файл : Имя файла, с которым производится работа.
• Функция : Имя функции, которая вызывается в настоящий момент.
  
• Строка : Номер строки кода.
• Выражение : В этой колонке вы можете указать любое выражение или переменную, за значениями которых вы желаете наблюдать в процессе выполнения программы.
  
• Значение : В этой колонке показываются текущие значения указанных выражений/переменных.
• Тип : В данной колонке показан тип данных, для которых установлен режим наблюдения.

Вернемся к процессу отладки…

Следущий шаг, который мы хотим сделать, указать переменные/выражения нашего кода, за которыми мы хотели бы провести наблюдение. Мы будем смотреть за значениями следующих переменных:

• Old_Time (старое время бара)
• New_Time[0] (время текущего бара)
• copied (количество скопированных данных времени)
• IsNewBar (флаг, показывающий появление нового бара)
• Mybars (полное количество баров в истории) – наш советник использует это значение

Также можно добавить в мониторинг и другие переменные, например значения технических индикаторов ADX, MA-8 и т.д.

Для добавления выражения/переменной в список наблюдаемых, дважды щелкните на колонке «Выражение» или используйте пункт «Добавить» контекстного меню и укажите наименование переменных или выражения, которые нужно включить в режим наблюдение

Рисунок 19. Монитор выражений

Укажите переменные/выражения для наблюдения:

Рисунок 20. Добавление выражений или переменных для наблюдения

Идем дальше…

Рисунок 21. Конманда «Step into» (Шаг с заходом) в действии

Нажмите кнопку Шаг с заходом или клавишу F11, и посмотрим, что происходит. Нажимая эту кнопку или клавишу F11, пройдите последовательно по точкам останова и понаблюдайте за значениями выражений в окне мониторинга выражений.

Рисунок 22. Наблюдение за выражениями или переменными

Рисунок 23. Наблюдение за выражениями или переменными

Рисунок 24. Наблюдение за выражениями или переменными

При наступлении нового тика, мы заходим в функцию OnTick(). В случае объявления переменных статическими, переменные останутся декларированными, их значения сохраняться.при новом вызове функции OnTick мы будем наблюдать следующее:

Рисунок 25. Значения переменных при новом вызове функции OnTick

Теперь запустим программу снова, на этот раз без точек останова. 

Рисунок 26. В режиме отладки при новом баре советник выводит сообщение

При каждом баре программа будет проверять условия на покупку/продажу, при наступлении условий будет производиться торговля и выводиться сообщение о результатах выполнения торговой операции:

Рисунок 27. Торговля советника

Я думаю, можно оставить советник поработать еще несколько минут и попить кофе. Вернувшись обратно и сделав немного денег (шутка), нажмите красную кнопку Stop в MetaEditor для остановки процесса отладки.

Рисунок 28. Остановка режима отладки

Мы убедились, что наш советник работает, однако отметим, что клиентский терминал должен быть подключен к Интернет, в противном случае, он не будет работать.

3.2 Тестируем стратегию нашего советника

Теперь мы хотим проверить нашего советника используя встроенный Тестер стратегий клиентского терминала. Для запуска Тестера Стратегий нажмите клавишу Ctrl-R или выберите пункт «Тестер стратегий» в меню «Вид» главного меню, как показано на рисунке 26:

Рисунок 29. Запуск Тестера стратегий

Окно тестера стратегий появится в нижней части клиентского терминала. Для того, чтобы увидеть настройки Тестера стратегий, нужно увеличить его окно. Для этого передвиньте указатель мыши в точку, отмеченную на рисунке 27:

Рисунок 30. Окно Тестера стратегий

Указатель мыши изменит свой вид, превратившись в двойные стрелки, удерживая мышь, нужно увеличить окно Тестера до высоты, при которой все его настройки видны.

Рисунок 31. Вкладка «Настройки» Тестера

1. Выберите советника, который нужно протестировать.
   
2. Выбор валютной пары для тестирования.
   
3. Выбор периода/таймфрейма для тестирования (выберем H2).
   
4. Выберите «Select Custom» чтобы производить тестирование на указанном историческом интервале.
   
5. Выбор дат начала и окончания тестирования.
   
6. Выберем режим торговли «Обычный».
   
7. Выбор начального депозита для тестирования.
   
8. Не будем использовать оптимизицию параметров советника (Отключена)
   
9. Нажмите кнопку «Старт», когда будете готовы начать тестирование.
   

Перед тем, как нажать кнопку «Старт», посмотрим на другие вкладки Тестера.

Вкладка «Агенты»

В процессе тестирования могут использоваться агенты (локальные и удаленные), их количество определяется количеством ядер процессора (если другие компьютеры не используются) и настройками удаленных агентов, если используются сетевые компьютеры.

Рисунок 32. Вкладка «Агенты» Тестера стратегий

Для одного агента в процессе тестирования вкладка «Агенты» имеет вид:

Рисунок 33. Агенты Тестера стратегий в процессе тестирования

Вкладка «Журнал»

В этой вкладке показываются все события, которые происходят в течение процесса тестирования.

Рисунок 34. Вкладка «Журнал» Тестера стратегий показывает активность советника при тестировании

Вкладка «Входные параметры»

Здесь можно указать входные параметры советника.

Рисунок 35. Вкладка «Входные параметры» советника в Тестере стратегий

Если используется оптимизация параметров при тестировании, нужно указать значения переменных, выделенных на рис. 31.

• Старт — начальное значение параметра
• Шаг — шаг изменения параметра
  
• Стоп — конечное значение параметра для тестера.

Тем не менее, в нашем советнике мы не будем производить поиск оптимальных параметров, поэтому нам они не нужны.

После того, как все установлено, вернемся обратно во вкладку «Настройки» и нажмем кнопку «Старт». Тестер начнет свою работу. Все, что нужно сейчас — это подготовить еще одну кружку кофе, если же вы, как и я, хотите наблюдать за процессом, откройте вкладку «Журнал», в процессе тестирования там появятся сообщения о запросах и результатах проведения торговых операций.

Вкладка «График»

После ознакомления с содержимым вкладки «Журнал» можно посмотреть на новую вкладку «График», которая появилась в процессе тестирования. При переключении на вкладку «График» вы увидите график, показывающий увеличение и уменьшение баланса, в зависимости от результатов торговли в истории.

Рисунок 36. График результатов тестирования

Вкладка «Результаты»

После завершения тестирования появится другая вкладка, называемая «Результаты» тестирования. Переключившись во вкладку результаты, вы увидите отчет о проведенном тестировании.

Рисунок 37. Отчет результатов Тестера стратегий

Видны чистая прибыль, общая прибыль, общее количество сделок, кол-во убыточных сделок и другие. 

Нажав правую кнопку мыши во вкладке «Результаты», вы увидите контектное меню. Выберите пункт «Сохранить как отчет«:

Рисунок 38. Сохранение результатов тестирования

Появится диалог сохранения файла, напишите имя файла для отчета (если хотите, можно использовать имя, преложенное по умолчанию) и нажимте кнопку «Сохранить». Полный отчет будет сохранен в файле формата HTML.

Для того, чтобы увидеть результаты торговли на графике, выберите пункт «Открыть график» и увидите график вида:

Рисунок 39. График с результатами тестирования на истории

Мы успешно написали и протестировали наш советник на истории и теперь имеем заготовку для дальнейшей работы. Можно опять вернуться во вкладку «Настройки» Тестера стратегий и протестировать его на другом временном интервале.

Интересно посмотреть, как он покажет себя на различных парах и таймфреймах, буду рад, если вы поделитесь со мной результатами.

Выводы

В этом пошаговом руководстве мы смогли рассмотреть основные шаги, необходимые для написания простого советника, основанного на заданной торговой стратегии. Мы рассмотрели, как можно проверить работу советника на наличие ошибок с использованием отладчика. Также мы обсудили, как протестировать результаты торговли нашего советника, используя Тестер стратегий. Мы смогли увидеть мощь и робастность нового языка MQL5.

Полученный в результате советник пока не является безупречным или завершенным, многие улучшения еще предстоит сделать для его использования в реальной торговле.

Еще многому необходимо научиться, я рекомендую еще раз прочитать эту статью вместе с документацией по MQL5, попробуйте все, чему вы научились в статье, и смею вас заверить, что вскоре в недалеком будущем вы сможете сами писать торговых советников.

Happy coding.

Форекс — торговые стратегии, советники, индикаторы, видео обучение торговле

---

Как самому создать советника или индикатор

Для разработки торговых систем в платформу встроен собственный язык программирования MetaQuotes Language 5 (MQL5), среда разработки MetaEditor и инструменты тестирования стратегий.

Встроенный язык программирования торговых стратегий MQL5 #

В торговую платформу встроен язык программирования торговых стратегий MetaQuotes Language 5. Это — пятое поколение языков MQL. Он позволяет писать советники, автоматизирующие управление торговыми процессами, и реализовывать собственные торговые стратегии. Кроме того, на MQL5 можно создавать пользовательские индикаторы, скрипты и библиотеки функций.

Особенности языка MQL5:

• Объектная ориентированность;
• Синтаксис MQL5 похож на синтаксис языка C++;
• Большое количество функций, необходимых для анализа котировок, управления позициями, вызова технических индикаторов и других;
• Высокая производительность;
• Высокий уровень защиты от декомпиляции: новые, сложные алгоритмы шифрования, проверка целостности файлов и сложность самого языка;
• Поддержка OpenCL, что позволяет использовать видеокарты для выполнения вычисления в MQL5-программах;
• Интегрированная среда разработки программ MetaEditor, включающая отладчик.

Подробное описание всех конструкций языка и функций приведено в справочнике MQL5. Также всю интересующую информацию о MQL5 можно найти на сайте сообщества разработчиков https://www.mql5.com.

Редактор для разработки торговых приложений MetaEditor #

MetaEditor — это интегрированная среда разработки на языке MQL5, он является составной частью торговой платформы. MetaEditor позволяет создавать, редактировать, компилировать и отлаживать исходные тексты программ, написанных на языке MQL5.

• Мастер MQL5 для создания шаблонов и готовых торговых роботов
  В MetaEditor встроен Мастер MQL5, который помогает быстро создавать MQL5-программы. Благодаря Мастеру MQL5, трейдер может создать советники, не обладая знаниями в области программирования. Все что нужно сделать — это выбрать торговые сигналы, которые будет использовать советник, алгоритм мани-менеджмента и трейлинг стопа. Код советника будет сгенерирован автоматически на основе выбранных параметров.
  Помимо этого, Мастер MQL5 позволяет создавать шаблоны MQL5-программ, что облегчает работу программиста.
• Помощь при работе с исходным кодом
  MetaEditor распознает различные конструкции языка: выдает подсказки по использованию функций и подсвечивает различные элементы кода программы. Таким образом, сам редактор облегчает ориентирование в коде торговых программ и ускоряет их разработку.
• Отладка для поиска ошибок
  MetaEditor позволяет осуществлять отладку программ, что значительно облегчает поиск ошибок. Можно пошагово выполнять исходный код и следить за значениями переменных.
• Профилирование для оптимизации кода
  В редакторе также доступна возможность профилирования. Вы сможете выявить наиболее медленные функции в исходном коде и максимально оптимизировать работу торговых программ.
• Статьи о программировании и библиотека исходных кодов
  Прямо в редакторе вы можете найти множество обучающий статей о программировании на MQL5. Помимо этого имеется доступ к огромной библиотеке бесплатных программ для автотрейдинга в виде исходных кодов.
• MQL5 Storage — онлайн хранилище с поддержкой версионности
  Хранилище предоставляет множество преимуществ: безопасное хранение файлов и возможность восстановления при выходе вашего компьютера из строя, доступ к своим кода с любого компьютера при помощи аккаунта MQL5.community, возможность совместной работы над проектами.

Детальное описание MetaEditor дано во встроенной справке по этой программе. Описание языка MQL5 может быть найдено во встроенном справочнике, а также на официальном сайте MQL5.community.

Статьи по разработке торговых приложений #

На сайте MQL5.community доступна обширная библиотека статей по программированию на MQL4/MQL5. Статьи являются отличным справочным материалом по созданию программ, в них рассматривается множество практических задач по алготрейдингу. Новые статьи выходят каждую неделю.

Список всех доступных статей отображается прямо в MetaEditor. Чтобы найти интересующий материал, воспользуйтесь онлайн-поиском.

Какие бывают типы приложений на MQL5 #

Существует три основных типа торговых приложений.

Советники

Советники — механические торговые системы, позволяющие полностью автоматизировать аналитико-торговую деятельность для эффективной работы на финансовых рынках. Они позволяют оперативно проводить технический анализ ценовых данных и на основе полученных сигналов управлять торговой деятельностью. Они также помогают четко придерживаться торговой стратегии, исключив роль эмоционального фактора.

Все советники хранятся в папке /MQL5/Experts торговой платформы.

Пользовательские индикаторы

Пользовательские индикаторы — самостоятельно написанные технические индикаторы, предназначенные для анализа динамики цен. На основе алгоритмов индикаторов строятся торговые тактики и разрабатываются советники. Пользовательские индикаторы предназначены только для анализа динамики цен финансовых инструментов. Индикаторы не могут торговать и не имеют доступа к графикам.

Все индикаторы хранятся в папке /MQL5/Indicators торговой платформы.

Скрипты

Скрипты — скриптом называется программа, написанная на языке MQL5 и предназначенная для одноразового выполнения любых действий. Скрипт может выполнять как аналитические, так и торговые функции. В отличие от советников, скрипты исполняются по запросу. Иными словами, если советник работает практически постоянно, то скрипт, отработав один раз, самостоятельно завершает работу.

Все скрипты хранятся в папке /MQL5/Scripts торговой платформы.

Сервисы

Сервисы позволяют использовать собственные источники ценовых данных для платформы — передавать цены от внешних систем в режиме реального времени так, как это делают торговые серверы брокеров. Также сервисы можно использовать для выполнения других обслуживающих задач в фоновом режиме.

В отличие от советников, индикаторов и скриптов, сервисы не привязаны к конкретному графику. Они работают в фоновом режиме и начинают работу автоматически при запуске терминала (если они не были принудительно остановлены).

Все сервисы хранятся в папке /MQL5/Services торговой платформы.

Как создать и запустить торговое приложение #

Нажмите « Создать в редакторе» в контекстном меню окна «Навигатор» в разделе «Советники», «Индикаторы» или «Скрипты». Также для запуска MetaEditor можно нажать F4.

После этого будет запущен MetaEditor, и в нем автоматически откроется «Мастер MQL5». Он позволит сгенерировать шаблон нужной программы, что быстро приступить к разработке. Для примера создадим простой скрипт, который будет выводить в журнал надпись «Hello world».

В полученном шаблоне напишем код Print(«Hello World»); и произведем компиляцию клавишей F7, чтобы получить исполняемый файл. Исполняемый файл имеет расширение EX5, именно такой файл может быть запущен в торговой платформе.

Результаты компиляции выводятся в журнал редактора.

В соответствии с типом программы, исходный код был сохранен в папку MQL5Scripts. В этой же папке был создан и исполняемый файл. Теперь можно вернуться в торговую платформу и запустить созданный скрипт.

Как изменить торговое приложение #

Чтобы приступить к редактированию торгового робота или пользовательского индикатора, нажмите « Изменить» в его контекстном меню в окне «Навигатор» или выделите его и нажмите «Enter». При этом будет открыт MetaEditor, в который уже будет загружен исходный код выбранного индикатора. После изменения индикатора скомпилируйте его повторно (F7), иначе в платформе будет использоваться предыдущая, неизмененная версия.

Как завершить работу торгового приложения #

Существует множество способов завершить работу торгового приложения в платформе.

Как запустить скачанный файл исходного кода MQ5 #

Если у вас имеется только файл исходного кода (*.MQ5), поместить его в папку, соответствующую типу приложения:

• Для советников — /MQL5/Experts
• Для индикаторов — /MQL5/Indicators
• Для скриптов —/MQL5/Scripts

Чтобы быстро перейти к папке хранения информации торговой платформы, нажмите « Открыть каталог данных» в меню «Файл».

Чтобы запустить файл в торговой платформе, скомпилируйте его в MetaEditor:

• Откройте MetaEditor клавишей F4.
• В MetaEditor в окне «Навигатор» откройте файл исходного кода двойным нажатием на нем левой кнопкой мыши.
• Скомпилируйте его клавишей F7.

В результате вы получите исполняемый файл *.EX5, который уже можно запустить в торговой платформе.

На прошлом уроке мы с вами писали индикатор, который указывает входы в рынок. Соответственно сегодня мы займёмся разработкой эксперта, использующего его сигналы.

Начнём с создания шаблона советника(как это сделать мы разбирали на уроке №10).

Опишем входные параметры эксперта:

extern double Lots       = 0.1;    // объём сделки в лотах
extern int    StopLoss   = 40;     // ограничение убытка в пунктах 
extern int    TakeProfit = 70;     // профит в пунктах
extern int    Magic      = 123;    // магический номер ордеров
extern int    Slippage   = 5;      // проскальзывание в пунктах
extern string comment    = "Мой первый советник";

Значения StopLoss, TakeProfit и Slippage, присвоенные в параметрах, указаны для 4-х значного брокера, соответственно, чтобы эти же значения корректно работали у 5-ти значного ДЦ их нужно умножить на 10, что мы и сделаем в функции OnInit:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   if (Digits == 3 || Digits == 5)
   {
       StopLoss     *= 10;
       TakeProfit   *= 10;
       Slippage     *= 10;
   }
   return(INIT_SUCCEEDED);
}

Начало нашего советника положено, что уже хорошо. Давайте теперь рассмотрим входные параметры индикатора, а заодно и номера буферов для сигналов:

Обычно я просто копирую параметры индикатора в код своего эксперта, в дальнейшем это позволит нам оптимизировать сам советник. В итоге получаем:

//+------------------------------------------------------------------+
extern double Lots            = 0.1; // объём сделки в лотах
extern int    StopLoss        = 40;  // ограничение убытка в пунктах
extern int    TakeProfit      = 70;  // профит в пунктах
extern int    Magic           = 123; // магический номер ордеров
extern int    Slippage        = 5;   // проскальзывание в пунктах
extern string comment         = "Мой первый советник";
//+------------------------------------------------------------------+
extern int    MA_Period       = 100;
extern double MACDOpenLevel   = 5;
extern int    fast_ema_period = 8;   // период быстрой средней 
extern int    slow_ema_period = 16;  // период медленной средней 
extern int    signal_period   = 9;   // период сигнальной линии 
//+------------------------------------------------------------------+

Переходим к функции OnTick и пишем заготовку обработчика, где описываю алгоритм работы эксперта:

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
    if (CountBuy() == 0)
    {
       BuySignal = ...
       
       if (BuySignal > 0)
       {
           CloseSell();

           // Open buy order 
           
       }
    }

    if (CountSell() == 0)
    {
       SellSignal = ...

       if (SellSignal > 0)
       {
           CloseBuy();

           // Open sell order
           
       }
    }
}

Итак, по шагам:

1. if (CountBuy() == 0) — я проверяю есть-ли у меня ордера на покупку, находящиеся в рынке, и если нет, то шаг 2.
2. BuySignal = … — проверяем наличие сигнала на покупку по индикатору, кстати, это будет переменная, которую необходимо объявить заранее.
3. if (BuySignal > 0) — если есть сигнал на покупку, то переходим к шагу 4.
4. CloseSell() — закрываем открытые ордера на продажу, если они есть и переходим к шагу 5.
5. Открываем ордер на покупку.

Точно такой же блок делается и для продаж.

Исходя из написанного алгоритма сразу видно, что предварительно нам потребуется несколько функций: CountBuy(), CountSell(), CloseBuy(), CloseSell(), а также написать код получения сигнала с индикатора.

Объявим в коде несколько переменных для дальнейшей работы и необходимые функции:

double BuySignal, SellSignal,
       SL, TP;
int    ticket;
bool   res;

Функция CountBuy():

//+------------------------------------------------------------------+
//| Функция возвращает количество ордеров на покупку                 |
//| находящихся в рынке                                              |
//+------------------------------------------------------------------+
int CountBuy() 
{  // объявляем переменную, в которой будем хранить количество ордеров
   // с типом OP_BUY 
   int count = 0;

   // Объявляем цикл с перебором ордеров   
   for (int trade = OrdersTotal() - 1; trade >= 0; trade--) 
   {
      // Если удалось выбрать ордер, находящийся в рынке
      if (OrderSelect(trade, SELECT_BY_POS, MODE_TRADES))
      {
         // у этого ордера совпадает валютная пара и его магический номер
         if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
         {
            // а также ордер является ордером на покупку,
            if (OrderType() == OP_BUY) 
            // то увеличиваем значение счётчика count на единицу
               count++;
         }
      }
   }
   // возвращаем количество ордеров на покупку
   return (count);
}

Аналогично пишется функция CountSell(), разве что проверяется тип ордера OP_SELL:

//+------------------------------------------------------------------+
//| Функция возвращает количество ордеров на продажу                 |
//| находящихся в рынке                                              |
//+------------------------------------------------------------------+
int CountSell() 
{
   int count = 0;
   
   for (int trade = OrdersTotal() - 1; trade >= 0; trade--) 
   {
      if (OrderSelect(trade, SELECT_BY_POS, MODE_TRADES))
      {
         if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
         {
            if (OrderType() == OP_SELL) 
               count++;
         }
      }
   }
   return (count);
}
//+------------------------------------------------------------------+

Далее пишем функцию CloseBuy():

//+------------------------------------------------------------------+
//| Фукнция закрывает все ордера на покупку, находящиеся в рынке     |
//+------------------------------------------------------------------+
void CloseBuy()
{
   // объявляем цикл, в котором выполним перебор все ордеров
   // находящихся в рынке
   for(int index = OrdersTotal()-1; index >= 0; index--)
   {
      // если удалось выбрать рыночный ордер
      if (OrderSelect(index, SELECT_BY_POS, MODE_TRADES))
      {
            // если валютная пара ордера, магический номер ордера и тип ордера совпадают
            // с тем, что нам необходимо,
            if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == OP_BUY)
                 // то пробуем закрыть ордер по рыночной цене
                  if (!OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), Slippage, Black))
                     // иначе выводим в журнал регистрации сообщение об ошибке
                     Print("Ошибка закрытия ордера на покупку, ticket = " + DoubleToStr(OrderTicket()));
      }
   }
}

Пишем практически всё то же самое и для закрытия ордеров на продажу, разница лишь в типе проверяемого ордера и цене закрытия, функция CloseSell():

//+------------------------------------------------------------------+
//| Фукнция закрывает все ордера на продажу, находящиеся в рынке     |
//+------------------------------------------------------------------+
void CloseSell()
{
   for(int index = OrdersTotal()-1; index >= 0; index--)
   {
      if (OrderSelect(index, SELECT_BY_POS, MODE_TRADES))
      {
            if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == OP_SELL)
                  if (!OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), Slippage, Black))
                     Print("Ошибка закрытия ордера на продажу, ticket = " + DoubleToStr(OrderTicket()));
      }
   }
}

На текущий момент нам осталось получить сигналы от индикаторы и написать код, открывающий ордера по его сигналам.

Для получения сигнала от любого пользовательского индикатора используется функция iCustom, обратившись к справке (F1) видим формат вызова функции:

Теперь мы можем с легкостью получить сигнал на покупку в нашем советнике:

BuySignal = iCustom(NULL, 0, "MyIndicator", MA_Period, MACDOpenLevel, fast_ema_period, slow_ema_period, signal_period, 0, 1);

заодно и сигнал на продажу:

SellSignal = iCustom(NULL, 0, "MyIndicator", MA_Period, MACDOpenLevel, fast_ema_period, slow_ema_period, signal_period, 1, 1);

кстати, обратите внимание на предпоследний параметр mode, который мы передаём в функцию iCustom — это номер буфера индикатора, где хранятся сигналы покупок и продаж.

Таким образом наша функция OnTick() будет выглядеть следующим образом:

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
    if (CountBuy() == 0)
    {
       // Получаем сигнал на покупку
       BuySignal = iCustom(NULL, 0, "MyIndicator", MA_Period, MACDOpenLevel, fast_ema_period, slow_ema_period, signal_period, 0, 1);
       
       // если есть сигнал индикатора
       if (BuySignal > 0)
       {
           // закрываем открытые ордера SELL
           CloseSell();
           
           // Open buy order
           // открываем ордер на покупку
           ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, comment, Magic, 0, Blue);

           // если ордер был успешно открыт,
           if (ticket > 0)
           {
               // то его необходимо выбрать, для дальнейшей установки ему StopLoss и TakeProfit
               if (OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
               {
                  // рассчитываем StopLoss и нормализуем цену
                  SL = NormalizeDouble(Ask-StopLoss*Point, Digits);

                  // рассчитываем TakeProfit и нормализуем цену
                  TP = NormalizeDouble(Ask+TakeProfit*Point, Digits);
                  
                  // попытаемся установить ордеру рассчитанные уровни StopLoss и TakeProfit
                  res = OrderModify(OrderTicket(), OrderOpenPrice(), SL, TP, 0);
                  if (!res)
                     // и если не удалось, то выведем сообщение в журнал регистрации для дальнейшего анализа причин
                     Print("Ошибка модификации ордера на покупку, ASK=" + DoubleToStr(Ask) + ", SL=" + DoubleToStr(SL) + ", TP=" + DoubleToStr(TP)); 
               }
           }
       }
    }

    if (CountSell() == 0)
    {
       SellSignal = iCustom(NULL, 0, "MyIndicator", MA_Period, MACDOpenLevel, fast_ema_period, slow_ema_period, signal_period, 1, 1);

       if (SellSignal > 0)
       {
           CloseBuy();
           
           ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, comment, Magic, 0, Red);
           if (ticket > 0)
           {
               if (OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
               {
                  SL = NormalizeDouble(Bid+StopLoss*Point, Digits);
                  TP = NormalizeDouble(Bid-TakeProfit*Point, Digits);
                  res = OrderModify(OrderTicket(), OrderOpenPrice(), SL, TP, 0);
                  if (!res)
                     Print("Ошибка модификации ордера на продажу, BID=" + DoubleToStr(Bid) + ", SL=" + DoubleToStr(SL) + ", TP=" + DoubleToStr(TP)); 
               }
           }
       }
    }
}

Собственно говоря, на этом всё, разработка советника на пользовательском индикаторе завершена.

Полный код эксперта:

//+------------------------------------------------------------------+
//|                                                    My_Expert.mq4 |
//|                              Copyright 2017, xbms, http://mql.su |
//|                                              mailto:xbms@mail.ru |
//+------------------------------------------------------------------+
#property copyright "Copyright 2017, xbms"
#property link      "http://mql.su"
#property version   "1.00"
#property strict
//+------------------------------------------------------------------+
extern double     Lots            = 0.1;
extern int        StopLoss        = 40;
extern int        TakeProfit      = 70;
extern int        Magic           = 123;
extern int        Slippage        = 5;
extern string     comment         = "Мой первый советник";
//+------------------------------------------------------------------+
extern int        MA_Period       = 100;
extern double     MACDOpenLevel   = 5;
extern int        fast_ema_period = 8;   // период быстрой средней 
extern int        slow_ema_period = 16;  // период медленной средней 
extern int        signal_period   = 9;   // период сигнальной линии 
//+------------------------------------------------------------------+
double BuySignal, SellSignal,
SL, TP;
int    ticket;
bool   res;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
if (Digits == 3 || Digits == 5)
{
StopLoss     *= 10;
TakeProfit   *= 10;
Slippage     *= 10;
}
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
if (CountBuy() == 0)
{
// Получаем сигнал на покупку
BuySignal = iCustom(NULL, 0, "MyIndicator", MA_Period, MACDOpenLevel, fast_ema_period, slow_ema_period, signal_period, 0, 1);
// если есть сигнал индикатора
if (BuySignal > 0)
{
// закрываем открытые ордера SELL
CloseSell();
// Open buy order
// открываем ордер на покупку
ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, comment, Magic, 0, Blue);
// если ордер был успешно открыт,
if (ticket > 0)
{
// то его необходимо выбрать, для дальнейшей установки ему StopLoss и TakeProfit
if (OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
{
// рассчитываем StopLoss и нормализуем цену
SL = NormalizeDouble(Ask-StopLoss*Point, Digits);
// рассчитываем TakeProfit и нормализуем цену
TP = NormalizeDouble(Ask+TakeProfit*Point, Digits);
// попытаемся установить ордеру рассчитанные уровни StopLoss и TakeProfit
res = OrderModify(OrderTicket(), OrderOpenPrice(), SL, TP, 0);
if (!res)
// и если не удалось, то выведем сообщение в журнал регистрации для дальнейшего анализа причин
Print("Ошибка модификации ордера на покупку, ASK=" + DoubleToStr(Ask) + ", SL=" + DoubleToStr(SL) + ", TP=" + DoubleToStr(TP)); 
}
}
}
}
if (CountSell() == 0)
{
SellSignal = iCustom(NULL, 0, "MyIndicator", MA_Period, MACDOpenLevel, fast_ema_period, slow_ema_period, signal_period, 1, 1);
if (SellSignal > 0)
{
CloseBuy();
ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, comment, Magic, 0, Red);
if (ticket > 0)
{
if (OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES))
{
SL = NormalizeDouble(Bid+StopLoss*Point, Digits);
TP = NormalizeDouble(Bid-TakeProfit*Point, Digits);
res = OrderModify(OrderTicket(), OrderOpenPrice(), SL, TP, 0);
if (!res)
Print("Ошибка модификации ордера на продажу, BID=" + DoubleToStr(Bid) + ", SL=" + DoubleToStr(SL) + ", TP=" + DoubleToStr(TP)); 
}
}
}
}
}
//+------------------------------------------------------------------+
//| Фукнция закрывает все ордера на покупку, находящиеся в рынке     |
//+------------------------------------------------------------------+
void CloseBuy()
{
// объявляем цикл, в котором выполним перебор все ордеров
// находящихся в рынке
for(int index = OrdersTotal()-1; index >= 0; index--)
{
// если удалось выбрать рыночный ордер
if (OrderSelect(index, SELECT_BY_POS, MODE_TRADES))
{
// если валютная пара ордера, магический номер ордера и тип ордера совпадают
// с тем, что нам необходимо,
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == OP_BUY)
// то пробуем закрыть ордер по рыночной цене
if (!OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), Slippage, Black))
// иначе выводим в журнал регистрации сообщение об ошибке
Print("Ошибка закрытия ордера на покупку, ticket = " + DoubleToStr(OrderTicket()));
}
}
} 
//+------------------------------------------------------------------+
//| Фукнция закрывает все ордера на продажу, находящиеся в рынке     |
//+------------------------------------------------------------------+
void CloseSell()
{
for(int index = OrdersTotal()-1; index >= 0; index--)
{
if (OrderSelect(index, SELECT_BY_POS, MODE_TRADES))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic && OrderType() == OP_SELL)
if (!OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), Slippage, Black))
Print("Ошибка закрытия ордера на продажу, ticket = " + DoubleToStr(OrderTicket()));
}
}
} 
//+------------------------------------------------------------------+
//| Функция возвращает количество ордеров на покупку                 |
//| находящихся в рынке                                              |
//+------------------------------------------------------------------+
int CountBuy() 
{  // объявляем переменную, в которой будем хранить количество ордеров
// с типом OP_BUY 
int count = 0;
// Объявляем цикл с перебором ордеров   
for (int trade = OrdersTotal() - 1; trade >= 0; trade--) 
{
// Если удалось выбрать ордер, находящийся в рынке
if (OrderSelect(trade, SELECT_BY_POS, MODE_TRADES))
{
// у этого ордера совпадает валютная пара и его магический номер
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
{
// а также ордер является ордером на покупку,
if (OrderType() == OP_BUY) 
// то увеличиваем значение счётчика count на единицу
count++;
}
}
}
// возвращаем количество ордеров на покупку
return (count);
}
//+------------------------------------------------------------------+
//| Функция возвращает количество ордеров на продажу                 |
//| находящихся в рынке                                              |
//+------------------------------------------------------------------+
int CountSell() 
{
int count = 0;
for (int trade = OrdersTotal() - 1; trade >= 0; trade--) 
{
if (OrderSelect(trade, SELECT_BY_POS, MODE_TRADES))
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
{
if (OrderType() == OP_SELL) 
count++;
}
}
}
return (count);
}
//+------------------------------------------------------------------+

Исходный код советника доступен для скачивания My_Expert.mq4

В качестве примера для обучения решил начать с нуля создание собственного торгового советника. Для пущего привлечения читателей к своему детищу назову его Форекс-Грааль (Forex-Grail), слово «святой» (holy) от греха подальше опущу. Буду стараться делать код удобочитаемым, чтобы в дальнейшем было проще его расширять и искать ошибки. Итак, вперед.

Запускаем редактор Метаедитор (MetaEditor)  из поставки Метатрейдера 4 (Metatrader), до 5 версии думаю я еще не скоро дойду, а в нем «Мастер MQL», где выбираем из предлагаемого списка шаблон советника.

Откроется окно среды разработки, приступим к наполнению исходника.
Первым делом назначим нашему советнику имя, номер версии, не забудем и копирайт и ссылочку на данный блог.

//+------------------------------------------------------------------+
//|                                                  Forex-Grail.mq4 |
//|                                     Copyright 2016, HomeTrade.ru |
//|                                             https://hometrade.ru |
//+------------------------------------------------------------------+
/*
Учимся писать советник.
Версия 1 - основные функции
*/
#define VERSION "1.00"
#property version VERSION
#property copyright "Copyright 2016, HomeTrade.ru"
#property link      "https://hometrade.ru"
#property strict
string ExpertName="Forex-Grail v."+VERSION;
Затем идут внешние переменные, отвечающие за настройку и оптимизацию советника
//внешние переменные
extern int SlipPage = 3; //Проскальзывание
extern int StopLoss = 20; //Стоп-лосс
extern int TakeProfit = 20; //Тейк-профит
extern int MagicNumber = 333; //Magic номер
extern double StartLot = 0.1; // Размер лота для начала торгов
extern double MaxLot = 1; //Максимально допустимый лот

Переменные MINLOT,MAXLOT нужны для корректировки возможного несоответствия наших желаний требованиям дилинг-центра. Эта проверка осуществляется в блоке OnInit(), который выполняется после загрузки советника в терминал. Также событие OnInit происходит при смене периода графика, валюты, после перекомпиляции или смене счета. Тут нужно размещать однократно изменяемые сущности.

//внутренние переменные
double MINLOT,MAXLOT;
bool expertStopped=false; //признак остановки эксперта
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//Если наши значения не попадают в пределы устанавливаемые брокером
MAXLOT = MarketInfo(Symbol(),MODE_MAXLOT);
MINLOT = MarketInfo(Symbol(),MODE_MINLOT);
if (MaxLot>MAXLOT) MaxLot=MAXLOT;
if (StartLot<MINLOT) StartLot=MINLOT;

//корректируем некоторые значения для 5 или 3 значных котировок
if (Digits == 5 || Digits == 3)
{
TakeProfit *= 10;
StopLoss *= 10;

}

return(INIT_SUCCEEDED);
}

В функции OnDeinit ничего нет. Это событие возникает при закрытии графика, перед сменой валюты, при изменении входных параметров после перекомпиляции исходника, при смене счета ну и при выключении торгового терминала.

void OnDeinit(const int reason)
{

}

Основная логика советника реализована в блоке OnTick(), который выполняется при получении терминалом новых валютных котировок.
Вначале идет проверка на наличие у нас денег для торговли. Потому как без денег нужно вначале их найти, а не долбить сервер брокера невыполнимыми приказами, рискуя нарваться на блокировку счета.

void OnTick()
{
//если нет денег для торговли, сообщим об этом однократно
double margin= MarketInfo(NULL, MODE_MARGINREQUIRED);
if ( AccountFreeMargin() < margin)
{
if (expertStopped) return; //уже сообщали что не хватает денег. Чтобы не тревожить брокера
Print ("AccountFreeMargin= ",AccountFreeMargin()," margin= ",margin);
expertStopped=true;
return;
}

expertStopped=false;
Traiding(); //торговые операции
// ТОДО другие операции, например отслеживание - трейлинг - убыточных/профитных сделок, проверка условий на закрытие ордеров и т.п.

}

Далее идет функция Traiding(), в которой мы проверяем условия входа в сделку и при необходимости открываем их.

//Проверяем условия на открытие позиций, открываем позиции
void Traiding()
{
int direction,ticket;

if (TradesCount()>0) return; //уже есть открытые ордера

// куда будем открываться при отсутствии ордеров
if (Open[1]<Close[1])
direction=OP_BUY;
else direction=OP_SELL;

if (direction==OP_BUY)
{
ticket= MyOrderSend(Symbol(),OP_BUY,StartLot,NormalizeDouble(Ask,Digits),SlipPage,NormalizeDouble(Bid - StopLoss*Point,Digits),NormalizeDouble(Bid + TakeProfit*Point,Digits),ExpertName,MagicNumber,0,Blue);
}
else if (direction==OP_SELL)
{
ticket= MyOrderSend(Symbol(),OP_SELL, StartLot,NormalizeDouble(Bid,Digits), SlipPage, NormalizeDouble(Ask + StopLoss*Point,Digits),NormalizeDouble(Ask - TakeProfit*Point,Digits),ExpertName,MagicNumber,0,Green);
}

}

В нашем простейшем примере мы будем торговать одним ордером. Для этого в функции TradesCount() вычисляется число рыночных ордеров, и если хотя бы один присутствует, то ничего не делаем.

//Подсчитаем число открытых рыночных ордеров
int TradesCount() {
int count = 0;
for (int trade = OrdersTotal() - 1; trade >= 0; trade--) //пройдем по всем ордерам
{
if (OrderSelect(trade, SELECT_BY_POS, MODE_TRADES)==true) //смотрим только те что в рынке
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber) //если мэджик номер и пара совпадают - это наш ордер
count++;
}
}
return (count);
}

В качестве торгового сигнала мы воспользуемся цветом последней сформировавшейся свечи, и если она белая (цена открытия меньше цены закрытия, похоже что растем вверх) то покупаем. В противном случае будем торговать в короткую. Далее в зависимости от направления торговли посылаем соответствующие торговые сигналы с помощью функции MyOrderSend, которая в простейшем случае просто передает параметры в стандартную функцию OrderSend. В дальнейшем функцию MyOrderSend можно и нужно усовершенствовать, введя обработку ошибок, исправление их по возможности, например корректировку неправильных стопов и тейков, проверку доступности торговли и прочее. Но пока для простоты понимания оставим как есть.

//Впоследствии можно улучшить обработку ошибок с попытками их исправления, а пока просто аналог OrderSend
int MyOrderSend(string symbol,int cmd,double volume,double price,int slippage,double stoploss,double takeprofit,
string comment=NULL,int magic=0,datetime expiration=0, color arrow_color=clrNONE)
{
int ticket=-1;
ticket=OrderSend(symbol,cmd,volume,price,slippage,stoploss,takeprofit,comment,magic,expiration,arrow_color);
if(ticket<0)
{
Print("Ошибка OrderSend:",GetLastError()," cmd=",cmd);
}

return ticket;
}

Хотелось бы заострить внимание на моменте выставления стоп-лосов и тейк-профитов. Зачастую в советниках встречается подобное:

OrderSend(Symbol(),OP_BUY,0.1,Ask,Slippage,Ask-lStop,Ask+dTake," коммент",0,0,clOpenBuy);

И это будет работать в большинстве случаев. Но иногда можете нарваться на ошибку 130 — неправильные стопы. Особенно если вы скальпер и несколько пипсов в сделке вам ох как важны. А все потому что стопы и тейки в длинной позиции нужно устанавливать не от Ask, а от Bid.
Запомним несколько простых, пусть и печальных для трейдера правил:
1) Брокер работает против вас, любая сделка открывается не в вашу пользу.
2) Продаем по заниженной против нас цене, а покупаем по завышенной.
3) ASK — цена по которой вы покупаете (для вас завышают цену), она выше цены, по которой вы же можете продать (А идет выше буквы B).
4) BID — цена по которой вы продаете (для вас занижают цену), она ниже цены, чем продают вам (буква B стоит ниже А)
5) Длинная позиция, покупка, открывается по невыгодной для вас цене ASK , соответственно закрытие длинной позиции, будь то стоп или профит, будет проходить как продажа вами по невыгодной для вас цене BID.
6) Короткая позиция, продажа, открывается по невыгодной для вас цене BID, соответственно её закрытие будет проводиться брокером как покупка вами по грабительской цене ASK.

Разница между ценами Ask и Bid называется спредом и является существенным заработком для брокеров, и иногда, при резких движениях торгового инструмента, она может существенно возрастать. Надеюсь, это небольшое отступление будет полезно для новичков.

Итак, вот в общем-то наш первый советник и готов. Пора приступить к испытаниям и открывать реальный торговый счет для загребания денег :).

К сожалению, график не внушает оптимизма, с Канарами придется повременить и продолжить работать головой. Постойте, раз на рынке только 25% времени существуют выраженные тренды, а оставшееся время валюты и сырье болтаются во флете, то может нам нужно не идти в направлении предыдущей свечи, а развернуться? Поменяем знак сравнения в if (Open[1]<Close[1]) чтобы получилось if (Open[1]>Close[1]) — в лонг идем при черной свече. И заново протестируем «грааль».

Стало значительно лучше, даже вышли в плюс. Кстати, почаще заглядывайте в журнал тестера на проверку наличия там ошибок. Лучше выявить и исправить их сразу при тестировании, чем после непонятных реальных финансовых потерь.

А если еще и провести оптимизацию значений

то можно получить вполне себе симпатичный график.

На этой оптимистической ноте и закончим создание первой самостоятельной версии автоматического торгового советника Форекс-Грааль. И постоянного профита всем нам!

Продолжение находится здесь: вводим трейлинг-стоп.

Многие трейдеры на Московской бирже хотели бы автоматизировать свои торговые алгоритмы, но не знают с чего начать. А ведь давно есть проработанные решения, которые максимально облегчают первые шаги в алготрейдинге.

Торговать на бирже с помощью роботов — это просто

Язык MQL5 изначально поддерживает все торговые возможности платформы MetaTrader 5 — в нем множество торговых функций для работы с ордерами, позициями и торговыми запросами. При этом не имеет значения, на каком рынке вы торгуете —  фьючерсы, акции, опционы и т.д.

Средствами MQL5 вы можете создать торговый запрос и отослать его на сервер с помощью функций OrderSend() или OrderSendAsync(), получить результат его выполнения, просмотреть торговую историю, узнать спецификацию контракта для инструмента, обработать торговое событие и получить еще множество другой необходимой информации.

MetaTrader 5 предлагает 6 типов торговых операций

Существует несколько основных типов торговых операций, которые вам могут понадобиться в торговом роботе:

1. покупка/продажа по текущей цене,
2. установка отложенного ордера на покупку/продажу по некоторому условию,
3. модификация/удаление отложенного ордера,
4. закрытие/наращивание/сокращение/переворот позиции.

Все эти операции реализуются с помощью функции OrderSend(), существует также и асинхронный вариант этой функции — OrderSendAsync(). Всё многообразие торговых операций описывается структурой MqlTradeRequest, содержащей описание торгового запроса. Поэтому единственные трудности с торговыми операциями могут заключаться только в правильном заполнении структуры MqlTradeRequest и обработке результата выполнения запроса.

В соответствии с правилами вашей торговой системы вы можете совершить покупку или продажу по цене рынка (BUY или SELL), а можете поместить отложенный ордер на совершение покупки/продажи на некотором расстоянии от текущей цены рынка:

• BUY STOP, SELL STOP — покупка или продажа при пробитии указанного уровня (хуже текущей цены);
• BUY LIMIT, SELL LIMIT — покупка или продажа при достижении указанного уровня (лучше текущей цены);
• BUY STOP LIMIT, SELL STOP LIMIT — установка ордера BUY LIMIT или SELL LIMIT при достижении указанной цены.

Типы этих стандартных ордеров соответствуют перечислению ENUM_ORDER_TYPE. 

Кроме  того, вам может понадобиться модифицировать или вовсе удалить отложенный ордер, это также делается с помощью функций OrderSend()/OrderSendAsync(). Изменение открытой позиций тоже не представляет сложности, так как происходит в результате совершения всё тех же торговых операций.

В этой статье мы покажем не только, как легко и просто программировать покупки и продажи в MQL5, но также подскажем, как работать с торговым счетом и свойствами символов. В этом нам помогут торговые классы Стандартной библиотеки.

Работа с торговым счетом

Первым делом при запуске торгового робота в дело необходимо получить информацию о торговом счете, на котором он будет торговать.

Для работы со счетом есть класс CAccountInfo, который как раз и разрабатывался для этих целей. Добавим в наш код подключение файла  AccountInfo.mqh и объявим переменную этого класса account:

#include <TradeAccountInfo.mqh>
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- объект для работы со счетом
  CAccountInfo account;
//--- получим номер счета, на котором запущен советник
   long login=account.Login();
   Print("Login=",login);
//--- выведем валюту счета    
   Print("Валюта счета: ",account.Currency());   
//--- выведем баланс и текущую прибыль на счете
   Print("Balance=",account.Balance(),"  Profit=",account.Profit(),"   Equity=",account.Equity());
//--- выведем тип счета    
   Print("Тип счета: ",account.TradeModeDescription());
//--- выясним, можно ли вообще торговать на данном счете
   if(account.TradeAllowed())
      Print("Торговля на данном счете разрешена");
   else
      Print("Торговля на счете запрещена: возможно, вход был совершен по инвест-паролю");
//--- режим вычисления маржи
   Print("Режим вычисления маржи: ",account.MarginModeDescription());
//--- выясним, разрешено ли торговать на счете с помощью эксперта
   if(account.TradeExpert())
      Print("Автоматическая торговля на счете разрешена");
   else
      Print("Запрещена автоматическая торговля с помощью экспертов и скриптов");
//--- допустимое количество ордеров задано или нет
   int orders_limit=account.LimitOrders();
   if(orders_limit!=0)Print("Максимально допустимое количество действующих отложенных ордеров: ",orders_limit);
//--- выведем имя компании и сервера
   Print(account.Company(),": server ",account.Server());
   Print(__FUNCTION__,"  completed"); //---   
  }

Как видно из приведенного кода, с помощью переменной account в функции OnInit() можно получить много полезной информации. Вы можете добавить этот код в своего эксперта и вам будет гораздо проще разбирать логи при анализе его работы.

Результат запуска скрипта показан на картинке.

Получение свойств финансового инструмента

Информацию о счете мы получили, но для совершения торговых операций нужно знать еще свойства актива, по которому мы собираемся торговать. Для этого предназначен еще один удобный класс CSymbolInfo с большим количеством методов. Мы приведем в примере только небольшую их часть.

#include<TradeSymbolInfo.mqh>
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- объект для получения свойств символа
  CSymbolInfo symbol_info;
//--- зададим имя символа, для которого будем получать информацию
   symbol_info.Name(_Symbol);
//--- получим текущие котировки и выведем
   symbol_info.RefreshRates();
   Print(symbol_info.Name()," (",symbol_info.Description(),")",
         "  Bid=",symbol_info.Bid(),"   Ask=",symbol_info.Ask());
//--- получим количество знаков после запятой и размер пункта
   Print("Digits=",symbol_info.Digits(),
         ", Point=",DoubleToString(symbol_info.Point(),symbol_info.Digits()));
//--- запросим тип исполнения ордеров, нет ли ограничений
   Print("Ограничения на торговые операции: ",EnumToString(symbol_info.TradeMode()),
         " (",symbol_info.TradeModeDescription(),")");
//--- выясним режим заключения сделок
   Print("Режим исполнения сделок: ",EnumToString(symbol_info.TradeExecution()),
         " (",symbol_info.TradeExecutionDescription(),")");
//--- выясним способ вычисления стоимости контрактов
   Print("Вычисление стоимости контракта: ",EnumToString(symbol_info.TradeCalcMode()),
         " (",symbol_info.TradeCalcModeDescription(),")");
//--- размер контракта
   Print("Размер стандартного контракта: ",symbol_info.ContractSize());
//--- размер начальной маржи для 1 контракта
   Print("Начальная маржа для стандартного контракта: ",symbol_info.MarginInitial()," ",symbol_info.CurrencyBase());
//--- минимальный, максимальный размеры объема в торговых операциях
   Print("Volume info: LotsMin=",symbol_info.LotsMin(),"  LotsMax=",symbol_info.LotsMax(),
         "  LotsStep=",symbol_info.LotsStep());
//--- 
   Print(__FUNCTION__,"  completed");   
  }

И на рисунке показаны свойства символа Si-6.16 из секции срочного рынка Московской биржи (FORTS). Теперь вы готовы перейти непосредственно к торговле.

Программирование торговых операций

Для отправки торговых приказов в языке MQL5 существует две функции — OrderSend() и OrderSendAsync(). На самом деле это две реализации одной функции. Если OrderSend() отправляет торговый запрос и ждет результата его выполнения, то асинхронная OrderSendAsync() просто выстреливает запрос и позволяет работать программе дальше, не дожидаясь ответа торгового сервера. Таким образом, торговать в MQL5 действительно просто, достаточно использовать только одну функцию для всех торговых операций

Обе функции получают в качестве первого параметра структуру MqlTradeRequest, которая содержит более десятка полей. Состав требуемых полей зависит от типа торговой операции, поэтому не все поля требуется заполнять. В случае неправильного значения или отсутствия обязательного поля запрос не пройдет проверку в самом терминале и просто не будет отправлен на сервер. При этом 5 из этих полей требуют указания корректного значения из предопределенных перечислений.

Столь большое количество полей торгового запроса вызвано необходимостью описать множество свойств ордера, которые могут меняться в зависимости от политики исполнения, времени истечения и некоторых других параметров. Вам не понадобится заучивать все эти тонкости, просто используйте готовый класс CTrade. Вот так примерно может выглядеть использование этого класса в вашем торговом роботе:

#include<TradeTrade.mqh>
//--- объект для проведения торговых операций
CTrade  trade;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- зададим MagicNumber для идентификации своих ордеров
   int MagicNumber=123456;
   trade.SetExpertMagicNumber(MagicNumber);
//--- установим допустимое проскальзывание в пунктах при совершении покупки/продажи
   int deviation=10;
   trade.SetDeviationInPoints(deviation);
//--- режим заполнения ордера, нужно использовать тот режим, который разрешается сервером
   trade.SetTypeFilling(ORDER_FILLING_RETURN);
//--- режим логирования: лучше не вызывать этот метод вообще, класс сам выставит оптимальный режим
   trade.LogLevel(1); 
//--- какую функцию использовать для торговли: true - OrderSendAsync(), false - OrderSend()
   trade.SetAsyncMode(true);
//---
   return(0);
  }

Для торговли на бирже как правило используется режим исполнения ORDER_FILLING_RETURN. Справка гласит:

Данный режим используется только в режимах «Исполнение по рынку» и «Биржевое исполнение»: для рыночных (ORDER_TYPE_BUY и ORDER_TYPE_SELL), лимитных и стоп-лимитных ордеров (ORDER_TYPE_BUY_LIMIT, ORDER_TYPE_SELL_LIMIT, ORDER_TYPE_BUY_STOP_LIMIT и ORDER_TYPE_SELL_STOP_LIMIT). В случае частичного исполнения рыночный или лимитный ордер с остаточным объемом не снимается, а продолжает действовать.

Для ордеров ORDER_TYPE_BUY_STOP_LIMIT и ORDER_TYPE_SELL_STOP_LIMIT при активации будет создан соответствующий лимитный ордер ORDER_TYPE_BUY_LIMIT/ORDER_TYPE_SELL_LIMIT с типом исполнения ORDER_FILLING_RETURN.

Ну а теперь пришло время посмотреть, как CTrade помогает в торговых операциях.

Покупка/продажа по текущей цене

Часто в торговых стратегиях необходимо совершить покупку или продажу по текущей цене прямо сейчас. CTrade знаком с такой ситуацией и просит лишь необходимый объем торговой операции. Все остальные параметры — цену открытия и название символа, уровни Stop Loss и Take Profit, комментарий к ордеру — можно не указывать.

//--- 1. пример покупки по текущему символу
   if(!trade.Buy(1))
     {
      //--- сообщим о неудаче
      Print("Метод Buy() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
            ". Описание кода: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Метод Buy() выполнен успешно. Код возврата=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

По умолчанию если имя инструмента не указано, CTrade будет использовать имя символа, на графике которого он запущен. Это очень удобно для простых стратегий. Для робота, который торгует сразу на нескольких инструментах,  вам необходимо каждый раз явно указывать символ, по которому будет проводиться торговая операция.

//--- 2. пример покупки по указанному символу
   if(!trade.Buy(1,"Si-6.16"))
     {
      //--- сообщим о неудаче
      Print("Метод Buy() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
            ". Описание кода: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Метод Buy() выполнен успешно. Код возврата=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Можно указать все параметры ордера: уровни Stop Loss/Take Profit, цена открытия и комментарий.

//--- 3. пример покупки по указанному символу символу с заданными SL и TP
   double volume=1;           // укажем объем торговой операции
   string symbol="Si-6.16";   // укажем символ, на котором проводится операция
   int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // количество знаков после запятой
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);         // пункт
   double bid=SymbolInfoDouble(symbol,SYMBOL_BID);             // текущая цена для закрытия LONG
   double SL=bid-100*point;                                    // ненормализованное значение SL
   SL=NormalizeDouble(SL,digits);                              // нормализуем Stop Loss
   double TP=bid+100*point;                                    // ненормализованное значение TP
   TP=NormalizeDouble(TP,digits);                              // нормализуем Take Profit
//--- получим текущую цену открытия для LONG позиций
   double open_price=SymbolInfoDouble(symbol,SYMBOL_ASK);
   string comment=StringFormat("Buy %s %G lots at %s, SL=%s TP=%s",
                               symbol,volume,
                               DoubleToString(open_price,digits),
                               DoubleToString(SL,digits),
                               DoubleToString(TP,digits));
   if(!trade.Buy(volume,symbol,open_price,SL,TP,comment))
     {
      //--- сообщим о неудаче
      Print("Метод Buy() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
            ". Описание кода: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Метод Buy() выполнен успешно. Код возврата=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Напомним, MagicNumber и допустимое проскальзывание мы задали при инициализации экземпляра CTrade, поэтому они не требуются. Хотя их тоже можно задавать непосредственно перед каждой торговой операцией, если это необходимо.

Выставление лимитного ордера

Для отправки лимитного ордера используется соответствующий метод класса BuyLimit() или SellLimit(). Для большинства случаев может подойти укороченный вариант, когда указываются только цена открытия и объем. Цена открытия для BuyLimit должна быть ниже текущей цены, а для SellLimit должна быть выше. То есть эти ордера используются для входа в рынок по лучшей цене, например, в стратегиях с расчетом на отскок от уровня поддержки. При этом используется тот символ, на котором запущен эксперт:

//--- 1. пример установки отложенного ордера BuyLimit
   string symbol="Si-6.16";                                    // укажем символ, на котором выставляется ордер
   int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // количество знаков после запятой
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);         // пункт
   double ask=SymbolInfoDouble(symbol,SYMBOL_ASK);             // текущая цена покупки
   double price=ask-100*point;                                 // ненормализованное цена открытия
   price=NormalizeDouble(price,digits);                        // нормализуем цену открытия
//--- все готово, отправляем на сервер отложенный ордер Buy Limit
   if(!trade.BuyLimit(1,price))
     {
      //--- сообщим о неудаче
      Print("Метод BuyLimit() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
            ". Описание кода: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Метод BuyLimit() выполнен успешно. Код возврата=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Можно использовать и более подробный вариант с указанием всех параметров: уровни SL/TP, время истечения, название инструмента и комментарий к ордеру.

//--- 2. пример установки отложенного ордера BuyLimit со всеми параметрами
   double volume=1;
   string symbol="Si-6.16";                                    // укажем символ, на котором выставляется ордер
   int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // количество знаков после запятой
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);         // пункт
   double ask=SymbolInfoDouble(symbol,SYMBOL_ASK);             // текущая цена покупки
   double price=ask-100*point;                                 // ненормализованное цена открытия
   price=NormalizeDouble(price,digits);                        // нормализуем цену открытия
   int SL_pips=100;                                            // Stop Loss в пунктах
   int TP_pips=100;                                            // Take Profit в пунктах
   double SL=price-SL_pips*point;                              // ненормализованное значение SL
   SL=NormalizeDouble(SL,digits);                              // нормализуем Stop Loss
   double TP=price+TP_pips*point;                              // ненормализованное значение TP
   TP=NormalizeDouble(TP,digits);                              // нормализуем Take Profit
   datetime expiration=TimeTradeServer()+PeriodSeconds(PERIOD_D1);
   string comment=StringFormat("Buy Limit %s %G lots at %s, SL=%s TP=%s",
                               symbol,volume,
                               DoubleToString(price,digits),
                               DoubleToString(SL,digits),
                               DoubleToString(TP,digits));
//--- все готово, отправляем на сервер отложенный ордер Buy Limit
   if(!trade.BuyLimit(volume,price,symbol,SL,TP,ORDER_TIME_DAY,expiration,comment))
     {
      //--- сообщим о неудаче
      Print("Метод BuyLimit() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
            ". Описание кода: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Метод BuyLimit() выполнен успешно. Код возврата=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Во втором варианте необходимо правильно указать уровни SL и TP. Не забывайте, что для покупок уровень Take Profit должен быть выше цены открытия, а уровень Stop Loss — ниже цены открытия. Для ордеров SellLimit всё наоборот. Вы легко можете узнать о своей ошибке при тестировании эксперта на исторических данных, класс CTrade автоматически выводит в таких случаях сообщения (если вы сами не вызывали функцию LogLevel).

Выставление стопового ордера

Для отправки стопового ордера используются аналогичные методы BuyStop() и SellStop(). Цена открытия для Buy Stop должна быть выше текущей цены, а для SellStop должна быть ниже. Стоповые ордера используются в стратегиях, которые входят на прорыве некоего уровня сопротивления, а также для ограничения убытков. Простой вариант:

//--- 1. пример установки отложенного ордера Buy Stop
   string symbol="RTS-6.16";    // укажем символ, на котором выставляется ордер
   int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // количество знаков после запятой
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);         // пункт
   double ask=SymbolInfoDouble(symbol,SYMBOL_ASK);             // текущая цена покупки
   double price=ask+100*point;                                 // ненормализованное цена открытия
   price=NormalizeDouble(price,digits);                        // нормализуем цену открытия
//--- все готово, отправляем на сервер отложенный ордер Buy Stop 
   if(!trade.BuyStop(1,price))
     {
      //--- сообщим о неудаче
      Print("Метод BuyStop() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
            ". Описание кода: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Метод BuyStop() выполнен успешно. Код возврата=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

И более подробный, когда нужно указать максимум параметров для отложенного ордера BuyStop:

//--- 2. пример установки отложенного ордера Buy Stop со всеми параметрами
   double volume=1;
   string symbol="RTS-6.16";    // укажем символ, на котором выставляется ордер
   int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // количество знаков после запятой
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);         // пункт
   double ask=SymbolInfoDouble(symbol,SYMBOL_ASK);             // текущая цена покупки
   double price=ask+100*point;                                 // ненормализованное цена открытия
   price=NormalizeDouble(price,digits);                        // нормализуем цену открытия
   int SL_pips=100;                                            // Stop Loss в пунктах
   int TP_pips=100;                                            // Take Profit в пунктах
   double SL=price-SL_pips*point;                              // ненормализованное значение SL
   SL=NormalizeDouble(SL,digits);                              // нормализуем Stop Loss
   double TP=price+TP_pips*point;                              // ненормализованное значение TP
   TP=NormalizeDouble(TP,digits);                              // нормализуем Take Profit
   datetime expiration=TimeTradeServer()+PeriodSeconds(PERIOD_D1);
   string comment=StringFormat("Buy Stop %s %G lots at %s, SL=%s TP=%s",
                               symbol,volume,
                               DoubleToString(price,digits),
                               DoubleToString(SL,digits),
                               DoubleToString(TP,digits));
//--- все готово, отправляем на сервер отложенный ордер Buy Stop 
   if(!trade.BuyStop(volume,price,symbol,SL,TP,ORDER_TIME_DAY,expiration,comment))
     {
      //--- сообщим о неудаче
      Print("Метод BuyStop() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
            ". Описание кода: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Метод BuyStop() выполнен успешно. Код возврата=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Для отправки ордера SellStop применяется соответствующий метод класса CTrade, главное — правильно указывать цены.

Работа с позицией

Вы можете вместо использования методов Buy() и Sell() пользоваться методами для открытия позиции. Правда, в этом случае придется указать больше деталей:

//--- количество знаков после запятой
   int    digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);
//--- значение пункта
   double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);
//--- получим цену покупки
   double price=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
//--- вычислим и нормализуем уровни SL и TP
   double SL=NormalizeDouble(price-100*point,digits);
   double TP=NormalizeDouble(price+100*point,digits);
//--- заполним комментарий
   string comment="Buy "+_Symbol+" 1 at "+DoubleToString(price,digits);
//--- все готово, делаем попытку открыть позицию на покупку
   if(!trade.PositionOpen(_Symbol,ORDER_TYPE_BUY,1,price,SL,TP,comment))
     {
      //--- сообщим о неудаче
      Print("Метод PositionOpen() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
            ". Описание кода: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Метод PositionOpen() выполнен успешно. Код возврата=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Для закрытия позиции достаточно указать имя инструмента, остальное класс CTrade сделает сам.

//--- закрываем позицию по текущему символу
   if(!trade.PositionClose(_Symbol))
     {
      //--- сообщим о неудаче
      Print("Метод PositionClose() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
            ". Описание кода: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Метод PositionClose() выполнен успешно. Код возврата=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

У открытой позиции можно изменять уровни StopLoss и TakeProfit. Это делается с помощью метода ModifyPosition().

//--- количество знаков после запятой
   int    digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);
//--- значение пункта
   double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);
//--- получим текущую цену Bid
   double price=SymbolInfoDouble(_Symbol,SYMBOL_BID);
//--- вычислим и нормализуем уровни SL и TP
   double SL=NormalizeDouble(price-100*point,digits);
   double TP=NormalizeDouble(price+100*point,digits);
//--- все готово, делаем попытку модифицировать позицию на покупку
   if(!trade.PositionModify(_Symbol,SL,TP))
     {
      //--- сообщим о неудаче
      Print("Метод PositionModify() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
            ". Описание кода: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Метод PositionModify() выполнен успешно. Код возврата=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Модификация и удаление ордера

Для изменения параметров отложенного ордера в классе CTrade предусмотрен метод OrderModify(), которому необходимо передать все требуемые параметры.

//--- проверим наличие ордера  
   if(!OrderSelect(ticket))
     {
      Print("Ордер #",ticket," не найден");
      return;
     }
//--- символ 
   string symbol=OrderGetString(ORDER_SYMBOL);
//--- количество знаков после запятой
   int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- значение пункта
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);
//--- получим цену открытия
   double price=OrderGetDouble(ORDER_PRICE_OPEN);
//--- вычислим и нормализуем уровни SL и TP
   double SL=NormalizeDouble(price-200*point,digits);
   double TP=NormalizeDouble(price+200*point,digits);
//--- все готово, делаем попытку модифицировать ордер 
//   if(!trade.OrderModify(ticket,price,SL,TP,(ENUM_ORDER_TYPE_TIME)OrderGetInteger(ORDER_TYPE_TIME),0))

   if(!trade.OrderModify(ticket,price,SL,TP,ORDER_TIME_DAY,0))
     {
      //--- сообщим о неудаче
      Print("Метод OrderModify() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
            ". Описание кода: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Метод OrderModify() выполнен успешно. Код возврата=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Вам необходимо получить тикет ордера, который необходимо изменить, и в зависимости от его типа указать правильные уровни StopLoss и TakeProfit. Кроме того, новая цена открытия должна быть также корректной по отношению к текущей цене.

Для удаления отложенного ордера достаточно знать его тикет:

//--- проверим наличие ордера  
   if(!OrderSelect(ticket))
     {
      Print("Ордер #",ticket," не найден");
      return;
     }
//--- все готово, делаем попытку удалить ордер
   if(!trade.OrderDelete(ticket))
     {
      //--- сообщим о неудаче
      Print("Метод OrderDelete() потерпел неудачу. Код возврата=",trade.ResultRetcode(),
            ". Описание кода: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Метод OrderDelete() выполнен успешно. Код возврата=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

В классе также есть универсальный метод OrderOpen(), который может выставлять отложенные ордера любого типа. В отличие от специализированных методов BuyLimit, BuyStop, SellLimit и SellStop, он требует указывать больше обязательных параметров. Возможно, кому-то он покажется более удобным.

Что еще посмотреть в торговых классах

В этой статье мы показали простые приемы для программирования торговых операций покупки и продажи, а также работу с отложенными ордерами. Но в разделе Торговые классы есть еще несколько удобных помощников для разработчиков роботов на MQL5:

• COrderInfo — для работы с ордерами;
• CHistoryOrderInfo — для работы с отработанными ордерами, попавшими в историю торговли;
• CPositionInfo — для работы с позициями;
• CDealInfo — для работы со сделками;
• CTerminalInfo — для получения информации о самом терминале.

С помощью этих классов вы можете сосредоточиться только на торговой стороне вашей стратегии, сведя все технические вопросы к минимуму. Кроме того, класс CTrade можно использовать для изучения торговых запросов, например, под отладкой. И со временем вы можете создать на его основе собственные классы, в которых реализуете необходимую вам логику по обработке результатов выполнения торгового запроса.

Начните свой путь в алготрейдинг с простых скриптов

Предложенные в статье способы по разработке торговых роботов на MQL5 предназначены в первую очередь новичкам, хотя многие опытные разработчики также могут найти для себя что-то новое и полезное.

Начните с выполнения простых скриптов (https://c.mql5.com/36/9/mql5-moex-first-steps.zip), и вы поймете, что создать торгового робота гораздо проще, чем вы думали!