MQL5 para Novatos: Guia para o Uso de Indicadores Técnicos em Expert Advisors
MetaTrader 5
—
Indicadores
| 23 dezembro 2013, 16:20
9 078
1
Introdução
Um Expert Advisor ou indicador que não usa indicadores técnicos padrão em seu código é raro. Eles são populares tanto para iniciantes quanto para desenvolvedores avançados em estratégias de negociação. Não é difícil de entender os detalhes da criação de um indicador; o objetivo deste artigo é para ajudá-lo com isso. Vamos considerar o uso de funções para trabalhar com indicadores técnicos internos padrão.
Fundamentos do uso de funções de indicadores técnicos padrão
Quando chamado, cada função de um indicador técnico cria um manipulador do objeto criado (instância do indicador) com parâmetros de entrada especificados. A finalidade do manipulador é atribuí-lo a esse objeto. Basta obter os dados do buffer de indicador e usá-lo em seus próprios cálculos. Considere um exemplo:
double MA[]; // array para o indicador iMA int MA_handle; // manipulador do indicador iMA //+------------------------------------------------------------------+ //| Função de inicialização do Expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iMA MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE); return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array MA[] com os valores atuais de iMA //--- Copiando 100 elementos CopyBuffer(MA_handle,0,0,100,MA); //--- Definindo os elementos de indexagem em série, como no MQL4 ArraySetAsSeries(MA,true); //--- Aqui você pode usar os dados de MA[] como você desejar, por exemplo: if(MA[0]>MA[1]) { //--- Algumas operações } }
Como vemos, tudo é muito simples. Este exemplo mostra como usar o indicador iMA - o mais popular entre os traders.
O manipulador do indicador deve ser criado dentro da função OnInit()
- "Definindo os elementos de indexagem em série, como no MQL4"- o que isso significa? Em nosso exemplo, nós usamos os elementos de indexagem como timeseries. Em outras palavras, a barra atual (que ainda não foi formada) sempre terá índice [0], o anterior (já formado) tem índice [1], etc.
- Por que nós definimos a indexagem? Usamos isso para a conveniência e pela execução adequada do algoritmo. A linguagem MQL5 permite usar a indexagem conveniente para o programador.
- Por que é melhor criar um indicador dentro da função OnInit()? Naturalmente, ele pode ser criado em qualquer lugar do programa, pois não há qualquer restrição explícita. No entanto, há um forte argumento em favor da forma proposta: a função OnInit() é chamada uma única vez no início de um Expert Advisor, ela é suficiente para executar a inicialização dos indicadores, que não mudam seus parâmetros durante a execução. Para o caso de haver mudanças nos parâmetros de entrada, é possível inicializá-los novamente dentro de outra função,por exemplo, na função OnTick().
Ensinamentos de programação
Quase todo Expert Advisor é projetado para executar operações de negócio não só em contas de demonstração, mas também em uma conta real. Se você quiser dormir tranquilamente quando ele negocia, você deve prever todos os resultados possíveis de seu negócio. Até mesmo desenvolvedores altamente qualificados de sistemas automáticos de negociação muitas vezes cometem erros irritantes. E o preço de tal erro pode ser muito alto!
Por exemplo, aqui está uma história que aconteceu no Automated Trading Championship 2008. Um Expert Advisor de um dos participantes deve aumentar seu depósito para um determinado nível e dormir. Isso foi feito. O autor e todos que estavam assistindo o trabalho do Expert Advisor ficaram surpreendidos, quando ele acordou e começou a negociar novamente, perdendo o dinheiro ganho.
Claro, você não quer cometer os erros similares quando o robô fica fora de controle. Então, vamos considerar os "recifes" que podem ser detectados durante a utilização dos indicadores técnicos padrão:
- O ponteiro do objeto é criado no bloco de inicialização. E se ele fosse mal sucedido? Neste caso, teremos uma referência vazia. Portanto, vamos usar a possibilidade de verificar a sua validade, que foi fornecida pelos desenvolvedores do MQL5. Se o ponteiro não foi criado, o valor de seu manipulador, retornado pela função, será igual a constante padrão INVALID_HANDLE = -1.
- Quando recebermos os dados do indicador, estamos copiando os seus valores para o buffer do indicador para usá-los em nossos cálculos. E se falhar? Se a cópia falhar, o sistema de negociação pode gerar sinais de negócio errados. Para tais casos, os desenvolvedores MQL5 forneceram a possibilidade de verificação imediata do número de elementos copiados. O número de elementos copiados no caso de um erro será igual a -1.
Agora vamos considerar como isso pode ser programado:
//---- arrays para os indicadores double MA[]; // array para o indicador iMA //---- manipulador de indicadores int MA_handle; // manipulador do indicador iMA //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iMA MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE); //--- informar se houve um erro na criação do objeto if(MA_handle<0) { Print("A criação do IMA falhou: MA_handle=",INVALID_HANDLE); Print("Erro de tempo de execução = ",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array MA[] com os valores atuais de iMA //--- 100 elementos devem ser escritos para o array //--- se houver um erro, nós encerramos a execução do programa if(CopyBuffer(MA_handle,0,0,100,MA)<=0) return; //--- Definindo a indexagem do array MA[] como timeseries ArraySetAsSeries(MA,true); //--- Aqui você pode usar os dados de MA[] como você desejar if(MA[0]>MA[1]) { //--- algumas operações } }
Observe que apenas uma pequena alteração no código aumentou sua segurança e confiabilidade. No entanto, isso não é tudo. Agora o processo de cópia dos valores do indicador para o array pode ser melhorado, é necessário usar a função que foi escrita:
//+------------------------------------------------------------------------------+ //| A função copia os valores do indicador,os elementos | //| serão indexados dependendo do valor do parâmetro de entrada asSeries | //+------------------------------------------------------------------------------+ bool CopyBufferAsSeries( int handle, // manipulador do indicador int bufer, // índice do buffer int start, // início do índice int number, // número de elementos para copiar bool asSeries, // se for verdade, os elementos serão indexados como série double &M[] // array alvo ) { //--- Preenchimento do array M com os valores atuais do indicador if(CopyBuffer(handle,bufer,start,number,M)<=0) return(false); //--- os elementos serão indexados como segue: //--- se asSeries = true, ele será indexado como timeseries //--- se asSeries = false, ele será indexado como padrão ArraySetAsSeries(M,asSeries); //--- return(true); }
A função CopyBufferAsSeries está localizada no arquivo GetIndicatorBuffers.mqh, que está anexado ao artigo. Para a sua utilização, nós temos que adicionar a diretiva include em nosso código. É necessário copiá-lo para a pasta ..\ MQL5\Include\. O código final, que chama o indicador iMA e copia os dados do buffer do indicador para o array correspondente, segue abaixo:
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double MA[]; // array para o indicador iMA //---- manipulador de indicadores int MA_handle; // manipulador para o indicador iMA //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- criação do indicador iMA MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE); //--- informar se houve um erro na criação do objeto if(MA_handle<0) { Print("A criação do IMA falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array MA[] com os valores atuais de iMA //---Definindo a indexagem do array MA[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(MA_handle,0,0,100,true,MA)) return; //--- Aqui você pode usar os dados de MA[] como você desejar, por exemplo: if(MA[0]>MA[1]) { //--- algumas operções } }
Características de Multi-Buffer de Indicadores
Como exemplo, vamos considerar o indicador iAlligator, que possui 3 buffers de indicador:
- buffer 0 - GATORJAW_LINE
- buffer 1 - GATORTEETH_LINE
- buffer 2 - GATORLIPS_LINE
Para executar os dados recebidos a partir dos buffers de indicadores utilizando apenas uma chamada, vamos usar a seguinte função, que pode ser encontrada no arquivo anexado ao artigo:
//+------------------------------------------------------------------------------+ //| A função copia os valores do indicador Alligator para três arrays: | //| Jaws[], Teeth[], Lips[] (com elementos indexados como timeaseries). | //+------------------------------------------------------------------------------+ bool GetAlligatorBuffers(int Alligator_handle, int start, int number, double &Jaws[], double &Teeth[], double &Lips[], bool asSeries=true // (elementos indexados como timeaseries) ) { //--- Preenchimento do array Jaws com os valores atuais de GATORJAW_LINE if(!CopyBufferAsSeries(Alligator_handle,0,start,number,asSeries,Jaws)) return(false); //--- Preenchimento do array Teeth com os valores atuais de GATORTEETH_LINE if(!CopyBufferAsSeries(Alligator_handle,1,start,number,asSeries,Teeth)) return(false); //--- Preenchimento do array Lisp com os valores atuais de GATORLIPS_LINE if(!CopyBufferAsSeries(Alligator_handle,2,start,number,asSeries,Lips)) return(false); //--- return(true); }
Isso pode ser usado da seguinte maneira:
#include <GetIndicatorBuffers.mqh> //---- buffers de indicador double Jaws[]; // array para GATORJAW_LINE do iAlligator double Teeth[]; // array para GATORTEETH_LINE do iAlligator double Lips[]; // array para GATORLIPS_LINE do iAlligator //---- manipulador de indicatores int Alligator_handle; // manipulador para o indicador iAlligator //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- criação do indicador iAlligator Alligator_handle=iAlligator(NULL,0,13,8,8,5,5,3,MODE_EMA,PRICE_MEDIAN); //--- informar se houve um erro na criação do objeto if(Alligator_handle<0) { Print("A criação do iAlligator falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Definindo a indexagem do array como timeseries //--- Preenchimento dos arrays com os valores atuais de Alligator //--- return se houve um erro if(!GetAlligatorBuffers(Alligator_handle,0,100,Jaws,Teeth,Lips,true)) return; }
Então, descrevemos os pontos-chave, agora estamos prontos para considerar os exemplos para todos os indicadores padrão.
Exemplos de utilização de indicadores padrão
iAC
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double AC[]; // array para o indicador iAC //---- manipulador de indicadores int AC_handle; // manipulador do indicador iAC //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iAC AC_handle=iAC(NULL,0); //--- informar se houve um erro na criação do objeto if(AC_handle<0) { Print("A criação do iAC falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array AC[] com os valores atuais do iAC //--- Definindo a indexagem do array AC[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(AC_handle,0,0,100,true,AC)) return; }
iAD
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double AD[]; // array para o indicador iAD //---- manipulador de indicadores int AD_handle; // manipulador do indicador iAD //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iAD AD_handle=iAD(NULL,0,VOLUME_TICK); //--- informar se houve um erro na criação do objeto if(AD_handle<0) { Print("A criação do iAD falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array AD[] com os valores atuais do iAD //--- Definindo a indexagem do array AD[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(AD_handle,0,0,100,true,AD)) return; }
iADX
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Main[]; // array para MAIN_LINE do iADX double PlusDI[]; // array para PLUSDI_LINE do iADX double MinusDI[]; // array para MINUSDI_LINE do iADX //---- manipulador de indicadores int ADX_handle; // manipulador do indicador iADX //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iADX ADX_handle=iADX(NULL,0,14); //--- informar se houve um erro na criação do objeto if(ADX_handle<0) { Print("A criação do iADX falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Definindo a indexagem dos arrays como timeseries //--- Preenchimento dos arrays com os valores atuais de todos os buffers de indicador //--- return se houve um erro if(!GetADXBuffers(ADX_handle,0,100,Main,PlusDI,MinusDI,true)) return; }
iADXWilder
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Main[]; // array para MAIN_LINE do iADXWilder double PlusDI[]; // array para PLUSDI_LINE do iADXWilder double MinusDI[]; // array para MINUSDI_LINE do iADXWilder //---- manipulador de indicadores int ADXWilder_handle; // manipulador do indicador iADXWilder //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iADXWilder ADXWilder_handle=iADXWilder(NULL,0,14); //--- informar se houve um erro na criação do objeto if(ADXWilder_handle<0) { Print("A criação do iADXWilder falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Definindo a indexagem dos arrays como timeseries //--- Preenchimento dos arrays com os valores atuais de todos os buffers de indicador //--- return se houve um erro if(!GetADXWilderBuffers(ADXWilder_handle,0,100,Main,PlusDI,MinusDI,true)) return; }
iAlligator
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Jaws[]; // array para GATORJAW_LINE do iAlligator double Teeth[]; // array para GATORTEETH_LINE do iAlligator double Lips[]; // array para GATORLIPS_LINE do iAlligator //---- manipulador de indicadores int Alligator_handle; // manipulador do indicador iAlligator //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iAlligator Alligator_handle=iAlligator(NULL,0,13,8,8,5,5,3,MODE_EMA,PRICE_MEDIAN); //--- informar se houve um erro na criação do objeto if(Alligator_handle<0) { Print("A criação do iAlligator falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Definindo a indexagem dos arrays como timeseries //--- Preenchimento dos arrays com os valores atuais de todos os buffers de indicador //--- return se houve um erro if(!GetAlligatorBuffers(Alligator_handle,0,100,Jaws,Teeth,Lips,true)) return; }
iAMA
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double AMA[]; // array para o indicador iAMA //---- manipulador de indicadores int AMA_handle; // manipulador do indicador iAMA //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iAMA AMA_handle=iAMA(NULL,0,21,5,8,0,PRICE_CLOSE); //--- informar se houve um erro na criação do objeto if(AMA_handle<0) { Print("A criação do iAMA falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array AMA[] com os valores atuais de iAMA //--- Definindo a indexagem do array AMA[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(AMA_handle,0,0,100,true,AMA)) return; }
iAO
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double AO[]; // array para o indicador iAO //---- manipulador de indicadores int AO_handle; // manipulador do indicador iAO //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iAO AO_handle=iAO(NULL,0); //--- informar se houve um erro na criação do objeto if(AO_handle<0) { Print("A criação do iAO falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array AO[] com os valores atuais de iAO //--- Definindo a indexagem do array AO[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(AO_handle,0,0,100,true,AO)) return; }
iATR
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double ATR[]; // array para o indicador iATR //---- manipulador de indicadores int ATR_handle; // manipulador do indicador iATR //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iATR ATR_handle=iATR(NULL,0,14); //--- informar se houve um erro na criação do objeto if(ATR_handle<0) { Print("A criação do iATR falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array ATR[] com os valores atuais de iATR //--- Definindo a indexagem do array ATR[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(ATR_handle,0,0,100,true,ATR)) return; }
iBearsPower
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double BearsPower[]; // array para o indicador iBearsPower //---- manipulador de indicadores int BearsPower_handle; // manipulador do indicador iBearsPower //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iBearsPower BearsPower_handle=iBearsPower(NULL,0,14); //--- informar se houve um erro na criação do objeto if(BearsPower_handle<0) { Print("A criação do iBearsPower falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array BearsPower[] com os valores atuais de iBearsPower //--- Definindo a indexagem do array BearsPower[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(BearsPower_handle,0,0,100,true,BearsPower)) return; }
iBands
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Base[]; // array para BASE_LINE do iBands double Upper[]; // array para UPPER_BAND do iBands double Lower[]; // array para LOWER_BAND do iBands //---- manipulador de indicadores int Bands_handle; // manipulador do indicador iBands //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iBands Bands_handle=iBands(NULL,0,144,0,2,PRICE_CLOSE); //--- informar se houve um erro na criação do objeto if(Bands_handle<0) { Print("A criação do iBands falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Definindo a indexagem dos arrays como timeseries //--- Preenchimento dos arrays com os valores atuais de todos os buffers de indicador //--- return se houve um erro if(!GetBandsBuffers(Bands_handle,0,100,Base,Upper,Lower,true)) return; }
iBullsPower
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double BullsPower[]; // array para o indicador iBullsPower //---- manipulador de indicadores int BullsPower_handle; // manipulador do indicadoriBullsPower //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iBullsPower BullsPower_handle=iBullsPower(NULL,0,14); //--- informar se houve um erro na criação do objeto if(BullsPower_handle<0) { Print("A criação do iBullsPower falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array BullsPower[] com os valores atuais de iBullsPower //--- Definindo a indexagem do array BullsPower[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(BullsPower_handle,0,0,100,true,BullsPower)) return; }
iCCI
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double CCI[]; // array para o indicador iCCI //---- manipulador de indicadores int CCI_handle; // manipulador do indicador iCCI //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iCCI CCI_handle=iCCI(NULL,0,14,PRICE_CLOSE); //--- informar se houve um erro na criação do objeto if(CCI_handle<0) { Print("A criação do iCCI falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array CCI[] com os valores atuais de iCCI //--- Definindo a indexagem do array CCI[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(CCI_handle,0,0,100,true,CCI)) return; }
iChaikin
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Chaikin[]; // array para o indicador iChaikin //---- manipulador de indicadores int Chaikin_handle; // manipulador do indicador iChaikin //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iChaikin Chaikin_handle=iChaikin(NULL,0,8,14,MODE_EMA,VOLUME_TICK); //--- informar se houve um erro na criação do objeto if(Chaikin_handle<0) { Print("A criação do iChaikin falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array Chaikin[] com os valores atuais de iChaikin //--- Definindo a indexagem do array AC[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(Chaikin_handle,0,0,100,true,Chaikin)) return; }
iDEMA
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double DEMA[]; // array para o indicador iDEMA //---- manipulador de indicadores int DEMA_handle; // manipulador do indicador iDEMA //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iDEMA DEMA_handle=iDEMA(NULL,0,8,0,PRICE_CLOSE); //--- informar se houve um erro na criação do objeto if(DEMA_handle<0) { Print("A criação do iDEMA falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array DEMA[] com os valores atuais de iDEMA //--- Definindo a indexagem do array DEMA[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(DEMA_handle,0,0,100,true,DEMA)) return; }
iDeMarker
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double DeMarker[]; // array para o indicador iDeMarker //---- manipulador de indicadores int DeMarker_handle; // manipulador do indicador iDeMarker //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iDeMarker DeMarker_handle=iDeMarker(NULL,0,21); //--- informar se houve um erro na criação do objeto if(DeMarker_handle<0) { Print("A criação do iDeMarker falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array DeMarker[] com os valores atuais de iDeMarker //--- Definindo a indexagem do array DeMarker[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(DeMarker_handle,0,0,100,true,DeMarker)) return; }
iEnvelopes
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Upper[]; // array para UPPER_LINE do iEnvelopes double Lower[]; // array para LOWER_LINE do iEnvelopes //---- manipulador de indicadores int Envelopes_handle; // manipulador do indicador iEnvelopes //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iEnvelopes Envelopes_handle=iEnvelopes(NULL,0,14,0,MODE_SMA,PRICE_CLOSE,0.1); //--- informar se houve um erro na criação do objeto if(Envelopes_handle<0) { Print("A criação do iEnvelopes falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Definindo a indexagem dos arrays como timeseries //--- return se houve um erro //--- Preenchimento dos arrays com os valores atuais de iEnvelopes if(!GetEnvelopesBuffers(Envelopes_handle,0,100,Upper,Lower,true)) return; }
iForce
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Force[]; // array para o indicador iForce //---- manipulador de indicadores int Force_handle; // manipulador do indicador iForce //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iForce Force_handle=iForce(NULL,0,21,MODE_SMA,VOLUME_TICK); //--- informar se houve um erro na criação do objeto if(Force_handle<0) { Print("A criação do iForce falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array Force[] com os valores atuais de iForce //--- Definindo a indexagem do array Force[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(Force_handle,0,0,100,true,Force)) return; }
iFractals
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Upper[]; // array para UPPER_LINE do iFractals double Lower[]; // array para LOWER_LINE do iFractals //---- manipulador de indicadores int Fractals_handle; // manipulador do indicador iFractals //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iFractals Fractals_handle=iFractals(NULL,0); //--- informar se houve um erro na criação do objeto if(Fractals_handle<0) { Print("A criação do iFractals falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Definindo a indexagem dos arrays como timeseries //--- Preenchimento dos arrays com os valores atuais de todos os buffers de indicador //--- return se houve um erro if(!GetFractalsBuffers(Fractals_handle,0,100,Upper,Lower,true)) return; }
iFrAMA
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double FrAMA[]; // array para o indicador iFrAMA //---- manipulador de indicadores int FrAMA_handle; // manipulador do indicador iFrAMA //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iFrAMA FrAMA_handle=iFrAMA(NULL,0,21,0,MODE_SMA); //--- informar se houve um erro na criação do objeto if(FrAMA_handle<0) { Print("A criação do iFrAMA falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array FrAMA[] com os valores atuais de iFrAMA //--- Definindo a indexagem do array FrAMA[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(FrAMA_handle,0,0,100,true,FrAMA)) return; }
iGator
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Upper[]; // array para UPPER_LINE do iGator double Lower[]; // array para LOWER_LINE do iGator //---- manipulador de indicadores int Gator_handle; // manipulador do indicador iGator //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iGator Gator_handle=iGator(NULL,0,13,8,8,5,5,3,MODE_EMA,PRICE_MEDIAN); //--- informar se houve um erro na criação do objeto if(Gator_handle<0) { Print("A criação do iGator falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Definindo a indexagem dos arrays como timeseries //--- Preenchimento dos arrays com os valores atuais de todos os buffers de indicador //--- return se houve um erro if(!GetGatorBuffers(Gator_handle,0,100,Upper,Lower,true)) return; }
iIchimoku
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Tenkansen[]; // array para TENKANSEN_LINE do iIchimoku double Kijunsen[]; // array para KIJUNSEN_LINE do iIchimoku double SenkouspanA[]; // array para SENKOUSPANA_LINE do iIchimoku double SenkouspanB[]; // array para SENKOUSPANB_LINE do iIchimoku double Chinkouspan[]; // array para CHINKOUSPAN_LINE do iIchimoku //---- manipulador de indicadores int Ichimoku_handle; // manipulador do indicador iIchimoku //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iIchimoku Ichimoku_handle=iIchimoku(NULL,0,9,26,52); //--- informar se houve um erro na criação do objeto if(Ichimoku_handle<0) { Print("A criação do iIchimoku falhou: Erro de tempo de execução =",GetLastError()); //--- forced program terminatio return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Definindo a indexagem dos arrays como timeseries //--- Preenchimento dos arrays com os valores atuais de todos os buffers de indicador //--- return se houve um erro if(!GetIchimokuBuffers(Ichimoku_handle,0,100, Tenkansen, Kijunsen, SenkouspanA, SenkouspanB, Chinkouspan, true)) return; }
iBWMFI
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double BWMFI[]; // array para o indicador iBWMFI //---- manipulador de indicadores int BWMFI_handle; // manipulador para o indicador iBWMFI //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iBWMFI BWMFI_handle=iBWMFI(NULL,0,VOLUME_TICK); //--- informar se houve um erro na criação do objeto if(BWMFI_handle<0) { Print("A criação do iBWMFI falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array BWMFI[] com os valores atuais de iBWMFI //--- Definindo a indexagem do array BWMFI[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(BWMFI_handle,0,0,100,true,BWMFI)) return; }
iMomentum
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Momentum[]; // array para o indicador iMomentum //---- manipulador de indicadores int Momentum_handle; // manipulador do indicador iMomentum //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iMomentum Momentum_handle=iMomentum(NULL,0,14,PRICE_CLOSE); //--- informar se houve um erro na criação do objeto if(Momentum_handle<0) { Print("A criação do iMomentum falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array Momentum[] com os valores atuais de iMomentum //--- Definindo a indexagem do array Momentum[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(Momentum_handle,0,0,100,true,Momentum)) return; }
iMFI
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double MFI[]; // array para o indicador iMFI //---- manipulador de indicadores int MFI_handle; // manipulador do indicador iMFI //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iMFI MFI_handle=iMFI(NULL,0,14,VOLUME_TICK); //--- informar se houve um erro na criação do objeto if(MFI_handle<0) { Print("A criação do iMFI falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array MFI[] com os valores atuais de iMFI //--- Definindo a indexagem do array MFI[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(MFI_handle,0,0,100,true,MFI)) return; }
iMA
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double MA[]; // array para o indicador iMA //---- manipulador de indicadores int MA_handle; // manipulador do indicador iMA //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iMA MA_handle=iMA(NULL,0,21,0,MODE_EMA,PRICE_CLOSE); //--- informar se houve um erro na criação do objeto if(MA_handle<0) { Print("A criação do iMA falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array MA[] com os valores atuais de iMA //--- Definindo a indexagem do array MA[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(MA_handle,0,0,100,true,MA)) return; }
iOsMA
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double OsMA[]; // array para o indicador iOsMA //---- manipulador de indicadores int OsMA_handle; // manipulador do indicador iOsMA //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iOsMA OsMA_handle=iOsMA(NULL,0,8,21,14,PRICE_MEDIAN); //--- informar se houve um erro na criação do objeto if(OsMA_handle<0) { Print("A criação do iOsMA falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array OsMA[] com os valores atuais de iOsMA //--- Definindo a indexagem do array OsMA[] timeseries //--- return se houve um erro if(!CopyBufferAsSeries(OsMA_handle,0,0,100,true,OsMA)) return; }
iMACD
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Main[]; // array para MAIN_LINE do iMACD double Signal[]; // array para SIGNAL_LINE do iMACD //---- manipulador de indicadores int MACD_handle; // manipulador do indicador iMACD //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iMACD MACD_handle=iMACD(NULL,0,12,26,9,PRICE_CLOSE); //--- informar se houve um erro na criação do objeto if(MACD_handle<0) { Print("A criação do iMACD falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Definindo a indexagem dos arrays como timeseries //--- Preenchimento dos arrays com os valores atuais de todos os buffers de indicador //--- return se houve um erro if(!GetMACDBuffers(MACD_handle,0,100,Main,Signal,true)) return; }
iOBV
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double OBV[]; // array para o indicador iOBV //---- manipulador de indicadores int OBV_handle; // manipulador do indicador iOBV //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iOBV OBV_handle=iOBV(NULL,0,VOLUME_TICK); //--- informar se houve um erro na criação do objeto if(OBV_handle<0) { Print("A criação do iOBV falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array OBV[] com os valores atuais de iOBV //--- Definindo a indexagem do array AC[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(OBV_handle,0,0,100,true,OBV)) return; }
iSAR
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double SAR[]; // array para o indicador iSAR //---- manipulador de indicadores int SAR_handle; // manipulador do indicador iSAR //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iSAR SAR_handle=iSAR(NULL,0,0.02,0.2); //--- informar se houve um erro na criação do objeto if(SAR_handle<0) { Print("A criação do iSAR falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array SAR[] com os valores atuais de iSAR //--- Definindo a indexagem do array SAR[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(SAR_handle,0,0,100,true,SAR)) return; }
iRSI
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double RSI[]; // array para o indicador iRSI //---- manipulador de indicadores int RSI_handle; // manipulador do indicador iRSI //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iRSI RSI_handle=iRSI(NULL,0,21,PRICE_CLOSE); //--- informar se houve um erro na criação do objeto if(RSI_handle<0) { Print("A criação do iRSI falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array RSI[] com os valores atuais de iRSI //--- Definindo a indexagem do array RSI[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(RSI_handle,0,0,100,true,RSI)) return; }
iRVI
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Main[]; // array para MAIN_LINE do iRVI double Signal[]; // array para SIGNAL_LINE do iRVI //---- manipulador de indicadores int RVI_handle; // manipulador do indicador iRVI //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iRVI RVI_handle=iRVI(NULL,0,14); //--- informar se houve um erro na criação do objeto if(RVI_handle<0) { Print("A criação do iRVI falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Definindo a indexagem dos arrays como timeseries //--- Preenchimento dos arrays com os valores atuais de todos os buffers de indicador //--- return se houve um erro if(!GetRVIBuffers(RVI_handle,0,100,Main,Signal,true)) return; }
iStdDev
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double StdDev[]; // array para o indicador iStdDev //---- manipulador de indicadores int StdDev_handle; // manipulador do indicador iStdDev //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iStdDev StdDev_handle=iStdDev(NULL,0,20,0,MODE_SMA,PRICE_CLOSE); //--- informar se houve um erro na criação do objeto if(StdDev_handle<0) { Print("A criação do iStdDev falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array StdDev[] com os valores atuais de iStdDev //--- Definindo a indexagem do array StdDev[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(StdDev_handle,0,0,100,true,StdDev)) return; }
iStochastic
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Main[]; // array para MAIN_LINE do iStochastic double Signal[]; // array para SIGNAL_LINE do iStochastic //---- manipulador de indicadores int Stochastic_handle; // manipulador do indicador iStochastic //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iStochastic Stochastic_handle=iStochastic(NULL,0,5,3,3,MODE_SMA,STO_LOWHIGH); //--- informar se houve um erro na criação do objeto if(Stochastic_handle<0) { Print("A criação do iStochastic falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Definindo a indexagem dos arrays como timeseries //--- Preenchimento dos arrays com os valores atuais de todos os buffers de indicador //--- return se houve um erro if(!GetStochasticBuffers(Stochastic_handle,0,100,Main,Signal,true)) return; }
iTEMA
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double TEMA[]; // array para o indicador iTEMA //---- manipulador de indicadores int TEMA_handle; // manipulador do indicador iTEMA //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iTEMA TEMA_handle=iTEMA(NULL,0,20,0,PRICE_CLOSE); //--- informar se houve um erro na criação do objeto if(TEMA_handle<0) { Print("A criação do iTEMA falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array TEMA[] com os valores atuais de iTEMA //--- Definindo a indexagem do array TEMA[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(TEMA_handle,0,0,100,true,TEMA)) return; }
iTriX
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double TriX[]; // array para o indicador iTriX //---- manipulador de indicadores int TriX_handle; // manipulador do indicador iTriX //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iTriX TriX_handle=iTriX(NULL,0,20,PRICE_CLOSE); //--- informar se houve um erro na criação do objeto if(TriX_handle<0) { Print("A criação do iTriX falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array TriX[] com os valores atuais de iTriX //--- Definindo a indexagem do array TriX[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(TriX_handle,0,0,100,true,TriX)) return; }
iWPR
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double WPR[]; // array para o indicador iWPR //---- manipulador de indicadores int WPR_handle; // manipulador do indicador iWPR //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iWPR WPR_handle=iWPR(NULL,0,14); //--- informar se houve um erro na criação do objeto if(WPR_handle<0) { Print("A criação do iWPR falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array WPR[] com os valores atuais de iWPR //--- Definindo a indexagem do array WPR[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(WPR_handle,0,0,100,true,WPR)) return; }
iVIDyA
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double VIDyA[]; // array para o indicador iVIDyA //---- manipulador de indicadores int VIDyA_handle; // manipulador do indicador iVIDyA //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iVIDyA VIDyA_handle=iVIDyA(NULL,0,14,21,0,PRICE_MEDIAN); //--- informar se houve um erro na criação do objeto if(VIDyA_handle<0) { Print("A criação do iVIDyA falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array VIDyA[] com os valores atuais de iVIDyA //--- Definindo a indexagem do array VIDyA[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(VIDyA_handle,0,0,100,true,VIDyA)) return; }
iVolumes
#include <GetIndicatorBuffers.mqh> //---- arrays para os indicadores double Volumes[]; // array para o indicador iVolumes //---- manipulador de indicadores int Volumes_handle; // manipulador do indicador iVolumes //+------------------------------------------------------------------+ //| Função de inicialização do expert | //+------------------------------------------------------------------+ int OnInit() { //--- Criação do indicador iVolumes Volumes_handle=iVolumes(NULL,0,VOLUME_TICK); //--- informar se houve um erro na criação do objeto if(Volumes_handle<0) { Print("A criação do iVolumes falhou: Erro de tempo de execução =",GetLastError()); //--- término do programa forçado return(-1); } return(0); } //+------------------------------------------------------------------+ //| Função tick do Expert | //+------------------------------------------------------------------+ void OnTick() { //--- Preenchimento do array Volumes[] com os valores atuais de iVolumes //--- Definindo a indexagem do array Volumes[] como timeseries //--- return se houve um erro if(!CopyBufferAsSeries(Volumes_handle,0,0,100,true,Volumes)) return; }
Conclusão
- A utilização de indicadores técnicos padrão nos Expert Advisors em MQL5 é tão fácil quanto na versão anterior.
- Sempre use métodos de programação seguros em seus Expert Advisors - analise e exclua todos os erros possíveis. O preço dos erros é muito alto, é seu dinheiro!
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/31
Arquivos anexados |
getindicatorbuffers.mqh
(12.96 KB)
Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.
Últimos Comentários |
Ir para discussão
(1)
moysesnunes
|
11 ago 2021 em 19:50
Caro amigo, como "novato" gostaria de agradecer pelo excelente artigo.
Introdução ao MQL5: Como escrever Expert Advisor e Custom Indicator simples
MetaQuotes Programming Language 5 (MQL5), incluído no Terminal Cliente do MetaTrader 5, tem muitas novas possibilidades e um maior desempenho, em comparação com MQL4. Este artigo irá ajudá-lo a se familiarizar com esta nova linguagem de programação. Os exemplos simples de como escrever um Expert Advisor e indicador personalizado são apresentados neste artigo. Vamos também considerar alguns detalhes da linguagem MQL5 que são necessários para entender estes exemplos.
Mergulhe rapidamente na linguagem MQL5
Você decidiu estudar a linguagem de programação das estratégias de negócio do MQL5, mas não sabe nada sobre isso? Tentamos examinar o MQL5 e o terminal MetaTrader 5 a partir do ponto de vista de iniciantes e escrevemos este pequeno artigo introdutório. Neste artigo, você pode ter uma breve ideia das possibilidades da linguagem, assim como dicas sobre como trabalhar com o MetaEditor 5 e o terminal.
Usando os Ponteiros de Objeto no MQL5
Predefinidamente, todos os objetos no MQL5 são passados por referência, mas há a possibilidade de usar os ponteiros de objeto. Porém, é necessário realizar a verificação do ponteiro, porque o objeto pode não ser inicializado. Neste caso, o programa MQL5 será finalizado com o erro crítico e descarregado. Os objetos, criados automaticamente, não causam tal erro, então, neste sentido, são bastante seguros. Neste artigo, tentaremos entender a diferença entre a referência do objeto e o ponteiro do objeto, e considere como escrever o código seguro, que usa os ponteiros.
MetaTrader 5 - Mais do que você imagina!
O terminal do cliente MetaTrader 5 foi desenvolvido a partir do zero e ultrapassa seu antecessor, é claro. A nova plataforma de negócio fornece oportunidade sem limites para negociação em qualquer mercado financeiro. Além disso, sua funcionalidade continua expandindo para oferecer conveniência e recursos ainda mais úteis. Então, não é muito difícil listar todas as inúmeras vantagens do MetaTrader 5. Tentamos brevemente descrevê-las em um artigo, e nos surpreendemos com o resultado, o artigo está longe de ser breve!
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se