MQL5 для "чайников": Получение значений технических индикаторов в своих экспертах
MetaTrader 5
—
Индикаторы
| 5 марта 2010, 12:09
30 594
3
Введение
Редкий эксперт или индикатор обходится без использования в своём коде стандартных технических индикаторов. Они популярны как у начинающих, так и у продвинутых разработчиков торговых стратегий. Разобраться в особенностях создания того или иного индикатора не так уж и сложно, но чтобы облегчить этот процесс и написана эта статья. Речь пойдёт в ней об использовании функций для работы с техническими индикаторами.
Общий принцип использования функций стандартных индикаторов
Каждая функция технического индикатора при вызове создаёт указатель (хэндл) на созданный объект (копию индикатора) с конкретными входными параметрами. Сам по себе указатель ничего не даёт, кроме как привязки его к объекту. Но этого вполне достаточно для того, чтобы получать данные из индикаторных буферов и использовать их в своих расчётах. Рассмотрим на примере:
//---- 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().
Необходимые пояснения:
- Что означает: "задаём порядок индексации массива MA[] как в MQL4"? А говорит это о том, что в данном примере используется индексация как в таймсерии. Другими словами, текущий (не сформировавшийся) бар всегда имеет индекс [0], а предыдущий (сформировавшийся бар) - соответствует индексу [1] и т.д.
- Зачем задавать порядок индексации? Для удобства и оптимальной реализации того или иного алгоритма, программист самостоятельно решает, какую применить индексацию в каждом конкретном случае, а MQL5 готов к любому развитию событий.
- Почему же указатель индикатора целесообразней всего создавать именно в функции OnInit()? По большому счёту, это можно делать где угодно в программе - явных запретов нет. Однако, есть весомый аргумент в пользу предлагаемого варианта: функция OnInit() вызывается один раз при запуске эксперта, а этого вполне достаточно для инициализации индикаторов, у которых входные параметры не меняют своих значений время исполнения. И даже если такое изменение входных параметров предусмотрено алгоритмом, то никто не запрещает вызвать функцию инициализации ещё раз из любой другой функции, например OnTick().
Уроки программирования
Практически любой эксперт предназначен для совершения торговых операций и не только на демо, но и на реальном счёте. И чтобы доверить ему самостоятельную торговлю, и при этом спать спокойно, надо заранее предусмотреть все возможные последствия его действий. Программисты МТС, даже высокого уровня, иногда допускают ошибки, причём очень "детские". А цена такой ошибки может быть очень высока!
Так на чемпионате по автотрейдингу в 2008 году был такой эпизод. Торговый робот одного из участников, после того как увеличил депозит до определённого уровня, должен был прекратить торговлю и уснуть до окончания чемпионата. Так он и сделал. И как же был удивлён автор и все кто следил за работой его эксперта, когда робот неожиданно проснулся и начал опять торговать, сливая при этом заработанный депозит!
Вы же не хотите совершать подобные ошибки, когда робот выходит из-под контроля? Тогда давайте рассмотрим, какие "подводные камни" могут быть при использовании стандартных индикаторов:
- Указатель на объект создаётся в блоке инициализации, а что если он при этом так и не создался? А мы будем потом обращаться к тому, чего нет. Поэтому, воспользуемся предоставленной нам разработчиками MQL5 возможностью это проверить. Если указатель не создан, то значение переменной будет возвращено равным стандартной константе INVALID_HANDLE = -1.
- Значения индикаторных буферов мы записываем в массив, а затем используем их в своих расчётах. А что если в этот массив, по какой-то причине, ничего не записалось? Следовательно, торговая система будет выдавать ошибочные сигналы или что-то в этом роде. Для этого случая, разработчики языка опять позаботились о нас, и предлагают проверять количество скопированных элементов сразу, "не отходя от кассы". Если произошла ошибка, то количество скопированных элементов будет равно -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; }
Заключение
- Использовать стандартные технические индикаторы в экспертах на языке MQL5 так же элементарно, как и в предыдущей версии.
- При разработке своих экспертов, используйте только безопасные методы программирования - анализируйте и исключайте все возможные ошибки. Ведь цена их слишком велика - это ваш депозит!
Прикрепленные файлы |
getindicatorbuffers.mqh
(12.61 KB)
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Способы вызова индикаторов в MQL5
C появлением новой версии языка MQL, не только изменился подход к работе с индикаторами, но и появились новые способы создания индикаторов. Кроме того, появилась дополнительная гибкость при работе с индикаторными буферами - теперь вы можете самостоятельно указать нужное направление индексации и получать ровно столько значений индикатора, сколько вам требуется. В этой статье рассмотрены базовые методы вызова индикаторов и получения данных из индикаторных буферов.
Пользовательские индикаторы в MQL5 для начинающих
Любой новый предмет для новичка с первого взгляда кажется сложным для понимания. Нам кажется простым и ясным то, что мы уже знаем. Но мы просто не помним, что всем нам когда-то приходилось изучать с нуля, даже родной язык, на котором мы разговариваем. Так и язык MQL5, таящий в себе огромные возможности для написания торговых стратегий, можно начать изучать с базовых понятий и примеров. В этой статье на примере пользовательского индикатора SMA рассматривается взаимодействие технического индикатора с клиентским терминалом MetaTrader 5.
MQL5, обработка событий: Изменяем период мувинга "на лету"
Предположим, что на чарт наброшен индикатор простого мувинга с периодом 13. А мы хотим изменить период до 20, но нам не хочется лезть в диалог свойств индикатора и править число 13 на 20: надоело уже пальцы стирать об мышку и клавиатуру. И уж тем более не хочется открывать код индикатора и модифицировать его. Мы хотим сделать все это однократным нажатием одной клавиши - "стрелочки вверх", расположенной рядом с цифровой клавиатурой. В этой публикации мы расскажем, как это сделать.
Порядок создания и уничтожения объектов в MQL5
Каждый объект, будь то пользовательский объект, динамический массив или массив объектов, имеет свои особенности создания и уничтожения в программе MQL5. Зачастую одни объекты являются частью других объектов, и порядок уничтожения объектов в момент деинициализации становится особенно важен. В этой статье приводятся несколько примеров для понимания механизмов работы с объектами.
Вы упускаете торговые возможности:
- Бесплатные приложения для трейдинга
- 8 000+ сигналов для копирования
- Экономические новости для анализа финансовых рынков
Регистрация
Вход
Вы принимаете политику сайта и условия использования
Если у вас нет учетной записи, зарегистрируйтесь
Опубликована статья MQL5 для "чайников": Получение значений технических индикаторов в своих экспертах:
Автор: Sergey
Здравствуйте! А вот еще один вопрос к Вам: Как получить значений технического индикатора Heiken Ashi или ZigZagColor в своих экспертах? Есть такой пример?
Например, поискать статью на эту тему - Пример торговой системы на основе индикатора Heiken-Ashi
Спасибо! Да, я это еще раньше скачал этот пример и разобрал. Нашел упрошенный вариант копирования буферов.
Вариант кода предоставляю:
Только остается искать код закрытия ордеров. Даже стесняюсь часто спрашивать. :-D