Скачать MetaTrader 5

MQL5 для "чайников": Получение значений технических индикаторов в своих экспертах

5 марта 2010, 12:09
Sergey Pavlov
3
13 575

Введение

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


Общий принцип использования функций стандартных индикаторов

Каждая функция технического индикатора при вызове создаёт указатель (хэндл) на созданный объект (копию индикатора) с конкретными входными параметрами. Сам по себе указатель ничего не даёт, кроме как привязки его к объекту. Но этого вполне достаточно для того, чтобы получать данные из индикаторных буферов и использовать их в своих расчётах. Рассмотрим на примере:

//---- indicator buffers
double      MA[];                // массив для индикатора iMA
//---- handles for indicators
int         MA_handle;           // указатель на индикатор iMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   //--- создание указателя на объект - индикатор iMA
   MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE);
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   //--- заполнение массива MA[] текущими значениями индикатора iMA
   //--- в массив будет записано 100 элементов
   CopyBuffer(MA_handle,0,0,100,MA);
   //--- задаём порядок индексации массива MA[] как в MQL4
   ArraySetAsSeries(MA,true);  
   //--- а дальше делайте с этими данными всё что угодно, например: 
   if(MA[0]>MA[1])
      {
      //--- выполнение каких-то операций
      }
   }
Как видим, всё достаточно просто. Здесь показано, как в советнике использовать самый популярный среди трейдеров индикатор - iMA.

Указатель индикатора целесообразно создавать в функции инициализации OnInit().

Необходимые пояснения:

  1. Что означает: "задаём порядок индексации массива MA[] как в MQL4"? А говорит это о том, что в данном примере используется индексация как в таймсерии. Другими словами, текущий (не сформировавшийся) бар всегда имеет индекс [0], а предыдущий (сформировавшийся бар) - соответствует индексу [1] и т.д.
  2. Зачем задавать порядок индексации? Для удобства и оптимальной реализации того или иного алгоритма, программист самостоятельно решает, какую применить индексацию в каждом конкретном случае, а MQL5 готов к любому развитию событий.
  3. Почему же указатель индикатора целесообразней всего создавать именно в функции OnInit()? По большому счёту, это можно делать где угодно в программе - явных запретов нет. Однако, есть весомый аргумент в пользу предлагаемого варианта: функция OnInit() вызывается один раз при запуске эксперта, а этого вполне достаточно для инициализации индикаторов, у которых входные параметры не меняют своих значений время исполнения. И даже если такое изменение входных параметров предусмотрено алгоритмом, то никто не запрещает вызвать функцию инициализации ещё раз из любой другой функции, например OnTick().


Уроки программирования

Практически любой эксперт предназначен для совершения торговых операций и не только на демо, но и на реальном счёте. И чтобы доверить ему самостоятельную торговлю, и при этом спать спокойно, надо заранее предусмотреть все возможные последствия его действий. Программисты МТС, даже высокого уровня, иногда допускают ошибки, причём очень "детские". А цена такой ошибки может быть очень высока!

Так на чемпионате по автотрейдингу в 2008 году был такой эпизод. Торговый робот одного из участников, после того как увеличил депозит до определённого уровня, должен был прекратить торговлю и уснуть до окончания чемпионата. Так он и сделал. И как же был удивлён автор и все кто следил за работой его эксперта, когда робот неожиданно проснулся и начал опять торговать, сливая при этом заработанный депозит!

Вы же не хотите совершать подобные ошибки, когда робот выходит из-под контроля? Тогда давайте рассмотрим, какие "подводные камни" могут быть при использовании стандартных индикаторов:

  1. Указатель на объект создаётся в блоке инициализации, а что если он при этом так и не создался? А мы будем потом обращаться к тому, чего нет. Поэтому, воспользуемся предоставленной нам разработчиками MQL5 возможностью это проверить. Если указатель не создан, то значение переменной будет возвращено равным стандартной константе INVALID_HANDLE = -1.
  2. Значения индикаторных буферов мы записываем в массив, а затем используем их в своих расчётах. А что если в этот массив, по какой-то причине, ничего не записалось? Следовательно, торговая система будет выдавать ошибочные сигналы или что-то в этом роде. Для этого случая, разработчики языка опять позаботились о нас, и предлагают проверять количество скопированных элементов сразу, "не отходя от кассы". Если произошла ошибка, то количество скопированных элементов будет равно -1.

Теперь, как всё это может выглядеть в коде:

//---- indicator buffers
double      MA[];                // массив для индикатора iMA
//---- handles for indicators
int         MA_handle;           // указатель на индикатор iMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   //--- создание указателя на объект - индикатор iMA
   MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE);
   //--- если произошла ошибка при создании объекта, то выводим сообщение
   if(MA_handle<0)
      {
      Print("Объект iMA не создан: MA_handle= ",INVALID_HANDLE);
      Print("Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
      }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   //--- заполнение массива MA[] текущими значениями индикатора iMA
   //--- в массив будет записано 100 элементов, а если произошла
   //--- ошибка, то прекращаем выполнение дальнейших операций
   if(CopyBuffer(MA_handle,0,0,100,MA)<=0) return;
   //--- задаём порядок индексации массива MA[] как в таймсерии
   ArraySetAsSeries(MA,true);  
   //--- а дальше делайте с этими данными всё что угодно, например: 
   if(MA[0]>MA[1])
      {
      //--- выполнение каких-то операций
      }
  }

Обратите внимание, что совсем небольшие изменения в коде увеличили его безопасность и надёжность! Но и это ещё не всё. Теперь можно усовершенствовать копирование значений индикатора в массив, для этого нужно воспользоваться специально разработанной функцией:

//+------------------------------------------------------------------------------+
//| копирует в массив значения индикатора с учётом порядка индексации            |
//+------------------------------------------------------------------------------+
bool CopyBufferAsSeries(
                        int handle,      // handle индикатора
                        int bufer,       // номер буфера индикатора
                        int start,       // откуда начнём
                        int number,      // сколько копируем
                        bool asSeries,   // порядок индексации массива
                        double &M[]      // массив, куда будут скопированы данные
                        )
  {
//--- заполнение массива M текущими значениями индикатора
   if(CopyBuffer(handle,bufer,start,number,M)<=0) return(false);
//--- задаём порядок индексации массива M
//--- если asSeries=true, то порядок индексации массива M как в таймсерии
//--- если asSeries=false, то порядок индексации массива M остаётся по умолчанию
   ArraySetAsSeries(M,asSeries);
//---
   return(true);
  }

Эта функция находится во включаемом файле GetIndicatorBuffers.mqh (см. прикреплённый файл). Для того, чтобы воспользоваться этой функцией, прикреплённый файл надо скопировать в каталог ...\ MQL5\Include\. Итоговый вид кода вызова стандартного индикатора iMA и копирования полученных значений из индикаторного буфера в соответствующий массив будет выглядеть так:

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      MA[];                // массив для индикатора iMA
//---- handles for indicators
int         MA_handle;           // указатель на индикатор iMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iMA
   MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(MA_handle<0)
     {
      Print("Объект iMA не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива MA[] текущими значениями индикатора iMA
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(MA_handle,0,0,100,true,MA)) return;
//--- а дальше делайте с этими данными всё что угодно, например: 
   if(MA[0]>MA[1])
     {
      //--- выполнение каких-то операций
     }
  }


Особенности вызова многобуферных индикаторов

Рассмотрим на примере индикатора iAlligator, который содержит 3 индикаторных буфера:

  • 0 буфер - GATORJAW_LINE
  • 1 буфер - GATORTEETH_LINE
  • 2 буфер - GATORLIPS_LINE

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

//+------------------------------------------------------------------------------+
//| копирует в массивы значния индикатора Аллигатор с учётом индексации          |
//+------------------------------------------------------------------------------+
bool GetAlligatorBuffers(int Alligator_handle,
                         int start,
                         int number,
                         double &Jaws[],
                         double &Teeth[],
                         double &Lips[],
                         bool asSeries=true  // индексация как в таймсерии
                         )
  {
//--- заполнение массива Jaws текущими значениями GATORJAW_LINE
   if(!CopyBufferAsSeries(Alligator_handle,0,start,number,asSeries,Jaws)) return(false);
//--- заполнение массива Teeth текущими значениями GATORTEETH_LINE
   if(!CopyBufferAsSeries(Alligator_handle,1,start,number,asSeries,Teeth)) return(false);
//--- заполнение массива Lips текущими значениями GATORLIPS_LINE
   if(!CopyBufferAsSeries(Alligator_handle,2,start,number,asSeries,Lips)) return(false);
//---
   return(true);
  }

следующим образом:

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Jaws[];   // массив для GATORJAW_LINE индикатора iAlligator
double      Teeth[];  // массив для GATORTEETH_LINE индикатора iAlligator
double      Lips[];   // массив для GATORLIPS_LINE индикатора iAlligator
//---- handles for indicators
int         Alligator_handle;           // указатель на индикатор iAlligator
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iAlligator
   Alligator_handle=iAlligator(NULL,0,13,8,8,5,5,3,MODE_EMA,PRICE_MEDIAN);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(Alligator_handle<0)
     {
      Print("Объект iAlligator не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- задаём порядок индексации массивов как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
//--- заполнение объявленных массивов текущими значениями из всех индикаторных буферов
   if(!GetAlligatorBuffers(Alligator_handle,0,100,Jaws,Teeth,Lips,true)) return;
  }

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

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

iAC

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      AC[];                // массив для индикатора iAC
//---- handles for indicators
int         AC_handle;           // указатель на индикатор iAC
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iAC
   AC_handle=iAC(NULL,0);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(AC_handle<0)
     {
      Print("Объект iAC не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива AC[] текущими значениями индикатора iAC
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(AC_handle,0,0,100,true,AC)) return;
  }


iAD

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      AD[];                // массив для индикатора iAD
//---- handles for indicators
int         AD_handle;           // указатель на индикатор iAD
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iAD
   AD_handle=iAD(NULL,0,VOLUME_TICK);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(AD_handle<0)
     {
      Print("Объект iAD не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива AD[] текущими значениями индикатора iAD
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(AD_handle,0,0,100,true,AD)) return;
  }


iADX

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Main[];    // массив для MAIN_LINE индикатора iADX
double      PlusDI[];  // массив для PLUSDI_LINE индикатора iADX
double      MinusDI[]; // массив для MINUSDI_LINE индикатора iADX
//---- handles for indicators
int         ADX_handle;           // указатель на индикатор iADX
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iADX
   ADX_handle=iADX(NULL,0,14);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(ADX_handle<0)
     {
      Print("Объект iADX не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- задаём порядок индексации массивов как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
//--- заполнение объявленных массивов текущими значениями из всех индикаторных буферов
   if(!GetADXBuffers(ADX_handle,0,100,Main,PlusDI,MinusDI,true)) return;
  }


iADXWilder

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Main[];    // массив для MAIN_LINE индикатора iADXWilder
double      PlusDI[];  // массив для PLUSDI_LINE индикатора iADXWilder
double      MinusDI[]; // массив для MINUSDI_LINE индикатора iADXWilder
//---- handles for indicators
int         ADXWilder_handle;           // указатель на индикатор iADXWilder
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iADXWilder
   ADXWilder_handle=iADXWilder(NULL,0,14);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(ADXWilder_handle<0)
     {
      Print("Объект iADXWilder не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- задаём порядок индексации массивов как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
//--- заполнение объявленных массивов текущими значениями из всех индикаторных буферов
   if(!GetADXWilderBuffers(ADXWilder_handle,0,100,Main,PlusDI,MinusDI,true)) return;
  }


iAlligator

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Jaws[];   // массив для GATORJAW_LINE индикатора iAlligator
double      Teeth[];  // массив для GATORTEETH_LINE индикатора iAlligator
double      Lips[];   // массив для GATORLIPS_LINE индикатора iAlligator
//---- handles for indicators
int         Alligator_handle;           // указатель на индикатор iAlligator
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iAlligator
   Alligator_handle=iAlligator(NULL,0,13,8,8,5,5,3,MODE_EMA,PRICE_MEDIAN);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(Alligator_handle<0)
     {
      Print("Объект iAlligator не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- задаём порядок индексации массивов как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
//--- заполнение объявленных массивов текущими значениями из всех индикаторных буферов
   if(!GetAlligatorBuffers(Alligator_handle,0,100,Jaws,Teeth,Lips,true)) return;
  }


iAMA

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      AMA[];                // массив для индикатора iAMA
//---- handles for indicators
int         AMA_handle;           // указатель на индикатор iAMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iAMA
   AMA_handle=iAMA(NULL,0,21,5,8,0,PRICE_CLOSE);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(AMA_handle<0)
     {
      Print("Объект iAMA не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива AMA[] текущими значениями индикатора iAMA
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(AMA_handle,0,0,100,true,AMA)) return;
  }


iAO

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      AO[];                // массив для индикатора iAO
//---- handles for indicators
int         AO_handle;           // указатель на индикатор iAO
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iAO
   AO_handle=iAO(NULL,0);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(AO_handle<0)
     {
      Print("Объект iAO не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива AO[] текущими значениями индикатора iAO
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(AO_handle,0,0,100,true,AO)) return;
  }


iATR

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      ATR[];                // массив для индикатора iATR
//---- handles for indicators
int         ATR_handle;           // указатель на индикатор iATR
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iATR
   ATR_handle=iATR(NULL,0,14);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(ATR_handle<0)
     {
      Print("Объект iATR не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива ATR[] текущими значениями индикатора iATR
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(ATR_handle,0,0,100,true,ATR)) return;
  }


iBearsPower

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      BearsPower[];                // массив для индикатора iBearsPower
//---- handles for indicators
int         BearsPower_handle;           // указатель на индикатор iBearsPower
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iBearsPower
   BearsPower_handle=iBearsPower(NULL,0,14);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(BearsPower_handle<0)
     {
      Print("Объект iBearsPower не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива BearsPower[] текущими значениями индикатора iBearsPower
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(BearsPower_handle,0,0,100,true,BearsPower)) return;
  }


iBands

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Base[];     // массив для BASE_LINE индикатора iBands
double      Upper[];    // массив для UPPER_BAND индикатора iBands
double      Lower[];    // массив для LOWER_BAND индикатора iBands
//---- handles for indicators
int         Bands_handle;           // указатель на индикатор iBands
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iBands
   Bands_handle=iBands(NULL,0,144,0,2,PRICE_CLOSE);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(Bands_handle<0)
     {
      Print("Объект iBands не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- задаём порядок индексации массивов как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
//--- заполнение объявленных массивов текущими значениями из всех индикаторных буферов
   if(!GetBandsBuffers(Bands_handle,0,100,Base,Upper,Lower,true)) return;
  }


iBullsPower

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      BullsPower[];                // массив для индикатора iBullsPower
//---- handles for indicators
int         BullsPower_handle;           // указатель на индикатор iBullsPower
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iBullsPower
   BullsPower_handle=iBullsPower(NULL,0,14);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(BullsPower_handle<0)
     {
      Print("Объект iBullsPower не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива BullsPower[] текущими значениями индикатора iBullsPower
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(BullsPower_handle,0,0,100,true,BullsPower)) return;
  }


iCCI

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      CCI[];                // массив для индикатора iCCI
//---- handles for indicators
int         CCI_handle;           // указатель на индикатор iCCI
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iCCI
   CCI_handle=iCCI(NULL,0,14,PRICE_CLOSE);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(CCI_handle<0)
     {
      Print("Объект iCCI не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива CCI[] текущими значениями индикатора iCCI
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(CCI_handle,0,0,100,true,CCI)) return;
  }


iChaikin

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Chaikin[];                // массив для индикатора iChaikin
//---- handles for indicators
int         Chaikin_handle;           // указатель на индикатор iChaikin
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iChaikin
   Chaikin_handle=iChaikin(NULL,0,8,14,MODE_EMA,VOLUME_TICK);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(Chaikin_handle<0)
     {
      Print("Объект iChaikin не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива Chaikin[] текущими значениями индикатора iChaikin
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(Chaikin_handle,0,0,100,true,Chaikin)) return;
  }


iDEMA

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      DEMA[];                // массив для индикатора iDEMA
//---- handles for indicators
int         DEMA_handle;           // указатель на индикатор iDEMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iDEMA
   DEMA_handle=iDEMA(NULL,0,8,0,PRICE_CLOSE);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(DEMA_handle<0)
     {
      Print("Объект iDEMA не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива DEMA[] текущими значениями индикатора iDEMA
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(DEMA_handle,0,0,100,true,DEMA)) return;
  }

iDeMarker

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      DeMarker[];                // массив для индикатора iDeMarker
//---- handles for indicators
int         DeMarker_handle;           // указатель на индикатор iDeMarker
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iDeMarker
   DeMarker_handle=iDeMarker(NULL,0,21);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(DeMarker_handle<0)
     {
      Print("Объект iDeMarker не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива DeMarker[] текущими значениями индикатора iDeMarker
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(DeMarker_handle,0,0,100,true,DeMarker)) return;
  }


iEnvelopes

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Upper[];    // массив для UPPER_LINE индикатора iEnvelopes
double      Lower[];    // массив для LOWER_LINE индикатора iEnvelopes
//---- handles for indicators
int         Envelopes_handle;           // указатель на индикатор iEnvelopes
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iEnvelopes
   Envelopes_handle=iEnvelopes(NULL,0,14,0,MODE_SMA,PRICE_CLOSE,0.1);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(Envelopes_handle<0)
     {
      Print("Объект iEnvelopes не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- задаём порядок индексации массивов как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
//--- заполнение объявленных массивов текущими значениями из всех индикаторных буферов
   if(!GetEnvelopesBuffers(Envelopes_handle,0,100,Upper,Lower,true)) return;
  }

iForce

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Force[];                // массив для индикатора iForce
//---- handles for indicators
int         Force_handle;           // указатель на индикатор iForce
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iForce
   Force_handle=iForce(NULL,0,21,MODE_SMA,VOLUME_TICK);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(Force_handle<0)
     {
      Print("Объект iForce не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива Force[] текущими значениями индикатора iForce
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(Force_handle,0,0,100,true,Force)) return;
  }


iFractals

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Upper[];    // массив для UPPER_LINE индикатора iFractals
double      Lower[];    // массив для LOWER_LINE индикатора iFractals
//---- handles for indicators
int         Fractals_handle;           // указатель на индикатор iFractals
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iFractals
   Fractals_handle=iFractals(NULL,0);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(Fractals_handle<0)
     {
      Print("Объект iFractals не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- задаём порядок индексации массивов как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
//--- заполнение объявленных массивов текущими значениями из всех индикаторных буферов
   if(!GetFractalsBuffers(Fractals_handle,0,100,Upper,Lower,true)) return;
  }


iFrAMA

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      FrAMA[];                // массив для индикатора iFrAMA
//---- handles for indicators
int         FrAMA_handle;           // указатель на индикатор iFrAMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iFrAMA
   FrAMA_handle=iFrAMA(NULL,0,21,0,MODE_SMA);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(FrAMA_handle<0)
     {
      Print("Объект iFrAMA не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива FrAMA[] текущими значениями индикатора iFrAMA
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(FrAMA_handle,0,0,100,true,FrAMA)) return;
  }


iGator

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Upper[];    // массив для UPPER_LINE индикатора iGator
double      Lower[];    // массив для LOWER_LINE индикатора iGator
//---- handles for indicators
int         Gator_handle;           // указатель на индикатор iGator
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iGator
   Gator_handle=iGator(NULL,0,13,8,8,5,5,3,MODE_EMA,PRICE_MEDIAN);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(Gator_handle<0)
     {
      Print("Объект iGator не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- задаём порядок индексации массивов как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
//--- заполнение объявленных массивов текущими значениями из всех индикаторных буферов
   if(!GetGatorBuffers(Gator_handle,0,100,Upper,Lower,true)) return;
  }


iIchimoku

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double   Tenkansen[];   // массив для TENKANSEN_LINE индикатора iIchimoku
double   Kijunsen[];    // массив для KIJUNSEN_LINE индикатора iIchimoku
double   SenkouspanA[]; // массив для SENKOUSPANA_LINE индикатора iIchimoku
double   SenkouspanB[]; // массив для SENKOUSPANB_LINE индикатора iIchimoku
double   Chinkouspan[]; // массив для CHINKOUSPAN_LINE индикатора iIchimoku
//---- handles for indicators
int      Ichimoku_handle;            // указатель на индикатор iIchimoku
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iIchimoku
   Ichimoku_handle=iIchimoku(NULL,0,9,26,52);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(Ichimoku_handle<0)
     {
      Print("Объект iIchimoku не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- задаём порядок индексации массивов как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
//--- заполнение объявленных массивов текущими значениями из всех индикаторных буферов
   if(!GetIchimokuBuffers(Ichimoku_handle,0,100,
      Tenkansen,
      Kijunsen,
      SenkouspanA,
      SenkouspanB,
      Chinkouspan,
      true)) return;
  }


iBWMFI

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      BWMFI[];                // массив для индикатора iBWMFI
//---- handles for indicators
int         BWMFI_handle;           // указатель на индикатор iBWMFI
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iBWMFI
   BWMFI_handle=iBWMFI(NULL,0,VOLUME_TICK);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(BWMFI_handle<0)
     {
      Print("Объект iBWMFI не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива BWMFI[] текущими значениями индикатора iBWMFI
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(BWMFI_handle,0,0,100,true,BWMFI)) return;
  }


iMomentum

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Momentum[];                // массив для индикатора iMomentum
//---- handles for indicators
int         Momentum_handle;           // указатель на индикатор iMomentum
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iMomentum
   Momentum_handle=iMomentum(NULL,0,14,PRICE_CLOSE);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(Momentum_handle<0)
     {
      Print("Объект iMomentum не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива Momentum[] текущими значениями индикатора iMomentum
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(Momentum_handle,0,0,100,true,Momentum)) return;
  }

iMFI

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      MFI[];                // массив для индикатора iMFI
//---- handles for indicators
int         MFI_handle;           // указатель на индикатор iMFI
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iMFI
   MFI_handle=iMFI(NULL,0,14,VOLUME_TICK);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(MFI_handle<0)
     {
      Print("Объект iMFI не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива MFI[] текущими значениями индикатора iMFI
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(MFI_handle,0,0,100,true,MFI)) return;
  }


iMA

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      MA[];                // массив для индикатора iMA
//---- handles for indicators
int         MA_handle;           // указатель на индикатор iMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iMA
   MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(MA_handle<0)
     {
      Print("Объект iMA не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива MA[] текущими значениями индикатора iMA
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(MA_handle,0,0,100,true,MA)) return;
  }

iOsMA

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      OsMA[];                // массив для индикатора iOsMA
//---- handles for indicators
int         OsMA_handle;           // указатель на индикатор iOsMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iOsMA
   OsMA_handle=iOsMA(NULL,0,8,21,14,PRICE_MEDIAN);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(OsMA_handle<0)
     {
      Print("Объект iOsMA не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива OsMA[] текущими значениями индикатора iOsMA
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(OsMA_handle,0,0,100,true,OsMA)) return;
  }


iMACD

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Main[];    // массив для MAIN_LINE индикатора iMACD
double      Signal[];  // массив для SIGNAL_LINE индикатора iMACD
//---- handles for indicators
int         MACD_handle;           // указатель на индикатор iMACD
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iMACD
   MACD_handle=iMACD(NULL,0,12,26,9,PRICE_CLOSE);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(MACD_handle<0)
     {
      Print("Объект iMACD не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- задаём порядок индексации массивов как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
//--- заполнение объявленных массивов текущими значениями из всех индикаторных буферов
   if(!GetMACDBuffers(MACD_handle,0,100,Main,Signal,true)) return;
  }

iOBV

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      OBV[];                // массив для индикатора iOBV
//---- handles for indicators
int         OBV_handle;           // указатель на индикатор iOBV
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iOBV
   OBV_handle=iOBV(NULL,0,VOLUME_TICK);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(OBV_handle<0)
     {
      Print("Объект iOBV не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива OBV[] текущими значениями индикатора iOBV
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(OBV_handle,0,0,100,true,OBV)) return;
  }

iSAR

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      SAR[];                // массив для индикатора iSAR
//---- handles for indicators
int         SAR_handle;           // указатель на индикатор iSAR
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iSAR
   SAR_handle=iSAR(NULL,0,0.02,0.2);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(SAR_handle<0)
     {
      Print("Объект iSAR не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива SAR[] текущими значениями индикатора iSAR
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(SAR_handle,0,0,100,true,SAR)) return;
  }

iRSI

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      RSI[];                // массив для индикатора iRSI
//---- handles for indicators
int         RSI_handle;           // указатель на индикатор iRSI
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iRSI
   RSI_handle=iRSI(NULL,0,21,PRICE_CLOSE);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(RSI_handle<0)
     {
      Print("Объект iRSI не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива RSI[] текущими значениями индикатора iRSI
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(RSI_handle,0,0,100,true,RSI)) return;
  }

iRVI

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Main[];    // массив для MAIN_LINE индикатора iRVI
double      Signal[];  // массив для SIGNAL_LINE индикатора iRVI
//---- handles for indicators
int         RVI_handle;           // указатель на индикатор iRVI
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iRVI
   RVI_handle=iRVI(NULL,0,14);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(RVI_handle<0)
     {
      Print("Объект iRVI не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- задаём порядок индексации массивов как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
//--- заполнение объявленных массивов текущими значениями из всех индикаторных буферов
   if(!GetRVIBuffers(RVI_handle,0,100,Main,Signal,true)) return;
  }

iStdDev

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      StdDev[];                // массив для индикатора iStdDev
//---- handles for indicators
int         StdDev_handle;           // указатель на индикатор iStdDev
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iStdDev
   StdDev_handle=iStdDev(NULL,0,20,0,MODE_SMA,PRICE_CLOSE);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(StdDev_handle<0)
     {
      Print("Объект iStdDev не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива StdDev[] текущими значениями индикатора iStdDev
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(StdDev_handle,0,0,100,true,StdDev)) return;
  }


iStochastic

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Main[];    // массив для MAIN_LINE индикатора iStochastic
double      Signal[];  // массив для SIGNAL_LINE индикатора iStochastic
//---- handles for indicators
int         Stochastic_handle;           // указатель на индикатор iStochastic
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iStochastic
   Stochastic_handle=iStochastic(NULL,0,5,3,3,MODE_SMA,STO_LOWHIGH);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(Stochastic_handle<0)
     {
      Print("Объект iStochastic не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- задаём порядок индексации массивов как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
//--- заполнение объявленных массивов текущими значениями из всех индикаторных буферов
   if(!GetStochasticBuffers(Stochastic_handle,0,100,Main,Signal,true)) return;
  }


iTEMA

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      TEMA[];                // массив для индикатора iTEMA
//---- handles for indicators
int         TEMA_handle;           // указатель на индикатор iTEMA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iTEMA
   TEMA_handle=iTEMA(NULL,0,20,0,PRICE_CLOSE);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(TEMA_handle<0)
     {
      Print("Объект iTEMA не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива TEMA[] текущими значениями индикатора iTEMA
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(TEMA_handle,0,0,100,true,TEMA)) return;
  }


iTriX

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      TriX[];                // массив для индикатора iTriX
//---- handles for indicators
int         TriX_handle;           // указатель на индикатор iTriX
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iTriX
   TriX_handle=iTriX(NULL,0,20,PRICE_CLOSE);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(TriX_handle<0)
     {
      Print("Объект iTriX не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива TriX[] текущими значениями индикатора iTriX
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(TriX_handle,0,0,100,true,TriX)) return;
  }


iWPR

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      WPR[];                // массив для индикатора iWPR
//---- handles for indicators
int         WPR_handle;           // указатель на индикатор iWPR
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iWPR
   WPR_handle=iWPR(NULL,0,14);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(WPR_handle<0)
     {
      Print("Объект iWPR не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива WPR[] текущими значениями индикатора iWPR
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(WPR_handle,0,0,100,true,WPR)) return;
  }


iVIDyA

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      VIDyA[];                // массив для индикатора iVIDyA
//---- handles for indicators
int         VIDyA_handle;           // указатель на индикатор iVIDyA
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iVIDyA
   VIDyA_handle=iVIDyA(NULL,0,14,21,0,PRICE_MEDIAN);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(VIDyA_handle<0)
     {
      Print("Объект iVIDyA не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива VIDyA[] текущими значениями индикатора iVIDyA
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(VIDyA_handle,0,0,100,true,VIDyA)) return;
  }


iVolumes

#include <GetIndicatorBuffers.mqh>
//---- indicator buffers
double      Volumes[];                // массив для индикатора iVolumes
//---- handles for indicators
int         Volumes_handle;           // указатель на индикатор iVolumes
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- создание указателя на объект - индикатор iVolumes
   Volumes_handle=iVolumes(NULL,0,VOLUME_TICK);
//--- если произошла ошибка при создании объекта, то выводим сообщение
   if(Volumes_handle<0)
     {
      Print("Объект iVolumes не создан: Ошибка исполнения = ",GetLastError());
      //--- принудительное завершение программы
      return(-1);
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- заполнение массива Volumes[] текущими значениями индикатора iVolumes
//--- задаём порядок индексации массива как в таймсерии
//--- если произошла ошибка, то прекращаем выполнение дальнейших операций
   if(!CopyBufferAsSeries(Volumes_handle,0,0,100,true,Volumes)) return;
  }

Заключение

  1. Использовать стандартные технические индикаторы в экспертах на языке MQL5 так же элементарно, как и в предыдущей версии.
  2. При разработке своих экспертов, используйте только безопасные методы программирования - анализируйте и исключайте все возможные ошибки. Ведь цена их слишком велика - это ваш депозит!
Прикрепленные файлы |
Aslanbiy Botashev
Aslanbiy Botashev | 13 сен 2015 в 09:31
Здравствуйте! А вот еще один вопрос к Вам: Как получить значений технического индикатора Heiken Ashi или ZigZagColor в своих экспертах? Есть такой пример?
Rashid Umarov
Rashid Umarov | 14 сен 2015 в 11:22
Aslanbiy Botashev:
Здравствуйте! А вот еще один вопрос к Вам: Как получить значений технического индикатора Heiken Ashi или ZigZagColor в своих экспертах? Есть такой пример?
Например, поискать статью на эту тему - Пример торговой системы на основе индикатора Heiken-Ashi
Aslanbiy Botashev
Aslanbiy Botashev | 14 сен 2015 в 13:07
Rashid Umarov:
Например, поискать статью на эту тему - Пример торговой системы на основе индикатора Heiken-Ashi

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

Вариант кода предоставляю:

         double ExtColorBuffer[2];         
         if (CopyBuffer(hHeiken_Ashi,4, 0, 2, ExtColorBuffer)<0) return;


         if (ExtColorBuffer[0]==0.0);  // DodgerBlue

         if (ExtColorBuffer[1]==1.0);  // Red
Только остается искать код закрытия ордеров. Даже стесняюсь часто спрашивать. :-D
Пользовательские индикаторы в MQL5 для начинающих Пользовательские индикаторы в MQL5 для начинающих

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

Порядок создания и уничтожения объектов в MQL5 Порядок создания и уничтожения объектов в MQL5

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

Способы вызова индикаторов в MQL5 Способы вызова индикаторов в MQL5

C появлением новой версии языка MQL, не только изменился подход к работе с индикаторами, но и появились новые способы создания индикаторов. Кроме того, появилась дополнительная гибкость при работе с индикаторными буферами - теперь вы можете самостоятельно указать нужное направление индексации и получать ровно столько значений индикатора, сколько вам требуется. В этой статье рассмотрены базовые методы вызова индикаторов и получения данных из индикаторных буферов.

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

Предположим, что на чарт наброшен индикатор простого мувинга с периодом 13. А мы хотим изменить период до 20, но нам не хочется лезть в диалог свойств индикатора и править число 13 на 20: надоело уже пальцы стирать об мышку и клавиатуру. И уж тем более не хочется открывать код индикатора и модифицировать его. Мы хотим сделать все это однократным нажатием одной клавиши - "стрелочки вверх", расположенной рядом с цифровой клавиатурой. В этой публикации мы расскажем, как это сделать.