Negociação Sistemática

Criando EAs com MQL5: Sinais de Negociação com Hammer/Hanging Man e Estocástico
MetaTrader5
Criando EAs com MQL5: Sinais de Negociação com Hammer/Hanging Man e Estocástico

O MQL5 Wizard permite que você crie EAs prontos com base nas classes da biblioteca padrão que acompanham o terminal do cliente (confira Criando EAs Prontos no MQL5 Wizard para mais detalhes). Essa ferramenta te ajuda a checar suas ideias de trade rapidamente, tudo que você precisa fazer é criar sua própria classe de sinais de negociação. A estrutura dessa classe e um exemplo podem ser encontrados no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação. A ideia básica é a seguinte: a classe de sinais de negociação é derivada de CExpertSignal. Depois, é necessário sobrescrever os métodos LongCondition() e ShortCondition() com seus próprios métodos. Existe um livro chamado "Estratégias dos Melhores Traders" (em russo), onde várias estratégias de trading são abordadas, e nós vamos focar nos padrões de velas de reversão, confirmados pelos osciladores como Estocástico, CCI, MFI e RSI. A melhor abordagem é criar uma classe separada, derivada de CExpertSignal para verificar a formação de padrões de velas. Para confirmar os sinais de negociação gerados pelos padrões de velas, é suficiente escrever a classe, derivada de CCandlePattern, e adicionar as funcionalidades necessárias (por exemplo, confirmação por osciladores). Aqui, vamos considerar os sinais baseados nos padrões de velas de reversão "Hammer/Hanging Man", confirmados pelo Estocástico. O módulo de sinais de trade é baseado na classe CCandlePattern, que é um exemplo simples de como criar sinais de trade com padrões de velas. 1. Padrões de velas de reversão "Hammer" e "Hanging Man" 1.1. Hammer O "Hammer" é uma vela com um corpo pequeno e uma longa sombra inferior, formada após um movimento de queda no preço. O padrão "Hammer" indica o fim de uma tendência de baixa. A cor do corpo da vela não é importante, mas um hammer bullish indica um maior potencial de alta. O corpo do padrão "Hammer" frequentemente se forma próximo ao mínimo da vela anterior. Uma longa sombra inferior e uma sombra superior curta aumentam o potencial de reversão do padrão. Fig. 1. Padrão de vela "Hammer" O reconhecimento do padrão "Hammer" é implementado no método CheckPatternHammer() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de vela "Hammer" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternHammer()   { //--- Hammer    if((MidPoint(1)<CloseAvg(2))                                && // tendência de baixa       (MathMin(Open(1),Close(1))>(High(1)-(High(1)-Low(1))/3.0)) && // corpo na parte superior 1/3       (Close(1)<Close(2)) && (Open(1)<Open(2)))                    // gap do corpo       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_HAMMER) da classe CCandlePattern é utilizado para checar a formação do padrão de vela "Hammer". 1.2. Hanging Man O "Hanging Man" é uma vela com um corpo pequeno e uma longa sombra inferior, formada após um movimento de alta no preço. O padrão "Hanging Man" indica o fim de uma tendência de alta. A cor do corpo da vela não é importante, mas uma vela bearish indica um maior potencial de baixa. O corpo do padrão "Hanging Man" frequentemente se forma próximo ao máximo da vela anterior. Uma longa sombra inferior e uma sombra superior curta aumentam o potencial de reversão do padrão. Fig. 2. Padrão de vela "Hanging Man" O reconhecimento do padrão "Hanging Man" é implementado no método CheckPatternHangingMan() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de vela "Hanging Man" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternHangingMan()   { //--- Hanging man    if((MidPoint(1)>CloseAvg(2))                                && // tendência de alta       (MathMin(Open(1),Close(1)>(High(1)-(High(1)-Low(1))/3.0)) && // corpo na parte superior 1/3       (Close(1)>Close(2)) && (Open(1)>Open(2))))                  // gap do corpo       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_HANGING_MAN) da classe CCandlePattern é utilizado para checar a formação do padrão de vela "Hanging Man". 2. Sinais de Negociação, Confirmados pelo Indicador Estocástico Os sinais de negociação para abrir posições longas ou curtas devem ser confirmados pelo oscilador Estocástico. A linha %D deve ser maior ou menor que o nível crítico correspondente (30 ou 70). O fechamento das posições abertas depende dos valores do indicador %D. Isso pode ser feito em 2 casos: se a linha %D atingiu o nível crítico oposto (80 para posição longa e 20 para posição curta) se o sinal reverso não for confirmado (quando a linha %D atinge os seguintes níveis: 20 para posição longa e 80 para posição curta) Fig. 3. Padrão "Hammer", confirmado pelo indicador Estocástico int CH_HM_Stoch::LongCondition() - verifica as condições para abrir posição longa (retorna 80) e fechar a posição curta (retorna 40); int CH_HM_Stoch::ShortCondition() - verifica as condições para abrir posição curta (retorna 80) e fechar a posição longa (retorna 40). 2.1. Abrindo Posição Longa/Fechando Posição Curta A formação do padrão "Hammer" deve ser confirmada pelo oscilador Estocástico: StochSignal(1)<30 (o valor da linha de sinal do indicador Estocástico da última barra completada deve ser menor que 30). A posição curta deve ser fechada se a linha de sinal do Estocástico cruzou para cima os níveis 20 ou 80. //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição longa, resultado=80) | //| 2) Saída do mercado (fechar posição curta, resultado=40) | //+------------------------------------------------------------------+ int CH_HM_Stoch::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do EA //--- idx=0 - neste caso o EA verifica as condições de trade a cada tick //--- idx=1 - neste caso o EA verifica as condições de trade apenas em novas barras   int idx   =StartIndex(); //--- verificação das condições para abrir posição longa //--- formação do padrão Hammer e linha de sinal<30   if (CheckCandlestickPattern(CANDLE_PATTERN_HAMMER) && (StochSignal(1)<30))      result=80; //--- verificação das condições para fechar posição curta //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo 20, para cima 80)    if((((StochSignal(1)>20) && (StochSignal(2)<20)) ||        ((StochSignal(1)>80) && (StochSignal(2)<80))))      result=40; //--- retornar resultado    return(result);   } 2.2. Abrindo Posição Curta/Fechando Posição Longa A formação do padrão "Hanging Man" deve ser confirmada pelo Estocástico: StochSignal(1)>70 (o valor da linha de sinal do indicador Estocástico da última barra completada deve ser maior que 70). A posição longa deve ser fechada se a linha de sinal do Estocástico cruzou para baixo os níveis 80 ou 20. //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição curta, resultado=80) | //| 2) Saída do mercado (fechar posição longa, resultado=40) | //+------------------------------------------------------------------+ int CH_HM_Stoch::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do EA //--- idx=0 - neste caso o EA verifica as condições de trade a cada tick //--- idx=1 - neste caso o EA verifica as condições de trade apenas em novas barras   int idx   =StartIndex(); //--- verificação das condições para abrir posição curta //--- formação do padrão Hanging Man e linha de sinal>70   if (CheckCandlestickPattern(CANDLE_PATTERN_HANGING_MAN) && (StochSignal(1)>70))      result=80; //--- verificação das condições para fechar posição longa //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo 80, para cima 20)    if((((StochSignal(1)<80) && (StochSignal(2)>80)) ||        ((StochSignal(1)<20) && (StochSignal(2)>20))))      result=40; //--- retornar resultado    return(result);   } 2.3. Criando o Expert Advisor com o MQL5 Wizard A classe CH_HM_Stoch não está incluída nas classes da biblioteca padrão, para usá-la, é necessário baixar o arquivo ach_hm_stoch.mqh (veja os anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo candlepatterns.mqh. Você poderá usá-lo no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Expert Advisor, inicie o MQL5 Wizard: Fig. 4. Criando Expert Advisor com MQL5 Wizard Vamos especificar o nome do Expert Advisor: Fig. 5. Propriedades gerais do Expert Advisor Depois disso, precisamos selecionar os módulos de sinais de negociação utilizados. Fig. 6. Propriedades de sinal do Expert Advisor No nosso caso, usamos apenas um módulo de sinais de negociação. Adicionando o módulo "Sinais baseados em Hammer/Hanging Man confirmados por Estocástico": Fig. 7. Propriedades de sinal do Expert Advisor Módulo de sinais de negociação adicionado: Fig. 8. Propriedades de sinal do Expert Advisor Você pode selecionar quaisquer propriedades de trailing, mas usaremos "Trailing Stop não utilizado": Fig. 9. Propriedades de trailing do Expert Advisor Em relação às propriedades de gerenciamento de dinheiro, usaremos "Negociação com volume fixo": Fig. 10. Propriedades de gerenciamento de dinheiro do Expert Advisor Ao pressionar o botão "Finalizar", receberemos o código do Expert Advisor gerado, localizado em Expert_AH_HM_Stoch.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrão do Expert Advisor gerado: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =10;     // Valor do limiar de sinal para abrir [0...100] input int            Signal_ThresholdClose  =10     // Valor do limiar de sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar um negócio input double         Signal_StopLevel       =50.0   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0    // Nível de Take Profit (em pontos) devem ser substituídos por: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =40;     // Valor do limiar de sinal para abrir [0...100] input int            Signal_ThresholdClose  =20     // Valor do limiar de sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar um negócio input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis de limiar para abrir e fechar posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de trade, especificamos os valores fixos do limiar: Abrir posição: 80; Fechar posição: 40. O Expert Advisor, gerado pelo MQL5 Wizard, abre e fecha posições usando os "votos" dos módulos de sinais de trade. O voto do módulo principal (como um container, que consiste em todos os módulos adicionados) também é usado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal são também usados na média de "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de trade, então precisamos levar em conta esse fato ao definir os valores de limiar. Por causa disso, o ThresholdOpen e ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, isso significa que o fechamento das posições será feito somente quando as condições de fechamento forem verdadeiras. 2.4. Resultados de Backtesting Histórico Vamos considerar o backtesting do Expert Advisor em dados históricos (EURUSD H1, período de teste: 2010.01.01-2011.03.04, PeriodK=47, PeriodD=9, PeriodSlow=13, MA_period=5). No desenvolvimento do Expert Advisor, usamos um volume fixo (Trading Fixed Lot, 0.1), o algoritmo Trailing Stop não é utilizado (Trailing não utilizado). Fig. 11. Resultados do teste do Expert Advisor, baseado em Hammer/Hanging Man + Estocástico O melhor conjunto de parâmetros de entrada pode ser encontrado usando o Strategy Tester do terminal cliente MetaTrader 5. O código do Expert Advisor, criado pelo MQL5 Wizard, está anexado em expert_ah_hm_stoch.mq5.

2011.03.21
Como Criar um Expert Advisor com MQL5: Sinais de Negociação Baseados em Harami e RSI
MetaTrader5
Como Criar um Expert Advisor com MQL5: Sinais de Negociação Baseados em Harami e RSI

O MQL5 Wizard é uma ferramenta incrível que permite criar Consultores Especializados prontos, utilizando as classes da biblioteca padrão que vem com o terminal do cliente (veja Criando Consultores Especializados Prontos no MQL5 Wizard para mais detalhes). Essa ferramenta facilita a verificação das suas ideias de negociação, tudo o que você precisa fazer é criar a sua própria classe de sinais de negociação. A estrutura dessa classe e um exemplo podem ser encontrados no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação. A ideia básica é a seguinte: a classe de sinais de negociação é derivada de CExpertSignal. Em seguida, é necessário sobrescrever os métodos virtuais LongCondition() e ShortCondition() com seus próprios métodos. Existe um livro chamado "Estratégias dos melhores traders" (em russo), onde são abordadas diversas estratégias de negociação. Neste artigo, focaremos nos padrões de vela de reversão, confirmados pelos osciladores Estocástico, CCI, MFI e RSI. O melhor jeito é criar uma classe separada, derivada de CExpertSignal para verificar a formação dos padrões de velas. Para confirmar os sinais de negociação gerados pelos padrões de velas, basta escrever uma classe, derivada de CCandlePattern e adicionar os recursos necessários (por exemplo, confirmação por osciladores). Aqui, vamos considerar os sinais baseados no padrão de vela de reversão "Bullish Harami/Bearish Harami", confirmados pelo indicador RSI. O módulo de sinais de negociação é baseado na classe CCandlePattern, que é um exemplo simples de como utilizá-la para criar sinais de negociação com padrões de velas. 1. Padrões de vela de reversão: "Bullish Harami" e "Bearish Harami" 1.1. Bullish Harami O padrão de reversão Bullish Harami se forma em uma tendência de baixa, quando uma grande candela é seguida por uma candela menor cujo corpo está localizado dentro da faixa vertical do corpo maior. Este padrão indica que a tendência de queda pode estar revertendo, sinalizando que é um bom momento para entrar em uma posição longa. A segunda candela se abre com um gap para cima. Quanto menor a segunda candela (branca), maior a probabilidade da reversão. Fig. 1. Padrão de candela "Bullish Harami" O reconhecimento do padrão "Bullish Harami" é feito pelo método CheckPatternBullishHarami() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de candela "Bullish Harami" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBullishHarami()   { //--- Bullish Harami    if((Close(1)>Open(1))              && // a última barra completada é bullish (dia branco)      ((Open(2)-Close(2)>AvgBody(1))  && // a candela anterior é bearish, seu corpo é maior que a média (long black)      ((Close(1)<Open(2))              && // preço de fechamento da candela bullish é menor que o preço de abertura da candela bearish       (Open(1)>Close(2)))             && // preço de abertura da candela bullish é maior que o preço de fechamento da candela bearish       (MidPoint(2)<CloseAvg(2)))         // tendência de baixa       return(true); //---    return(false);   }O método CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_HARAMI) da classe CCandlePattern é utilizado para verificar a formação do padrão "Bullish Harami". 1.2. Bearish Harami O padrão de reversão Bearish Harami se forma em uma tendência de alta, quando uma grande candela é seguida por uma candela menor cujo corpo está localizado dentro da faixa vertical do corpo maior. Este padrão indica que a tendência de alta pode estar revertendo, sinalizando que é um bom momento para entrar em uma posição curta. A segunda candela se abre com um gap para baixo. Quanto menor a segunda candela (preta), maior a probabilidade da reversão. Fig. 2. Padrão de candela "Bearish Harami" O reconhecimento do padrão "Bearish Harami" é feito pelo método CheckPatternBearishHarami() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de candela "Bearish Harami" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBearishHarami()   { //--- Bearish Harami    if((Close(1)<Open(1))              && // a última barra completada é bearish (dia preto)      ((Close(2)-Open(2)>AvgBody(1))  && // a candela anterior é bullish, seu corpo é maior que a média (long white)      ((Close(1)>Open(2))              && // preço de fechamento da candela bearish é maior que o preço de abertura da candela bullish       (Open(1)<Close(2)))             && // preço de abertura da candela bearish é menor que o preço de fechamento da candela bullish       (MidPoint(2)>CloseAvg(2)))         // tendência de alta       return(true); //---    return(false);   }O método CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_HARAMI) da classe CCandlePattern é utilizado para verificar a formação do padrão "Bearish Harami". 2. Sinais de negociação, confirmados pelo indicador RSI Os sinais de negociação para abrir posições longas ou curtas devem ser confirmados pelo indicador RSI. O valor do RSI deve estar abaixo/acima dos níveis críticos (40 para posição longa e 60 para posição curta). O fechamento das posições abertas depende dos valores do RSI. Isso pode ser feito em 2 casos: se o RSI atingiu o nível crítico oposto (70 para posição longa e 30 para posição curta) se o sinal inverso não for confirmado (quando o RSI atinge os níveis: 30 para posição longa e 70 para posição curta) Fig. 3. Padrão "Bullish Harami", confirmado pelo indicador RSI int CBH_BH_RSI::LongCondition() - verifica as condições para abrir posição longa (retorna 80) e fechar a posição curta (retorna 40); int CBH_BH_RSI::ShortCondition() - verifica as condições para abrir posição curta (retorna 80) e fechar a posição longa (retorna 40). 2.1. Abrir posição longa/Fechar posição curta A formação do padrão "Bullish Harami" deve ser confirmada pelo RSI: RSI(1)<40 (o valor do RSI da última barra completada deve ser menor que 40). A posição curta deve ser fechada se o indicador RSI cruzou para cima os níveis críticos 70 ou 30. //+------------------------------------------------------------------+ //| Verifica as condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição longa, resultado=80) | //| 2) Saída do mercado (fechar posição curta, resultado=40) | //+------------------------------------------------------------------+ int CBH_BH_RSI::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do EA //--- idx=0 - neste caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, o EA verifica as condições de negociação apenas em barras de notícias    int idx   =StartIndex(); //--- verificando as condições para abrir posição longa //--- formação do padrão Bullish Harami e RSI<30   if(CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_HARAMI) && (RSI(1)<40))      result=80; //--- verificando as condições para fechar posição curta //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para cima 30, para cima 70)   if(((RSI(1)>30) && (RSI(2)<30)) || ((RSI(1)>70) && (RSI(2)<70)))      result=40; //--- retornar resultado    return(result);   } 2.2. Abrir posição curta/Fechar posição longa A formação do padrão "Bearish Harami" deve ser confirmada pelo RSI: RSI(1)>60 (o valor do indicador RSI da última barra completada deve ser maior que 60). A posição longa deve ser fechada se o RSI cruzar para baixo os níveis críticos 70 ou 30. //+------------------------------------------------------------------+ //| Verifica as condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição curta, resultado=80) | //| 2) Saída do mercado (fechar posição longa, resultado=40) | //+------------------------------------------------------------------+ int CBH_BH_RSI::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do EA //--- idx=0 - neste caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, o EA verifica as condições de negociação apenas em barras de notícias    int idx   =StartIndex(); //--- verificando as condições para abrir posição curta //--- formação do padrão Bearish Harami e RSI>60   if(CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_HARAMI) && (RSI(1)>60))      result=80; //--- verificando as condições para fechar posição longa //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo 70, para baixo 30)    if(((RSI(1)<70) && (RSI(2)>70)) || ((RSI(1)<30) && (RSI(2)>30)))      result=40; //--- retornar resultado    return(result);   } 2.3. Criando o Expert Advisor usando o MQL5 Wizard A classe CBH_BH_RSI não está incluída nas classes da Biblioteca Padrão. Para usá-la, é necessário baixar o arquivo acml_rsi.mqh (veja os anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo acandlepatterns.mqh. Você pode usá-los no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Consultor Especializado, inicie o MQL5 Wizard: Fig. 4. Criando Consultor Especializado usando MQL5 Wizard Vamos especificar o nome do Consultor Especializado: Fig. 5. Propriedades gerais do Consultor Especializado Após isso, precisamos selecionar os módulos de sinais de negociação utilizados. Fig. 6. Propriedades de sinal do Consultor Especializado No nosso caso, usamos apenas um módulo de sinais de negociação. Adicionando o módulo de "Sinais baseados em Bullish Harami/Bearish Harami confirmados por RSI": Fig. 7. Propriedades de sinal do Consultor Especializado Módulo de sinais de negociação adicionado: Fig. 8. Propriedades de sinal do Consultor Especializado Você pode selecionar qualquer propriedade de trailing, mas usaremos "Trailing Stop não utilizado": Fig. 9. Propriedades de trailing do Consultor Especializado Com relação às propriedades de gerenciamento de dinheiro, usaremos "Negociação com volume fixo": Fig. 10. Propriedades de gerenciamento de dinheiro do Consultor Especializado Ao pressionar o botão "Finalizar", receberemos o código do Consultor Especializado gerado, localizado em Expert_ABH_BH_RSI.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrão do Consultor Especializado gerado: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =10;     // Valor do limite de sinal para abrir [0...100] input int            Signal_ThresholdClose  =10     // Valor do limite de sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar um negócio input double         Signal_StopLevel       =50.0   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0    // Nível de Take Profit (em pontos) devem ser substituídos por: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =40;     // Valor do limite de sinal para abrir [0...100] input int            Signal_ThresholdClose  =20     // Valor do limite de sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar um negócio input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis de limite para abrir e fechar posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de negociação, especificamos os valores fixos do limite: Abrir posição: 80; Fechar posição: 40. O Consultor Especializado gerado pelo MQL5 Wizard abre e fecha posições usando os "votos" dos módulos de sinais de negociação. O voto do módulo principal (como contêiner, que consiste em todos os módulos adicionados) também é utilizado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal também são utilizados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de negociação, então precisamos considerar esse fato ao definir os valores de limite. Por causa disso, o ThresholdOpen e ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, o que significa que o fechamento das posições será feito apenas quando as condições de fechamento forem verdadeiras. 2.4. Resultados de backtesting da história Vamos considerar o backtesting do Consultor Especializado em dados históricos (EURUSD H1, período de teste: 01.01.2010-11.03.2011, PeriodRSI=37, MA_period=7). Na criação do Consultor Especializado, utilizamos o volume fixo (Negociação com Lote Fixo, 0.1), o algoritmo Trailing Stop não é utilizado (Trailing não utilizado). Fig. 11. Resultados de testes do Consultor Especializado baseado em Bullish Harami/Bearish Harami + RSI O melhor conjunto de parâmetros de entrada pode ser encontrado usando o Strategy Tester do terminal do cliente MetaTrader 5. O código do Consultor Especializado, criado pelo MQL5 Wizard, está anexado em expert_aml_rsi.mq5.

2011.03.17
Sinais de Negociação com Bullish Harami/Bearish Harami e MFI no MetaTrader 5
MetaTrader5
Sinais de Negociação com Bullish Harami/Bearish Harami e MFI no MetaTrader 5

O MQL5 Wizard é uma ferramenta poderosa que permite a criação de Expert Advisors prontos, utilizando classes da biblioteca padrão que vem junto com o terminal do cliente (para mais detalhes, confira Criando Expert Advisors Prontos no MQL5 Wizard). Essa ferramenta ajuda a testar rapidamente suas ideias de negociação, basta criar sua própria classe de sinais de negociação. A estrutura dessa classe e exemplos podem ser encontrados no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação. A ideia principal é a seguinte: a classe de sinais de negociação é derivada de CExpertSignal, e em seguida, é necessário sobrepor os métodos virtuais LongCondition() e ShortCondition() com suas próprias implementações. Um livro interessante é "Estratégias dos Melhores Traders" (em russo), onde são discutidas várias estratégias de negociação, focando em padrões de reversão de velas, confirmados por Estocástico, CCI, MFI e RSI. A melhor abordagem é criar uma classe separada, derivada de CExpertSignal para verificar a formação de padrões de velas. Para confirmar os sinais de negociação gerados pelos padrões de velas, basta escrever uma classe derivada de CCandlePattern e adicionar as funcionalidades necessárias (como a confirmação por osciladores). Aqui, vamos considerar os sinais baseados no padrão de reversão de velas "Bullish Harami/Bearish Harami", confirmados pelo índice de facilitação de mercado (MFI). O módulo de sinais de negociação é baseado na classe CCandlePattern, que fornece um exemplo simples de seu uso para criar sinais de negociação com padrões de velas. 1. Padrões de reversão "Bullish Harami" e "Bearish Harami" 1.1. Bullish Harami O padrão de reversão Bullish Harami se forma em uma tendência de baixa quando uma grande vela é seguida por uma vela menor cujo corpo está localizado dentro da faixa vertical do corpo maior. Este padrão indica que a tendência de queda pode estar se revertendo, sinalizando que é um bom momento para entrar em uma posição longa. A segunda vela abre com um gap para cima. Quanto menor a segunda vela (branca), maior a probabilidade da reversão. Fig. 1. Padrão de vela "Bullish Harami" O reconhecimento do padrão "Bullish Harami" é implementado no método CheckPatternBullishHarami() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de vela "Bullish Harami"         | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBullishHarami()   { //--- Bullish Harami    if((Close(1)>Open(1))              && // a última barra concluída é bullish (dia branco)      ((Open(2)-Close(2)>AvgBody(1))  && // a vela anterior é bearish, seu corpo é maior que a média (long black)      ((Close(1)<Open(2))              && // o preço de fechamento da vela bullish é menor que o preço de abertura da vela bearish       (Open(1)>Close(2)))             && // o preço de abertura da vela bullish é maior que o preço de fechamento da vela bearish       (MidPoint(2)<CloseAvg(2)))         // tendência de baixa       return(true); //---    return(false);   } A verificação do padrão de vela (CANDLE_PATTERN_BULLISH_HARAMI) é feita pelo método CheckCandlestickPattern da classe CCandlePattern. 1.2. Bearish Harami O padrão de reversão Bearish Harami se forma em uma tendência de alta quando uma grande vela é seguida por uma vela menor cujo corpo está localizado dentro da faixa vertical do corpo maior. Este padrão indica que a tendência de alta pode estar se revertendo, sinalizando que é um bom momento para entrar em uma posição curta. A segunda vela abre com um gap para baixo. Quanto menor a segunda vela (preta), maior a probabilidade da reversão. Fig. 2. Padrão de vela "Bearish Harami" O reconhecimento do padrão "Bearish Harami" é implementado no método CheckPatternBearishHarami() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de vela "Bearish Harami"         | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBearishHarami()   { //--- Bearish Harami    if((Close(1)<Open(1))              && // a última barra concluída é bearish (dia preto)      ((Close(2)-Open(2)>AvgBody(1))  && // a vela anterior é bullish, seu corpo é maior que a média (long white)      ((Close(1)>Open(2))              && // o preço de fechamento da vela bearish é maior que o preço de abertura da vela bullish       (Open(1)<Close(2)))             && // o preço de abertura da vela bearish é menor que o preço de fechamento da vela bullish       (MidPoint(2)>CloseAvg(2)))         // tendência de alta       return(true); //---    return(false);   } A verificação do padrão de vela (CANDLE_PATTERN_BEARISH_HARAMI) é feita pelo método CheckCandlestickPattern da classe CCandlePattern. 2. Sinais de Negociação Confirmados pelo Indicador MFI Os sinais de negociação para abrir posições longas ou curtas devem ser confirmados pelo indicador MFI. O valor do indicador MFI deve ser inferior a 40 (para posições longas) ou superior a 60 (para posições curtas). O fechamento de posições abertas depende dos valores do indicador MFI. Isso pode ocorrer em 2 casos: se o MFI atingiu o nível crítico oposto (70 para posição longa e 30 para posição curta) se o sinal reverso não for confirmado (quando o indicador MFI atinge os seguintes níveis: 30 para posição longa e 70 para posição curta) Fig. 3. Padrão "Bullish Harami", confirmado pelo indicador MFI int CBH_BH_MFI::LongCondition() - verifica condições para abrir posição longa (retorna 80) e fechar posição curta (retorna 40); int CBH_BH_MFI::ShortCondition() - verifica condições para abrir posição curta (retorna 80) e fechar posição longa (retorna 40). 2.1. Abrir Posição Longa/Fechar Posição Curta A formação do padrão "Bullish Harami" deve ser confirmada pelo indicador MFI: MFi(1)<40 (o valor do indicador MFI da última barra concluída deve ser menor que 40). A posição curta deve ser fechada se o indicador MFI cruzar para cima os níveis críticos (70 ou 30). //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado                 | //| 1) Entrada no mercado (abrir posição longa, resultado=80)                  | //| 2) Saída do mercado (fechar posição curta, resultado=40)                 | //+------------------------------------------------------------------+ int CBH_BH_MFI::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do Expert Advisor //--- idx=0 - neste caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, o EA verifica as condições de negociação apenas em barras de notícias    int idx   =StartIndex(); //--- verificação das condições para abrir posição longa //--- formação do padrão Bullish Harami e MFI<40   if(CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_HARAMI) && (MFI(1)<40))      result=80; //--- verificação das condições para fechar posição curta //--- cruzamento da linha de sinal dos níveis sobrecomprados/sobrevendidos (para cima 30, para cima 70)   if(((MFI(1)>30) && (MFI(2)<30)) || ((MFI(1)>70) && (MFI(2)<70)))      result=40; //--- retornar resultado    return(result);   } 2.2. Abrir Posição Curta/Fechar Posição Longa A formação do padrão "Bearish Harami" deve ser confirmada pelo indicador MFI: MFI(1)>60 (o valor do indicador MFI da última barra concluída deve ser maior que 60). A posição longa deve ser fechada se o indicador MFI cruzar para cima os níveis críticos (70 ou 30). //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado                 | //| 1) Entrada no mercado (abrir posição curta, resultado=80)                 | //| 2) Saída do mercado (fechar posição longa, resultado=40)                  | //+------------------------------------------------------------------+ int CBH_BH_MFI::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do Expert Advisor //--- idx=0 - neste caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, o EA verifica as condições de negociação apenas em barras de notícias    int idx   =StartIndex(); //--- verificação das condições para abrir posição curta //--- formação do padrão Bearish Harami e MFI>60   if(CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_HARAMI) && (MFI(1)>60))      result=80; //--- verificação das condições para fechar posição longa //--- cruzamento da linha de sinal dos níveis sobrecomprados/sobrevendidos (para cima 70, para baixo 30)    if(((MFI(1)>70) && (MFI(2)<70)) || ((MFI(1)<30) && (MFI(2)>30)))      result=40; //--- retornar resultado    return(result);   } 2.3. Criando Expert Advisor usando MQL5 Wizard A classe CBH_BH_MFI não está incluída nas classes da Biblioteca Padrão, para usá-la, é necessário baixar o arquivo abh_bh_mfi.mqh (veja os anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo acandlepatterns.mqh. Você pode usá-los no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Expert Advisor, inicie o MQL5 Wizard: Fig. 4. Criando Expert Advisor usando MQL5 Wizard Vamos especificar o nome do Expert Advisor: Fig. 5. Propriedades gerais do Expert Advisor Depois disso, precisamos selecionar os módulos de sinais de negociação usados. Fig. 6. Propriedades do sinal do Expert Advisor No nosso caso, usamos apenas um módulo de sinais de negociação. Adicionando o módulo de sinais Baseado em Bullish Harami/Bearish Harami confirmado pelo MFI: Fig. 7. Propriedades do sinal do Expert Advisor Módulo de sinais de negociação adicionado: Fig. 8. Propriedades do sinal do Expert Advisor Você pode selecionar quaisquer propriedades de trailing, mas usaremos "Trailing Stop não utilizado": Fig. 9. Propriedades de trailing do Expert Advisor Quanto às propriedades de gerenciamento de dinheiro, usaremos "Negociação com volume fixo": Fig. 10. Propriedades de gerenciamento de dinheiro do Expert Advisor Ao pressionar o botão "Concluir", obteremos o código do Expert Advisor gerado, localizado em Expert_ABH_BH_MFI.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrão do Expert Advisor gerado: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =10;     // Valor do limite do sinal para abrir [0...100] input int            Signal_ThresholdClose  =10     // Valor do limite do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar um negócio input double         Signal_StopLevel       =50.0   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0    // Nível de Take Profit (em pontos)devem ser substituídos por: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =40;     // Valor do limite do sinal para abrir [0...100] input int            Signal_ThresholdClose  =20     // Valor do limite do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar um negócio input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis de limite para abrir e fechar posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de negociação, especificamos os valores fixos do limite: Abrir posição: 80; Fechar posição: 40. O Expert Advisor, gerado pelo MQL5 Wizard, abre e fecha posições utilizando os "votos" dos módulos de sinais de negociação. O voto do módulo principal (como um contêiner, que consiste em todos os módulos adicionados) também é utilizado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal também são utilizados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de negociação, então precisamos levar isso em conta ao definir os valores do limite. Por causa disso, os valores ThresholdOpen e ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, o que significa que o fechamento das posições será feito apenas quando as condições de fechamento forem verdadeiras. 2.4. Resultados de Backtesting Histórico Vamos considerar o backtesting do Expert Advisor em dados históricos (EURUSD H1, período de teste: 2010.01.01-2011.03.16, PeriodMFI=37, MA_period=11). Na criação do Expert Advisor, usamos o volume fixo (Negociação com Lote Fixo, 0.1), o algoritmo de Trailing Stop não é utilizado (Trailing não utilizado). Fig. 11. Resultados do teste do Expert Advisor, baseado em Bullish Harami/Bearish Harami + MFI O melhor conjunto de parâmetros de entrada pode ser encontrado utilizando o Strategy Tester do terminal cliente MetaTrader 5. O código do Expert Advisor, criado pelo MQL5 Wizard, está anexado em expert_abh_bh_mfi.mq5.

2011.03.17
MQL5 Wizard: Sinais de Negociação com Bullish Harami/Bearish Harami + CCI no MetaTrader 5
MetaTrader5
MQL5 Wizard: Sinais de Negociação com Bullish Harami/Bearish Harami + CCI no MetaTrader 5

O MQL5 Wizard permite criar Expert Advisors prontos, utilizando as classes da biblioteca padrão que vem junto com o terminal cliente (confira Criando Expert Advisors no MQL5 Wizard para mais detalhes). Ele permite verificar rapidamente suas ideias de negociação; tudo que você precisa é criar sua própria classe de sinais de negociação. A estrutura dessa classe e um exemplo podem ser encontrados no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação. A ideia geral é a seguinte: a classe de sinais de negociação é derivada de CExpertSignal. Em seguida, é necessário sobrescrever os métodos virtuais LongCondition() e ShortCondition() com seus próprios métodos. Há um livro chamado "Estratégias dos melhores traders" (em russo), onde muitas estratégias de negociação são abordadas. Aqui, focaremos nos padrões de velas de reversão, confirmados pelo Stochastic, CCI, MFI e RSI. A melhor abordagem é criar uma classe separada, derivada de CExpertSignal para verificar a formação de padrões de velas. Para confirmar os sinais de negociação gerados pelos padrões de velas, basta escrever a classe, derivada de CCandlePattern, e adicionar os recursos necessários (por exemplo, confirmação por osciladores). Aqui, consideraremos os sinais baseados no padrão de velas de reversão "Bullish Harami/Bearish Harami", confirmado pelo indicador CCI. O módulo de sinais de negociação é baseado na classe CCandlePattern, que é um exemplo simples de seu uso para a criação de sinais de negociação com padrões de velas. 1. Padrões de Velas de Reversão "Bullish Harami" e "Bearish Harami" 1.1. Bullish Harami O padrão de reversão Bullish Harami se forma em uma tendência de baixa quando uma vela grande é seguida por uma vela menor cujo corpo está localizado dentro do intervalo vertical do corpo maior. Esse padrão indica que a tendência de queda pode estar se revertendo, sinalizando que é um bom momento para entrar em uma posição longa. A segunda vela é aberta com um gap para cima. Quanto menor a segunda vela (branca), maior a probabilidade da reversão. Fig. 1. Padrão de velas "Bullish Harami" O reconhecimento do padrão "Bullish Harami" é implementado no método CheckPatternBullishHarami() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de velas "Bullish Harami" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBullishHarami()   { //--- Bullish Harami    if((Close(1)>Open(1))              && // a última barra concluída é bullish (dia branco)      ((Open(2)-Close(2)>AvgBody(1))  && // a vela anterior é bearish, seu corpo é maior que a média (vela preta longa)      ((Close(1)<Open(2))              && // o preço de fechamento da vela bullish é menor que o preço de abertura da vela bearish       (Open(1)>Close(2)))             && // o preço de abertura da vela bullish é maior que o preço de fechamento da vela bearish       (MidPoint(2)<CloseAvg(2)))         // tendência de baixa       return(true); //---    return(false);   } A função CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_HARAMI) da classe CCandlePattern é utilizada para verificar a formação do padrão de velas "Bullish Harami". 1.2. Bearish Harami O padrão de reversão Bearish Harami se forma em uma tendência de alta quando uma vela grande é seguida por uma vela menor cujo corpo está localizado dentro do intervalo vertical do corpo maior. Esse padrão indica que a tendência de alta pode estar se revertendo, sinalizando que é um bom momento para entrar em uma posição curta. A segunda vela é aberta com um gap para baixo. Quanto menor a segunda vela (preta), maior a probabilidade da reversão. Fig. 2. Padrão de velas "Bearish Harami" O reconhecimento do padrão "Bearish Harami" é implementado no método CheckPatternBearishHarami() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de velas "Bearish Harami" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBearishHarami()   { //--- Bearish Harami    if((Close(1)<Open(1))              && // a última barra concluída é bearish (dia preto)      ((Close(2)-Open(2)>AvgBody(1))  && // a vela anterior é bullish, seu corpo é maior que a média (vela branca longa)      ((Close(1)>Open(2))              && // o preço de fechamento da vela bearish é maior que o preço de abertura da vela bullish       (Open(1)<Close(2)))             && // o preço de abertura da vela bearish é menor que o preço de fechamento da vela bullish       (MidPoint(2)>CloseAvg(2)))         // tendência de alta       return(true); //---    return(false);   } A função CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_HARAMI) da classe CCandlePattern é utilizada para verificar a formação do padrão de velas "Bearish Harami". 2. Sinais de Negociação, Confirmados pelo Indicador CCI Os sinais de negociação para abrir posições longas ou curtas devem ser confirmados pelo indicador CCI. O valor do CCI deve ser maior/menor do que os níveis críticos (-50 para posição longa e 50 para posição curta). O fechamento da posição aberta depende dos valores do CCI. Isso pode ser feito em 2 casos: se a linha do CCI atingiu o nível crítico oposto (80 para posição longa e -80 para posição curta) se o sinal reverso não for confirmado (quando o CCI atinge os seguintes níveis: -80 para posição longa e 80 para posição curta) Fig. 3. Padrão Bullish Harami, confirmado pelo CCI int CBH_BH_CCI::LongCondition() - verifica as condições para abrir posição longa (retorna 80) e fechar a posição curta (retorna 40); int CBH_BH_CCI::ShortCondition() - verifica as condições para abrir posição curta (retorna 80) e fechar a posição longa (retorna 40). 2.1. Abrindo Posição Longa / Fechando Posição Curta A formação do padrão "Bullish Harami" deve ser confirmada pelo indicador CCI: CCI(1)<-50 (o valor do CCI da última barra concluída deve ser menor que -50). A posição curta deve ser fechada se o indicador CCI cruzou para cima o nível crítico -80 ou cruzou para baixo o nível crítico 80. //+------------------------------------------------------------------+ //| Verifica as condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrindo posição longa, resultado=80) | //| 2) Saída do mercado (fechando posição curta, resultado=40) | //+------------------------------------------------------------------+ int CBH_BH_CCI::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do Expert Advisor //--- idx=0 - neste caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, o EA verifica as condições de negociação apenas em novas barras    int idx   =StartIndex(); //--- verificando as condições para abrir posição longa //--- formação do padrão Bullish Harami e CCI<-50    if(CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_HARAMI) && (CCI(1)<-50))      result=80; //--- verificando as condições para fechar posição curta //--- cruzamento da linha do sinal dos níveis de sobrecompra/sobrevenda (para baixo -80, para cima -80)    if(((CCI(1)>-80) && (CCI(2)<-80)) || ((CCI(1)<80) && (CCI(2)>80)))      result=40; //--- retornar resultado    return(result);   } 2.2. Abrindo Posição Curta / Fechando Posição Longa A formação do padrão "Bearish Harami" deve ser confirmada pelo indicador CCI: CCI(1)>50 (o valor do CCI da última barra concluída deve ser maior que 50). A posição longa deve ser fechada se o indicador CCI cruzou para baixo os níveis -80 ou 80. //+------------------------------------------------------------------+ //| Verifica as condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrindo posição curta, resultado=80) | //| 2) Saída do mercado (fechando posição longa, resultado=40) | //+------------------------------------------------------------------+ int CBH_BH_CCI::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do Expert Advisor //--- idx=0 - neste caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, o EA verifica as condições de negociação apenas em novas barras    int idx   =StartIndex(); //--- verificando as condições para abrir posição curta //--- formação do padrão Bearish Harami e CCI>50    if(CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_HARAMI) && (CCI(1)>50))      result=80; //--- verificando as condições para fechar posição longa //--- cruzamento da linha do sinal dos níveis de sobrecompra/sobrevenda (para baixo -80, para cima 80)    if(((CCI(1)<80) && (CCI(2)>80)) || ((CCI(1)<-80) && (CCI(2)>-80)))      result=40; //--- retornar resultado    return(result);   } 2.3. Criando Expert Advisor usando MQL5 Wizard A classe CBH_BH_CCI não está incluída nas classes da Biblioteca Padrão. Para utilizá-la, é necessário baixar o arquivo acbh_bh_cci.mqh (veja os anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo candlepatterns.mqh. Você pode usá-los no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Expert Advisor, inicie o MQL5 Wizard: Fig. 4. Criando Expert Advisor usando MQL5 Wizard Vamos especificar o nome do Expert Advisor: Fig. 5. Propriedades gerais do Expert Advisor Depois disso, precisamos selecionar os módulos de sinais de negociação utilizados. Fig. 6. Propriedades de sinal do Expert Advisor No nosso caso, usamos apenas um módulo de sinais de negociação. Adicionando o módulo de sinais baseado em Bullish Harami/Bearish Harami confirmado pelo CCI: Fig. 7. Propriedades de sinal do Expert Advisor Módulo de sinais de negociação adicionado: Fig. 8. Propriedades de sinal do Expert Advisor Você pode selecionar quaisquer propriedades de trailing, mas usaremos "Trailing Stop não utilizado": Fig. 9. Propriedades de trailing do Expert Advisor Em relação às propriedades de gerenciamento de dinheiro, usaremos "Negociação com volume fixo": Fig. 10. Propriedades de gerenciamento de dinheiro do Expert Advisor Ao pressionar o botão "Finalizar", obteremos o código do Expert Advisor gerado, localizado em Expert_ABH_BH_CCI.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrão do Expert Advisor gerado: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =10;     // Valor do limite do sinal para abrir [0...100] input int            Signal_ThresholdClose  =10;     // Valor do limite do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar um negócio input double         Signal_StopLevel       =50.0;   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0   // Nível de Take Profit (em pontos)devem ser substituídos por: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =40;     // Valor do limite do sinal para abrir [0...100] input int            Signal_ThresholdClose  =20;     // Valor do limite do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar um negócio input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar níveis limite para abrir e fechar posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de negociação, especificamos os valores fixos do limite: Abrir posição: 80; Fechar posição: 40. O Expert Advisor, gerado pelo MQL5 Wizard, abre e fecha posições usando os "votos" dos módulos de sinais de negociação. O voto do módulo principal (como contêiner, que consiste em todos os módulos adicionados) também é usado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal também são utilizados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de negociação, então precisamos levar esse fato em conta ao definir os valores de limite. Por causa disso, os ThresholdOpen e ThresholdClose devem ser configurados como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, o que significa que o fechamento das posições será feito apenas quando as condições de fechamento forem verdadeiras. 2.4. Resultados de Backtesting de História Vamos considerar o backtesting do Expert Advisor em dados históricos (EURUSD H1, período de teste: 2010.01.01-2011.03.16, PeriodCCI=11, MA_period=5). Na criação do Expert Advisor, usamos o volume fixo (Negociação com Lote Fixo, 0.1), o algoritmo de Trailing Stop não é utilizado (Trailing não utilizado). Fig. 11. Resultados do teste do Expert Advisor, baseado em Bullish Harami/Bearish Harami + CCI O melhor conjunto de parâmetros de entrada pode ser encontrado usando o Strategy Tester do terminal cliente MetaTrader 5. O código do Expert Advisor, criado pelo MQL5 Wizard, está anexado em expert_abh_bh_cci.mq5.

2011.03.17
Como Criar Sinais de Trade com MQL5 Wizard: Bullish e Bearish Harami Confirmados pelo Stochastic
MetaTrader5
Como Criar Sinais de Trade com MQL5 Wizard: Bullish e Bearish Harami Confirmados pelo Stochastic

O MQL5 Wizard é uma ferramenta incrível que permite criar Consultores Especializados prontos, utilizando classes da biblioteca padrão que vem junto com o terminal do cliente (veja Criando Consultores Especializados no MQL5 Wizard para mais detalhes). Com ele, você pode testar rapidamente suas ideias de trade, basta criar sua própria classe de sinais de trade. A estrutura dessa classe e um exemplo podem ser encontrados no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Trading. A ideia geral é a seguinte: a classe de sinais de trade é derivada de CExpertSignal. Em seguida, é necessário sobrepor os métodos virtuais LongCondition() e ShortCondition() com suas próprias implementações. Um livro interessante é "Estratégias dos Melhores Traders" (em russo), onde várias estratégias de trading são abordadas. Aqui, vamos focar nos padrões de candlestick de reversão, confirmados por Stochastic, CCI, MFI e RSI. A melhor abordagem é criar uma classe separada, derivada de CExpertSignal, para verificar a formação dos padrões de candlestick. Para confirmar os sinais de trade gerados por esses padrões, basta escrever uma classe derivada de CCandlePattern e adicionar as funcionalidades necessárias (como a confirmação por osciladores). Vamos considerar os sinais baseados no padrão de candlestick de reversão "Bullish Harami/Bearish Harami", confirmados pelo Stochastic. O módulo de sinais de trade é baseado na classe CCandlePattern, que serve como um exemplo simples para a criação de sinais de trade com padrões de candlestick. 1. Padrões de Candlestick Bullish Harami e Bearish Harami 1.1. Bullish Harami O padrão de reversão Bullish Harami se forma em uma tendência de baixa quando uma grande candlestick é seguida por uma candlestick menor, cuja parte do corpo está dentro da faixa vertical do corpo maior. Este padrão indica que a tendência de queda pode estar prestes a reverter, sinalizando que é um bom momento para entrar em uma posição comprada. A segunda candlestick abre com um gap para cima. Quanto menor a segunda candlestick (branca), maior a probabilidade da reversão. Fig. 1. Padrão de candlestick Bullish Harami O reconhecimento do padrão "Bullish Harami" é feito no método CheckPatternBullishHarami() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão "Bullish Harami" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBullishHarami()   { //--- Bullish Harami    if((Close(1)>Open(1))              && // o último candle fechado é bullish (dia branco)      ((Open(2)-Close(2)>AvgBody(1))  && // o candle anterior é bearish, seu corpo é maior que a média (long black)      ((Close(1)<Open(2))              && // o preço de fechamento do candle bullish é menor que o preço de abertura do candle bearish       (Open(1)>Close(2)))             && // o preço de abertura do candle bullish é maior que o fechamento do candle bearish       (MidPoint(2)<CloseAvg(2)))         // tendência de baixa       return(true); //---    return(false);   } A verificação do padrão CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_HARAMI) da classe CCandlePattern é utilizada para verificar a formação do padrão "Bullish Harami". 1.2. Bearish Harami O padrão de reversão Bearish Harami se forma em uma tendência de alta quando uma grande candlestick é seguida por uma candlestick menor, cuja parte do corpo está dentro da faixa vertical do corpo maior. Esse padrão indica que a tendência de alta pode estar prestes a reverter, sinalizando que é um bom momento para entrar em uma posição vendida. A segunda candlestick abre com um gap para baixo. Quanto menor a segunda candlestick (preta), maior a probabilidade da reversão. Fig. 2. Padrão de candlestick Bearish Harami O reconhecimento do padrão "Bearish Harami" é feito no método CheckPatternBearishHarami() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão "Bearish Harami" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBearishHarami()   { //--- Bearish Harami    if((Close(1)<Open(1))              && // último candle fechado é bearish (dia preto)      ((Close(2)-Open(2)>AvgBody(1))  && // o candle anterior é bullish, seu corpo é maior que a média (long white)      ((Close(1)>Open(2))              && // preço de fechamento do candle bearish é maior que o preço de abertura do candle bullish      (Open(1)<Close(2)))             && // preço de abertura do candle bearish é menor que o fechamento do candle bullish       (MidPoint(2)>CloseAvg(2)))         // tendência de alta       return(true); //---    return(false);   } A verificação do padrão CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_HARAMI) da classe CCandlePattern é utilizada para verificar a formação do padrão "Bearish Harami". 2. Sinais de Trade, Confirmados pelo Indicador Stochastic Os sinais de trading para abrir posições longas ou curtas devem ser confirmados pelo oscilador Stochastic. A linha %D deve estar acima ou abaixo do nível crítico correspondente (30 ou 70). O fechamento da posição aberta depende dos valores do indicador %D. Isso pode ser feito em dois casos: se a linha %D atingir o nível crítico oposto (80 para posição longa e 20 para posição curta) se o sinal reverso não for confirmado (quando a linha %D atingir os seguintes níveis: 20 para posição longa e 80 para posição curta) Figura 3. Padrão de candlestick Bearish Harami, confirmado pelo indicador Stochastic O controle das condições de trade para entrada e saída é implementado em dois métodos: int CBH_BH_Stoch::LongCondition() - verifica as condições para abrir posição longa (retorna 80) e fechar a posição curta (retorna 40); int CBH_BH_Stoch::ShortCondition() - verifica as condições para abrir posição curta (retorna 80) e fechar a posição longa (retorna 40). 2.1. Abrir posição longa/Fechar posição curta A formação do padrão "Bullish Harami" deve ser confirmada pelo indicador Stochastic: StochSignal(1)<30 (o valor da linha de sinal do indicador Stochastic do último candle fechado deve ser menor que 30). A posição curta deve ser fechada se a linha de sinal do Stochastic cruzou para cima os níveis 20 ou 80. //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição longa, resultado=80) | //| 2) Saída do mercado (fechar posição curta, resultado=40) | //+------------------------------------------------------------------+ int CBH_BH_Stoch::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do EA //--- idx=0 - neste caso o EA verifica as condições de trade a cada tick //--- idx=1 - neste caso o EA verifica as condições de trade apenas em candles de notícias   int idx   =StartIndex(); //--- verificando as condições para abrir posição longa //--- formação do padrão Bullish Harami e linha de sinal<30   if (CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_HARAMI) && (StochSignal(1)<30))      result=80; //--- verificando as condições para fechar posição curta //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo 20, para cima 80)    if((((StochSignal(1)>20) && (StochSignal(2)<20)) ||        ((StochSignal(1)>80) && (StochSignal(2)<80))))      result=40; //--- retorno do resultado    return(result);   } 2.2. Abrir posição curta/Fechar posição longa A formação do padrão "Bearish Harami" deve ser confirmada pelo indicador Stochastic: StochSignal(1)>70 (o valor da linha de sinal do indicador Stochastic do último candle fechado deve ser maior que 70). A posição longa deve ser fechada se a linha de sinal do Stochastic cruzou para baixo os níveis 80 ou 20. //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição curta, resultado=80) | //| 2) Saída do mercado (fechar posição longa, resultado=40) | //+------------------------------------------------------------------+ int CBH_BH_Stoch::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do EA //--- idx=0 - neste caso o EA verifica as condições de trade a cada tick //--- idx=1 - neste caso o EA verifica as condições de trade apenas em candles de notícias   int idx   =StartIndex(); //--- verificando as condições para abrir posição curta //--- formação do padrão Bearish Harami e linha de sinal>70   if (CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_HARAMI) && (StochSignal(1)>70))      result=80; //--- verificando as condições para fechar posição longa //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo 80, para cima 20)    if((((StochSignal(1)<80) && (StochSignal(2)>80)) ||        ((StochSignal(1)<20) && (StochSignal(2)>20))))      result=40; //--- retorno do resultado    return(result);   } 2.3. Criando o Consultor Especializado Usando MQL5 Wizard A classe CBH_BH_Stoch não está incluída nas classes da Biblioteca Padrão. Para utilizá-la, é necessário baixar o arquivo acbh_bh_stoch.mqh (veja anexos) e salvá-lo na pasta terminal_cliente_dados\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo candlepatterns.mqh. Você poderá usá-los no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Consultor Especializado, inicie o MQL5 Wizard: Fig. 4. Criando o Consultor Especializado usando MQL5 Wizard Vamos especificar o nome do Consultor Especializado: Fig. 5. Propriedades gerais do Consultor Especializado Depois disso, precisamos selecionar os módulos de sinais de trade que serão utilizados. Fig. 6. Propriedades do sinal do Consultor Especializado Neste caso, usamos apenas um módulo de sinais de trade. Adicionando o módulo de sinais "Sinais baseados em Bullish Harami/Bearish Harami confirmados pelo Stochastic": Fig. 7. Propriedades do sinal do Consultor Especializado Módulo de sinais de trade adicionado: Fig. 8. Propriedades do sinal do Consultor Especializado Você pode selecionar quaisquer propriedades de trailing, mas utilizaremos "Trailing Stop não utilizado": Fig. 9. Propriedades do trailing do Consultor Especializado Quanto às propriedades de gerenciamento de dinheiro, utilizaremos "Trading com volume fixo": Fig. 10. Propriedades de gerenciamento de dinheiro do Consultor Especializado Ao pressionar o botão "Finalizar", receberemos o código do Consultor Especializado gerado, localizado em Expert_ABH_BH_Stoch.mq5, que será salvo em terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrão do Consultor Especializado gerado: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =10;     // Valor do limite de sinal para abrir [0...100] input int            Signal_ThresholdClose  =10;     // Valor do limite de sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar uma operação input double         Signal_StopLevel       =50.0;   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0  // Nível de Take Profit (em pontos) devem ser substituídos por: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =40;     // Valor do limite de sinal para abrir [0...100] input int            Signal_ThresholdClose  =20;     // Valor do limite de sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar uma operação input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis de limite para abrir e fechar posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de trade, especificamos os valores fixos do limite: Abrir posição: 80; Fechar posição: 40. O Consultor Especializado gerado pelo MQL5 Wizard abre e fecha posições usando os "votos" dos módulos de sinais de trade. O voto do módulo principal (como contêiner, ele consiste em todos os módulos adicionados) também é utilizado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal também são usados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de trade, então precisamos levar em conta esse fato ao definir os valores de limite. Por causa disso, os ThresholdOpen e ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, o que significa que o fechamento das posições será feito apenas quando as condições de fechamento forem verdadeiras. 2.4. Resultados do Backtesting Histórico Vamos considerar o backtesting do Consultor Especializado em dados históricos (EURUSD H1, período de teste: 01/01/2010 a 04/03/2011, PeriodK=47, PeriodD=9, PeriodSlow=13, MA_period=5). Na criação do Consultor Especializado, utilizamos um volume fixo (Trading Fixed Lot, 0.1), o algoritmo de Trailing Stop não foi utilizado (Trailing não utilizado). Fig. 11. Resultados de teste do Consultor Especializado, baseado em Bullish/Bearish Harami + Stochastic O melhor conjunto de parâmetros de entrada pode ser encontrado usando o Strategy Tester do terminal cliente MetaTrader 5.O código do Consultor Especializado, criado pelo MQL5 Wizard, está anexado em expert_abh_bh_stoch.mq5.

2011.03.16
Crie um Expert Advisor com MQL5 Wizard: Sinais de Negociação Baseados em Padrões de Candlestick e RSI
MetaTrader5
Crie um Expert Advisor com MQL5 Wizard: Sinais de Negociação Baseados em Padrões de Candlestick e RSI

O MQL5 Wizard é uma ferramenta poderosa que permite criar Expert Advisors prontos, utilizando as classes da biblioteca padrão que acompanha o terminal cliente (veja Criando Expert Advisors Prontos no MQL5 Wizard para mais detalhes). Essa ferramenta permite verificar suas ideias de negociação rapidamente; tudo que você precisa fazer é criar sua própria classe de sinais de negociação. A estrutura dessa classe e um exemplo podem ser encontrados no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação.A ideia geral é a seguinte: a classe de sinais de negociação é derivada de CExpertSignal. Em seguida, é necessário sobrescrever os métodos virtuais LongCondition() e ShortCondition() com seus próprios métodos.Há um livro chamado "Estratégias dos melhores traders" (em russo), onde muitas estratégias de negociação são discutidas, e aqui vamos focar nos padrões de candlestick de reversão, confirmados pelo Estocástico, CCI, MFI e RSI.A melhor abordagem é criar uma classe separada, derivada de CExpertSignal, para verificar a formação dos padrões de candlestick. Para a confirmação dos sinais de negociação gerados pelos padrões de candlestick, basta escrever a classe, derivada de CCandlePattern e adicionar as características necessárias (por exemplo, confirmação por osciladores).Aqui vamos considerar os sinais baseados no padrão de reversão "Bullish Engulfing/Bearish Engulfing", confirmados pelo indicador RSI. O módulo de sinais de negociação é baseado na classe CCandlePattern, que é um exemplo simples de seu uso para a criação de sinais de negociação com padrões de candlestick.1. Padrões "Bullish Engulfing" e "Bearish Engulfing"1.1. Bullish EngulfingO padrão de reversão "Bullish Engulfing" se forma em uma tendência de baixa, quando uma pequena vela negra é seguida por uma grande vela branca que a eclipsa completamente. As sombras da pequena vela são curtas, permitindo que o corpo da grande vela cubra toda a vela do dia anterior.Fig. 1. Padrão de candlestick 'Bullish Engulfing'O reconhecimento do padrão "Bullish Engulfing" é implementado no método CheckPatternBullishEngulfing() da classe CCandlePattern://+------------------------------------------------------------------+ //| Verifica a formação do padrão de candlestick "Bullish Engulfing" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBullishEngulfing()   { //--- Bullish Engulfing    if((Open(2)>Close(2))             &&  // vela anterior é bearish       (Close(1)-Open(1)>AvgBody(1))  &&  // corpo da vela bullish é maior que a média do corpo       (Close(1)>Open(2))             &&  // preço de fechamento da vela bullish é maior que o preço de abertura da vela bearish       (MidOpenClose(2)<CloseAvg(2))  &&  // tendência de baixa       (Open(1)<Close(2)))                // preço de abertura da vela bullish é menor que o preço de fechamento da bearish       return(true); //---    return(false);   }O método CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_ENGULFING) da classe CCandlePattern é usado para verificar a formação do padrão "Bullish Engulfing".1.2. Bearish EngulfingO padrão de reversão "Bearish Engulfing" se forma em uma tendência de alta, quando uma pequena vela branca é seguida por uma grande vela negra que a eclipsa completamente. As sombras da pequena vela são curtas, permitindo que o corpo da grande vela cubra toda a vela do dia anterior.Fig. 2. Padrão de candlestick 'Bearish Engulfing'O reconhecimento do padrão "Bearish Engulfing" é realizado no método CheckPatternBearishEngulfing() da classe CCandlePattern://+------------------------------------------------------------------+ //| Verifica a formação do padrão de candlestick "Bearish Engulfing" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBearishEngulfing()   { //--- Bearish Engulfing    if((Open(2)<Close(2))            &&  // vela anterior é bullish       (Open(1)-Close(1)>AvgBody(1)) &&  // corpo da vela é maior que a média do corpo       (Close(1)<Open(2))            &&  // preço de fechamento da vela bearish é menor que o preço de abertura da vela bullish       (MidOpenClose(2)>CloseAvg(2)) &&  // tendência de alta       (Open(1)>Close(2)))               // Preço de abertura da vela bearish é maior que o preço de fechamento da bullish       return(true); //---    return(false);   }O método CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_ENGULFING) da classe CCandlePattern é usado para verificar a formação do padrão "Bearish Engulfing".2. Sinais de Negociação Confirmados pelo Indicador RSIOs sinais de negociação para abrir posições longas ou curtas devem ser confirmados pelo indicador RSI. O valor do RSI deve ser menor ou maior que os níveis críticos (40 para posição longa e 60 para posição curta).O fechamento das posições abertas depende dos valores do RSI. Isso pode ser feito em 2 casos: se o RSI atingiu o nível crítico oposto (70 para posição longa e 30 para posição curta)se o sinal reverso não for confirmado (quando o RSI atinge os seguintes níveis: 30 para posição longa e 70 para posição curta)Fig. 3. Padrão 'Bullish Engulfing', confirmado pelo indicador RSIint CBE_BE_RSI::LongCondition() - verifica as condições para abrir posição longa (retorna 80) e fechar a posição curta (retorna 40);int CBE_BE_RSI::ShortCondition() - verifica as condições para abrir posição curta (retorna 80) e fechar a posição longa (retorna 40).2.1. Abrir posição longa/Fechar posição curtaA formação do padrão "Bullish Engulfing" deve ser confirmada pelo indicador RSI: RSI(1)<40 (o valor do RSI da última barra concluída deve ser menor que 40).A posição curta deve ser fechada se o indicador RSI cruzou para cima os níveis críticos 70 ou 30.//+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição longa, resultado=80) | //| 2) Saída do mercado (fechar posição curta, resultado=40) | //+------------------------------------------------------------------+ int CBE_BE_RSI::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do Expert Advisor //--- idx=0 - neste caso o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso o EA verifica as condições de negociação apenas em novas barras   int idx   =StartIndex(); //--- verificando condições para abrir posição longa //--- formação do padrão Bullish Engulfing e RSI<30   if(CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_ENGULFING) && (RSI(1)<40))      result=80; //--- verificando condições para fechar posição curta //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para cima 30, para cima 70)   if(((RSI(1)>30) && (RSI(2)<30)) || ((RSI(1)>70) && (RSI(2)<70)))      result=40; //--- retornar resultado    return(result);   }2.2. Abrir posição curta/Fechar posição longaA formação do padrão "Bearish Engulfing" deve ser confirmada pelo indicador RSI: RSI(1)>60 (o valor do RSI da última barra concluída deve ser maior que 60).A posição longa deve ser fechada se o indicador RSI cruzou para baixo os níveis críticos 70 ou 30.//+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição curta, resultado=80) | //| 2) Saída do mercado (fechar posição longa, resultado=40) | //+------------------------------------------------------------------+ int CBE_BE_RSI::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do Expert Advisor //--- idx=0 - neste caso o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso o EA verifica as condições de negociação apenas em novas barras   int idx   =StartIndex(); //--- verificando condições para abrir posição curta //--- formação do padrão Bearish Engulfing e RSI>60   if(CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_ENGULFING) && (RSI(1)>60))      result=80; //--- verificando condições para fechar posição longa //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo 70, para baixo 30)    if(((RSI(1)<70) && (RSI(2)>70)) || ((RSI(1)<30) && (RSI(2)>30)))      result=40; //--- retornar resultado    return(result);   }2.3. Criando o Expert Advisor usando MQL5 WizardA classe CBE_BE_RSI não está incluída nas classes da Biblioteca Padrão. Para usá-la, é necessário baixar o arquivo acml_rsi.mqh (veja anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo acandlepatterns.mqh. Você pode usá-los no MQL5 Wizard após reiniciar o MetaEditor.Para criar um Expert Advisor, inicie o MQL5 Wizard:Fig. 4. Criando Expert Advisor usando MQL5 WizardVamos especificar o nome do Expert Advisor:Fig. 5. Propriedades gerais do Expert AdvisorDepois disso, precisamos selecionar os módulos de sinais de negociação utilizados.Fig. 6. Propriedades do sinal do Expert AdvisorNeste caso, usamos apenas um módulo de sinais de negociação.Adicionando o módulo de sinais: Sinais baseados em Bullish Engulfing/Bearish Engulfing confirmados pelo RSI:Fig. 7. Propriedades do sinal do Expert AdvisorMódulo de sinais de negociação adicionado:Fig. 8. Propriedades do sinal do Expert AdvisorVocê pode selecionar quaisquer propriedades de trailing, mas usaremos "Trailing Stop não utilizado":Fig. 9. Propriedades de trailing do Expert AdvisorQuanto às propriedades de gerenciamento de dinheiro, usaremos "Negociando com volume fixo":Fig. 10. Propriedades de gerenciamento de dinheiro do Expert AdvisorAo pressionar o botão "Concluir", obteremos o código do Expert Advisor gerado, localizado em Expert_ABE_BE_RSI.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts\.Os parâmetros de entrada padrão do Expert Advisor gerado://--- entradas para sinal principal input int            Signal_ThresholdOpen   =10;     // Valor de limiar de sinal para abrir [0...100] input int            Signal_ThresholdClose  =10;     // Valor de limiar de sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar um negócio input double         Signal_StopLevel       =50.0;   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0   // Nível de Take Profit (em pontos)devem ser substituídos por: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =40;     // Valor de limiar de sinal para abrir [0...100] input int            Signal_ThresholdClose  =20;     // Valor de limiar de sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar um negócio input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos)Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar níveis de limiar para abrir e fechar posições.No código dos métodos LongCondition() e ShortCondition() da classe de sinais de negociação, definimos os valores fixos do limiar:Abrir posição: 80;Fechar posição: 40.O Expert Advisor gerado pelo MQL5 Wizard abre e fecha posições usando os "votos" dos módulos de sinais de negociação. O voto do módulo principal (como um contêiner, que consiste em todos os módulos adicionados) também é utilizado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0.Os resultados dos votos do módulo principal também são utilizados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de negociação, então precisamos levar isso em conta ao definir os valores dos limiares. Por causa disso, os valores ThresholdOpen e ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2.Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, o que significa que o fechamento das posições só será feito quando as condições de fechamento forem verdadeiras.2.4. Resultados de backtesting da históriaVamos considerar o backtesting do Expert Advisor em dados históricos (EURUSD H1, período de teste: 01/01/2010 a 04/03/2011, PeriodRSI=11, MA_period=5).Na criação do Expert Advisor, usamos o volume fixo (Trading Fixed Lot, 0.1), e o algoritmo Trailing Stop não é utilizado (Trailing não utilizado).Fig. 11. Resultados dos testes do Expert Advisor, baseado em Bullish Engulfing/Bearish Engulfing + RSIO melhor conjunto de parâmetros de entrada pode ser encontrado usando o Strategy Tester do terminal cliente MetaTrader 5.O código do Expert Advisor, criado pelo MQL5 Wizard, está anexado em expert_abe_be_rsi.mq5.

2011.03.10
Como Criar Sinais de Negociação com MQL5 Wizard: Padrões de Candlestick e MFI
MetaTrader5
Como Criar Sinais de Negociação com MQL5 Wizard: Padrões de Candlestick e MFI

O MQL5 Wizard é uma ferramenta poderosa que permite criar Expert Advisors prontos com base nas classes da biblioteca padrão que acompanha o terminal do cliente. Com ele, você pode testar suas ideias de negociação rapidamente, tudo que precisa fazer é criar sua própria classe de sinais de negociação. A estrutura desta classe e um exemplo podem ser encontrados no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação. A ideia básica é a seguinte: a classe de sinais de negociação é derivada de CExpertSignal. Em seguida, é necessário sobrescrever os métodos virtuais LongCondition() e ShortCondition() com seus próprios métodos. Existem muitos padrões de candlestick de reversão que podemos considerar, como os padrões de "Bullish Engulfing" e "Bearish Engulfing", confirmados por indicadores como o Market Facilitation Index (MFI). Vamos explorar como criar sinais de negociação baseados nesses padrões. 1. Padrões de Candlestick de Reversão 1.1. Bullish Engulfing O padrão "Bullish Engulfing" se forma durante uma tendência de baixa quando um pequeno candlestick negro é seguido por um grande candlestick branco que o eclipsa completamente. Os sombras do pequeno candlestick são curtas, permitindo que o corpo do grande candlestick cubra todo o candlestick do dia anterior. Fig. 1. Padrão de candlestick Bullish Engulfing A verificação do padrão "Bullish Engulfing" é feita pelo método CheckPatternBullishEngulfing() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de candlestick "Bullish Engulfing" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBullishEngulfing() { //--- Bullish Engulfing if((Open(2)>Close(2)) && // o candlestick anterior é bearish (Close(1)-Open(1)>AvgBody(1)) && // corpo do candlestick bullish é maior que a média (Close(1)>Open(2)) && // preço de fechamento do candlestick bullish é maior que o preço de abertura do bearish (MidOpenClose(2)70) && (MFI(2)

2011.03.10
Como Criar Sinais de Negociação com MQL5: Engulfing Bullish/Bearish + CCI
MetaTrader5
Como Criar Sinais de Negociação com MQL5: Engulfing Bullish/Bearish + CCI

O MQL5 Wizard é uma ferramenta poderosa que permite criar Expert Advisors (EAs) prontos para uso, baseando-se nas classes da biblioteca padrão fornecida com o terminal cliente. Essa ferramenta é ideal para quem deseja validar rapidamente suas ideias de negociação; tudo que você precisa fazer é desenvolver sua própria classe de sinais de negociação. A estrutura dessa classe, juntamente com um exemplo, pode ser encontrada no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação. A ideia principal é a seguinte: a classe de sinais de negociação é derivada de CExpertSignal. Em seguida, é necessário sobrescrever os métodos virtuais LongCondition() e ShortCondition() com seus próprios métodos. Um bom recurso é o livro "Estratégias dos melhores traders" (em russo), que discute várias estratégias de negociação. Vamos focar nos padrões de velas de reversão, confirmados pelos osciladores Estocástico, CCI, MFI e RSI. A maneira mais eficaz é criar uma classe separada, derivada de CExpertSignal, para verificar a formação de padrões de velas. Para a confirmação dos sinais de negociação gerados pelos padrões de velas, basta escrever a classe, derivada de CCandlePattern, e adicionar as funcionalidades necessárias (por exemplo, confirmação por osciladores). Aqui, focaremos nos sinais baseados nos padrões de reversão "Bullish Engulfing/Bearish Engulfing", confirmados pelo indicador CCI. O módulo de sinais de negociação é baseado na classe CCandlePattern, que é um exemplo simples de como utilizá-la para criar sinais de negociação com padrões de velas. 1. Padrões de Velas Reversão: "Bullish Engulfing" e "Bearish Engulfing" 1.1. Bullish Engulfing O padrão de reversão "Bullish Engulfing" se forma em uma tendência de baixa, quando uma pequena vela preta é seguida por uma grande vela branca que a eclipsa completamente. As sombras da pequena vela são curtas, permitindo que o corpo da grande vela cubra toda a vela do dia anterior. Fig. 1. Padrão de vela Bullish Engulfing O reconhecimento do padrão "Bullish Engulfing" é implementado no método CheckPatternBullishEngulfing() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de vela "Bullish Engulfing"      | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBullishEngulfing()   { //--- Bullish Engulfing    if((Open(2)>Close(2))             &&  // a vela anterior é de baixa       (Close(1)-Open(1)>AvgBody(1))  &&  // corpo da vela de alta é maior que a média do corpo       (Close(1)>Open(2))             &&  // preço de fechamento da vela de alta é maior que o preço de abertura da vela de baixa       (MidOpenClose(2)<CloseAvg(2))  &&  // tendência de baixa       (Open(1)<Close(2)))                // preço de abertura da vela de alta é menor que o preço de fechamento da vela de baixa       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_ENGULFING) da classe CCandlePattern é utilizado para verificar a formação do padrão de vela "Bullish Engulfing". 1.2. Bearish Engulfing O padrão de reversão "Bearish Engulfing" se forma em uma tendência de alta, quando uma pequena vela branca é seguida por uma grande vela preta que a eclipsa completamente. As sombras da pequena vela também são curtas, permitindo que o corpo da grande vela cubra toda a vela do dia anterior. Fig. 2. Padrão de vela Bearish Engulfing O reconhecimento do padrão "Bearish Engulfing" é implementado no método CheckPatternBearishEngulfing() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de vela "Bearish Engulfing"      | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBearishEngulfing()   { //--- Bearish Engulfing    if((Open(2)<Close(2))            &&  // a vela anterior é de alta       (Open(1)-Close(1)>AvgBody(1)) &&  // corpo da vela é maior que a média do corpo       (Close(1)<Open(2))            &&  // preço de fechamento da vela de baixa é menor que o preço de abertura da vela de alta       (MidOpenClose(2)>CloseAvg(2)) &&  // tendência de alta       (Open(1)>Close(2)))               // preço de abertura da vela de baixa é maior que o preço de fechamento da vela de alta       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_ENGULFING) da classe CCandlePattern é usado para verificar a formação do padrão de vela "Bearish Engulfing". 2. Sinais de Negociação, Confirmados pelo Indicador CCI Os sinais de negociação para abrir posições longas ou curtas devem ser confirmados pelo indicador CCI. O valor do CCI deve ser maior/menor que os níveis críticos (-50 para posição longa e 50 para posição curta). O fechamento da posição aberta depende dos valores do CCI. Isso pode ocorrer em 2 situações: se a linha do CCI alcançar o nível crítico oposto (80 para posição longa e -80 para posição curta) se o sinal reverso não for confirmado (quando o CCI atinge os seguintes níveis: -80 para posição longa e 80 para posição curta) Fig. 3. Padrão Bullish Engulfing, confirmado pelo indicador CCI int CBE_BE_CCI::LongCondition() - verifica as condições para abrir posição longa (retorna 80) e fechar a posição curta (retorna 40); int CBE_BE_CCI::ShortCondition() - verifica as condições para abrir posição curta (retorna 80) e fechar a posição longa (retorna 40). 2.1. Abrir Posição Longa/Fechar Posição Curta A formação do padrão "Bullish Engulfing" deve ser confirmada pelo CCI: CCI(1)<-50 (o valor do CCI da última barra completada deve ser menor que -50). A posição curta deve ser fechada se o indicador CCI cruzou para cima o nível crítico -80 ou cruzou para baixo o nível crítico 80. //+------------------------------------------------------------------+ //| Verifica as condições de entrada e saída do mercado                 | //| 1) Entrada no mercado (abrir posição longa, resultado=80)                  | //| 2) Saída do mercado (fechar posição curta, resultado=40)                 | //+------------------------------------------------------------------+ int CBE_BE_CCI::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do Expert Advisor //--- idx=0 - neste caso, EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, EA verifica as condições de negociação apenas em novas barras    int idx   =StartIndex(); //--- verificação das condições para abrir posição longa //--- formação do padrão Bullish Engulfing e CCI<-50    if(CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_ENGULFING) && (CCI(1)<-50))      result=80; //--- verificação das condições para fechar a posição curta //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo -80, para baixo -80)    if(((CCI(1)>-80) && (CCI(2)<-80)) || ((CCI(1)<80) && (CCI(2)>80)))      result=40; //--- retorna o resultado    return(result);   } 2.2. Abrir Posição Curta/Fechar Posição Longa A formação do padrão "Bearish Engulfing" deve ser confirmada pelo CCI: CCI(1)>50 (o valor do CCI do último barra completada deve ser maior que 50). A posição longa deve ser fechada se o CCI cruzou para baixo os níveis -80 ou 80. //+------------------------------------------------------------------+ //| Verifica as condições de entrada e saída do mercado                 | //| 1) Entrada no mercado (abrir posição curta, resultado=80)                 | //| 2) Saída do mercado (fechar posição longa, resultado=40)                  | //+------------------------------------------------------------------+ int CBE_BE_CCI::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do Expert Advisor //--- idx=0 - neste caso, EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, EA verifica as condições de negociação apenas em novas barras    int idx   =StartIndex(); //--- verificação das condições para abrir posição curta //--- formação do padrão Bearish Engulfing e CCI>50    if(CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_ENGULFING) && (CCI(1)>50))      result=80; //--- verificação das condições para fechar a posição longa //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo -80, para baixo 80)    if(((CCI(1)<80) && (CCI(2)>80)) || ((CCI(1)<-80) && (CCI(2)>-80)))      result=40; //--- retorna o resultado    return(result);   } 2.3. Criando Expert Advisor Usando MQL5 Wizard A classe CBE_BE_CCI não está incluída nas classes da Biblioteca Padrão; para utilizá-la, é necessário baixar o arquivo acbe_be_cci.mqh (veja anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo candlepatterns.mqh. Você pode utilizá-los no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Expert Advisor, inicie o MQL5 Wizard: Fig. 4. Criando Expert Advisor usando MQL5 Wizard Vamos especificar o nome do Expert Advisor: Fig. 5. Propriedades gerais do Expert Advisor Após isso, precisamos selecionar os módulos de sinais de negociação utilizados. Fig. 6. Propriedades de sinal do Expert Advisor No nosso caso, utilizamos apenas um módulo de sinais de negociação. Adicionando o módulo de sinais Baseados em Bullish Engulfing/Bearish Engulfing confirmados pelo CCI: Fig. 7. Propriedades de sinal do Expert Advisor Módulo de sinais de negociação adicionado: Fig. 8. Propriedades de sinal do Expert Advisor Você pode selecionar quaisquer propriedades de trailing, mas utilizaremos "Trailing Stop não utilizado": Fig. 9. Propriedades de trailing do Expert Advisor Em relação às propriedades de gestão de dinheiro, utilizaremos "Negociação com volume fixo": Fig. 10. Propriedades de gestão de dinheiro do Expert Advisor Ao pressionar o botão "Finalizar", obteremos o código do Expert Advisor gerado, localizado em Expert_ABE_BE_CCI.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrão do Expert Advisor gerado são: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =10;     // Valor do limite do sinal para abrir [0...100] input int            Signal_ThresholdClose  =10     // Valor do limite do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar um negócio input double         Signal_StopLevel       =50.0   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0  // Nível de Take Profit (em pontos) Devem ser alterados para: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =40;     // Valor do limite do sinal para abrir [0...100] input int            Signal_ThresholdClose  =20     // Valor do limite do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar um negócio input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis de limite para abrir e fechar posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de negociação, temos os valores fixos de limite especificados: Abrir posição: 80; Fechar posição: 40. O Expert Advisor gerado pelo MQL5 Wizard abre e fecha posições utilizando os "votos" dos módulos de sinais de negociação. O voto do módulo principal (como contêiner, que consiste em todos os módulos adicionados) também é utilizado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal também são usados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de negociação, então precisamos levar isso em conta ao definir os valores de limite. Por causa disso, o ThresholdOpen e o ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores de Signal_StopLevel e Signal_TakeLevel são definidos como 0, o que significa que o fechamento das posições só ocorrerá quando as condições de fechamento forem verdadeiras. 2.4. Resultados de Backtesting Histórico Vamos considerar o backtesting do Expert Advisor em dados históricos (EURUSD H1, período de teste: 2010.01.01-2011.03.16, PeriodCCI=49, MA_period=11). Na criação do Expert Advisor, utilizamos o volume fixo (Negociação com Lote Fixo, 0.1), o algoritmo de Trailing Stop não é utilizado (Trailing não utilizado). Fig. 11. Resultados do teste do Expert Advisor, baseado em Bullish Engulfing/Bearish Engulfing + CCI A melhor combinação de parâmetros de entrada pode ser encontrada utilizando o Testador de Estratégia do terminal cliente MetaTrader 5. O código do Expert Advisor, criado pelo MQL5 Wizard está anexado em expert_abe_be_cci.mq5.

2011.03.10
Crie seu Expert Advisor com MQL5: Sinais de Negociação com Padrões Engulfing e Stochastic
MetaTrader5
Crie seu Expert Advisor com MQL5: Sinais de Negociação com Padrões Engulfing e Stochastic

O MQL5 Wizard permite criar EAs (Expert Advisors) prontos baseados nas classes da biblioteca padrão que acompanham o terminal do cliente. Com isso, você pode verificar suas ideias de negociação de forma rápida, basta criar sua própria classe de sinais de negociação. A estrutura dessa classe e um exemplo podem ser encontrados no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação. A ideia básica é a seguinte: a classe de sinais de negociação é derivada de CExpertSignal. Você precisará sobrescrever os métodos virtuais LongCondition() e ShortCondition() com seus próprios métodos. Um livro interessante é "Estratégias dos Melhores Traders" (em russo), que considera várias estratégias de negociação. Aqui, vamos focar em padrões de velas de reversão, confirmados pelos osciladores Stochastic, CCI, MFI e RSI. O melhor caminho é criar uma classe separada, derivada de CExpertSignal para verificar a formação de padrões de velas. Para confirmação dos sinais de negociação gerados por esses padrões, basta escrever a classe derivada de CCandlePattern e adicionar as funcionalidades necessárias (como confirmação por osciladores). Neste artigo, vamos considerar os sinais baseados no padrão de velas de reversão "Bullish Engulfing/Bearish Engulfing", confirmados pelo indicador Stochastic. O módulo de sinais de negociação é baseado na classe CCandlePattern, que é um exemplo simples de como criar sinais de negociação com padrões de velas. 1. Padrões de Velas de Reversão: "Bullish Engulfing" e "Bearish Engulfing" 1.1. Bullish Engulfing O padrão de reversão "Bullish Engulfing" se forma em uma tendência de baixa quando uma pequena vela preta é seguida por uma grande vela branca que eclipsa completamente a vela do dia anterior. As sombras (caudas) da vela pequena são curtas, permitindo que o corpo da vela grande cubra toda a vela do dia anterior. Fig. 1. Padrão de vela "Bullish Engulfing" O reconhecimento do padrão "Bullish Engulfing" é implementado no método CheckPatternBullishEngulfing() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão "Bullish Engulfing"     | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBullishEngulfing()   { //--- Bullish Engulfing    if((Open(2)>Close(2))             &&  // vela anterior é bearish       (Close(1)-Open(1)>AvgBody(1))  &&  // corpo da vela bullish é maior que a média       (Close(1)>Open(2))             &&  // preço de fechamento da vela bullish é maior que a abertura da bearish       (MidOpenClose(2)<CloseAvg(2))  &&  // tendência de baixa       (Open(1)<Close(2)))                // preço de abertura da vela bullish é menor que o fechamento da bearish       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_ENGULFING) da classe CCandlePattern é utilizado para verificar a formação do padrão "Bullish Engulfing". 1.2. Bearish Engulfing O padrão de reversão "Bearish Engulfing" se forma em uma tendência de alta quando uma pequena vela branca é seguida por uma grande vela preta que cobre completamente a vela do dia anterior. As sombras (caudas) da vela pequena são curtas, permitindo que o corpo da vela grande cubra toda a vela do dia anterior. Fig. 2. Padrão de vela "Bearish Engulfing" O reconhecimento do padrão "Bearish Engulfing" é implementado no método CheckPatternBearishEngulfing() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão "Bearish Engulfing"     | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternBearishEngulfing()   { //--- Bearish Engulfing    if((Open(2)<Close(2))            &&  // vela anterior é bullish       (Open(1)-Close(1)>AvgBody(1)) &&  // corpo da vela é maior que a média       (Close(1)<Open(2))            &&  // preço de fechamento da vela bearish é menor que a abertura da bullish       (MidOpenClose(2)>CloseAvg(2)) &&  // tendência de alta       (Open(1)>Close(2)))               // Preço de abertura da vela bearish é maior que o fechamento da bullish       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_ENGULFING) da classe CCandlePattern é utilizado para verificar a formação do padrão "Bearish Engulfing". 2. Sinais de Negociação Confirmados pelo Indicador Stochastic Os sinais de negociação para abrir posição longa ou curta devem ser confirmados pelo oscilador Stochastic. A linha de sinal %D deve ser maior/menor que os níveis críticos correspondentes (30 ou 70). O fechamento da posição aberta depende dos valores do indicador %D. Isso pode ocorrer em duas situações: se a linha %D atingir o nível crítico oposto (80 para posição longa e 20 para posição curta) se o sinal reverso não for confirmado (quando a linha %D atinge os níveis seguintes: 20 para posição longa e 80 para posição curta) Fig. 3. Padrão "Bullish Engulfing", confirmado pelo indicador Stochastic Verificação das condições de negociação para entrada e saída é implementada em dois métodos: int CBE_BE_Stoch::LongCondition() - verifica condições para abrir posição longa (retorna 80) e fechar a posição curta (retorna 40); int CBE_BE_Stoch::ShortCondition() - verifica condições para abrir posição curta (retorna 80) e fechar a posição longa (retorna 40). 2.1. Abrir posição longa/Fechar posição curta A formação do padrão "Bullish Engulfing" deve ser confirmada pelo indicador Stochastic: StochSignal(1)<30 (o valor da linha de sinal do indicador Stochastic da última barra completada deve ser menor que 30). A posição curta deve ser fechada se a linha de sinal do indicador Stochastic cruzou para cima os níveis 20 ou 80. //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado                  | //| 1) Entrada no mercado (abrir posição longa, resultado=80)            | //| 2) Saída do mercado (fechar posição curta, resultado=40)           | //+------------------------------------------------------------------+ int CBE_BE_Stoch::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do EA //--- idx=0 - neste caso o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso o EA verifica as condições de negociação apenas em barras de notícias   int idx   =StartIndex(); //--- verificando condições para abrir posição longa //--- formação do padrão Bullish Engulfing e linha de sinal<30   if (CheckCandlestickPattern(CANDLE_PATTERN_BULLISH_ENGULFING) && (StochSignal(1)<30))      result=80; //--- verificando condições para fechar posição curta //--- cruzamento da linha de sinal dos níveis sobrecomprado/vendido (para baixo 20, para cima 80)    if((((StochSignal(1)>20) && (StochSignal(2)<20)) ||        ((StochSignal(1)>80) && (StochSignal(2)<80))))      result=40; //--- retornar resultado    return(result);   } 2.2. Abrir posição curta/Fechar posição longa A formação do padrão "Bearish Engulfing" deve ser confirmada pelo indicador Stochastic: StochSignal(1)>70 (o valor da linha de sinal do indicador Stochastic da última barra completada deve ser maior que 70). A posição longa deve ser fechada se a linha de sinal do indicador Stochastic cruzou para baixo os níveis 80 ou 20. //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado                  | //| 1) Entrada no mercado (abrir posição curta, resultado=80)            | //| 2) Saída do mercado (fechar posição longa, resultado=40)           | //+------------------------------------------------------------------+ int CBE_BE_Stoch::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do EA //--- idx=0 - neste caso o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso o EA verifica as condições de negociação apenas em barras de notícias   int idx   =StartIndex(); //--- verificando condições para abrir posição curta //--- formação do padrão Bearish Engulfing e linha de sinal>70   if (CheckCandlestickPattern(CANDLE_PATTERN_BEARISH_ENGULFING) && (StochSignal(1)>70))      result=80; //--- verificando condições para fechar posição longa //--- cruzamento da linha de sinal dos níveis sobrecomprado/vendido (para baixo 80, para cima 20)    if((((StochSignal(1)<80) && (StochSignal(2)>80)) ||        ((StochSignal(1)<20) && (StochSignal(2)>20))))      result=40; //--- retornar resultado    return(result);   } 2.3. Criando o Expert Advisor com o MQL5 Wizard A classe CBE_BE_Stoch não está incluída nas classes da Biblioteca Padrão, para usá-la, é necessário baixar o arquivo acbe_be_stoch.mqh (ver anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo candlepatterns.mqh. Você pode utilizá-lo no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Expert Advisor, inicie o MQL5 Wizard: Fig. 4. Criando Expert Advisor com MQL5 Wizard Vamos especificar o nome do Expert Advisor: Fig. 5. Propriedades gerais do Expert Advisor Após isso, precisamos selecionar os módulos de sinais de negociação a serem usados. Fig. 6. Propriedades de sinal do Expert Advisor No nosso caso, usamos apenas um módulo de sinais de negociação. Adicionando o módulo de Sinais baseados em Bullish Engulfing/Bearish Engulfing confirmados pelo Stochastic: Fig. 7. Propriedades de sinal do Expert Advisor Módulo de sinais de negociação adicionado: Fig. 8. Propriedades de sinal do Expert Advisor Você pode selecionar quaisquer propriedades de trailing, mas iremos usar "Trailing Stop não utilizado":Fig. 9. Propriedades de trailing do Expert Advisor Quanto às propriedades de gestão de dinheiro, iremos usar "Negociação com volume fixo":Fig. 10. Propriedades de gestão de dinheiro do Expert Advisor Ao pressionar o botão "Finalizar", receberemos o código do Expert Advisor gerado, localizado em Expert_ABE_BE_Stoch.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrão do Expert Advisor gerado: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =10;     // Valor do limite do sinal para abrir [0...100] input int            Signal_ThresholdClose  =10     // Valor do limite do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar um negócio input double         Signal_StopLevel       =50.0   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0   // Nível de Take Profit (em pontos)devem ser alterados para: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =40;     // Valor do limite do sinal para abrir [0...100] input int            Signal_ThresholdClose  =20     // Valor do limite do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar um negócio input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis de limitação para abertura e fechamento de posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de negociação, especificamos os valores fixos do limite: Abrir posição: 80; Fechar posição: 40. O Expert Advisor gerado pelo MQL5 Wizard abre e fecha posições usando os "votos" dos módulos de sinais de negociação. O voto do módulo principal (como contêiner, que consiste em todos os módulos adicionados) também é utilizado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal também são utilizados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de negociação, então precisamos levar em conta esse fato ao definir os valores dos limites. Por causa disso, o ThresholdOpen e o ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, o que significa que o fechamento das posições será feito apenas quando as condições de fechamento forem verdadeiras. 2.4. Resultados de Backtesting Histórico Vamos considerar o backtesting do Expert Advisor em dados históricos (EURUSD H1, período de teste: 2010.01.01-2011.03.04, PeriodK=47, PeriodD=9, PeriodSlow=13, MA_period=5). Na criação do Expert Advisor, utilizamos o volume fixo (Negociação com Lote Fixo, 0.1), e o algoritmo de Trailing Stop não foi utilizado (Trailing não utilizado). Fig. 11. Resultados do teste do Expert Advisor, baseado em Bullish/Bearish Engulfing + Stochastic O melhor conjunto de parâmetros de entrada pode ser encontrado usando o Testador de Estratégia do terminal cliente MetaTrader 5. O código do Expert Advisor, criado pelo MQL5 Wizard, está anexado em expert_abe_be_stoch.mq5.

2011.03.10
Crie Seu Expert Advisor com MQL5: Sinais de Comércio Baseados em Dark Cloud Cover e Piercing Line com RSI
MetaTrader5
Crie Seu Expert Advisor com MQL5: Sinais de Comércio Baseados em Dark Cloud Cover e Piercing Line com RSI

O MQL5 Wizard é uma ferramenta poderosa que permite criar robôs de negociação (EAs) prontos para uso, utilizando as classes da biblioteca padrão que vem com o terminal do cliente. Com ele, você pode testar suas ideias de trading rapidamente, bastando criar sua própria classe de sinais de negociação. A estrutura dessa classe e exemplos podem ser encontrados no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação. A ideia geral é a seguinte: a classe de sinais de negociação é derivada de CExpertSignal. Em seguida, é necessário sobrescrever os métodos virtuais LongCondition() e ShortCondition() com suas próprias implementações. Se você está em busca de inspiração, recomendo o livro "Estratégias dos Melhores Traders" (em russo), que aborda várias estratégias de trading. Aqui, vamos focar nos padrões de velas de reversão, confirmados pelos osciladores como Estocástico, CCI, MFI e RSI. A melhor forma é criar uma classe separada, derivada de CExpertSignal para verificar a formação de padrões de velas. Para confirmar os sinais de negociação gerados pelos padrões de velas, basta escrever a classe derivada de CCandlePattern e adicionar os recursos necessários (como confirmação por osciladores) ali. Aqui, vamos considerar os sinais baseados no padrão de velas de reversão "Dark Cloud Cover/Piercing Line", confirmados pelo indicador RSI. O módulo de sinais de negociação é baseado na classe CCandlePattern, que é um exemplo simples de uso para a criação de sinais de negociação com padrões de velas. 1. Padrões de Velas de Reversão: "Dark Cloud Cover" e "Piercing Line" 1.1. Dark Cloud Cover Esse é um padrão de reversão de alta que ocorre no final de uma tendência de alta. No primeiro dia, forma-se uma vela branca longa e, no segundo dia, há um gap de alta. No entanto, o fechamento do segundo dia ocorre abaixo do ponto médio do primeiro dia. Figura 1. Padrão de vela 'Dark Cloud Cover' O reconhecimento do padrão "Dark Cloud Cover" é implementado no método CheckPatternDarkCloudCover() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de vela "Dark Cloud Cover" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternDarkCloudCover()   { //--- Dark Cloud Cover    if((Close(2)-Open(2)>AvgBody(1))  && // (vela branca longa)       (Close(1)<Close(2))            && //       (Close(1)>Open(2))             && // (fechamento dentro do corpo anterior)       (MidOpenClose(2)>CloseAvg(1))  && // (tendência de alta)       (Open(1)>High(2)))                // (abertura em nova alta)       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_DARK_CLOUD_COVER) da classe CCandlePattern é utilizado para verificar a formação do padrão "Dark Cloud Cover". 1.2. Piercing Line O gap de baixa no segundo dia perpetua a tendência de baixa. No entanto, o fechamento do segundo dia está acima do ponto médio do corpo do primeiro dia, sugerindo aos vendedores que um fundo pode estar se formando. Essa ação de preço não é tão discernível em gráficos de barras quanto em gráficos de velas. Quanto mais penetrante o fechamento do segundo dia no corpo do primeiro dia, maior a probabilidade de sucesso do sinal de reversão. Figura 2. Padrão de vela 'Piercing Line' O reconhecimento do padrão "Piercing Line" é implementado no método CheckPatternPiercingLine() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de vela "Piercing Line" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternPiercingLine()   { //--- Piercing Line    if((Close(1)-Open(1)>AvgBody(1)) && // (vela branca longa)       (Open(2)-Close(2)>AvgBody(1)) && // (vela preta longa)       (Close(1)>Close(2))           && //         (Close(1)<Open(2))            && // (fechamento dentro do corpo anterior)       (MidOpenClose(2)<CloseAvg(2)) && // (tendência de baixa)       (Open(1)<Low(2)))                // (abertura abaixo da baixa anterior)       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_PIERCING_LINE) da classe CCandlePattern é utilizado para verificar a formação do padrão "Piercing Line". 2. Sinais de Negociação Confirmados pelo Indicador RSI Os sinais de negociação para abrir posição longa ou curta devem ser confirmados pelo indicador RSI. O valor do RSI deve estar abaixo/acima dos níveis críticos (40 para posição longa e 60 para posição curta). O fechamento da posição aberta depende dos valores do RSI. Isso pode ser feito em 2 casos: se o RSI atingiu o nível crítico oposto (70 para posição longa e 30 para posição curta) se o sinal reverso não for confirmado (quando o RSI atinge os seguintes níveis: 30 para posição longa e 70 para posição curta) Figura 3. Padrão 'Dark Cloud Cover' confirmado pelo indicador RSI int CDC_PL_RSI::LongCondition() - verifica as condições para abrir posição longa (retorna 80) e fechar a posição curta (retorna 40); int CDC_PL_RSI::ShortCondition() - verifica as condições para abrir posição curta (retorna 80) e fechar a posição longa (retorna 40). 2.1. Abrir Posição Longa / Fechar Posição Curta A formação do padrão "Piercing Line" deve ser confirmada pelo RSI: RSI(1)<40 (o valor do RSI da última barra completada deve ser menor que 40). A posição curta deve ser fechada se o RSI cruzar para cima os níveis críticos 70 ou 30. //+------------------------------------------------------------------+ //| Verifica as condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição longa, resultado=80) | //| 2) Saída do mercado (fechar posição curta, resultado=40) | //+------------------------------------------------------------------+ int CDC_PL_RSI::LongCondition()   {    int result=0; //--- o idx pode ser usado para determinar o modo de operação do EA //--- idx=0 - nesse caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - nesse caso, o EA verifica as condições de negociação apenas em novas barras   int idx   =StartIndex(); //--- verificando as condições para abrir posição longa //--- formação do padrão Piercing Line e RSI<30   if(CheckCandlestickPattern(CANDLE_PATTERN_PIERCING_LINE) && (RSI(1)<40))      result=80; //--- verificando as condições para fechar a posição curta //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para cima 30, para cima 70)   if(((RSI(1)>30) && (RSI(2)<30)) || ((RSI(1)>70) && (RSI(2)<70)))      result=40; //--- retorna o resultado    return(result);   } 2.2. Abrir Posição Curta / Fechar Posição Longa A formação do padrão "Dark Cloud Cover" deve ser confirmada pelo RSI: RSI(1)>60 (o valor do indicador RSI da última barra completada deve ser maior que 60). A posição longa deve ser fechada se o RSI cruzar para baixo os níveis críticos 70 ou 30. //+------------------------------------------------------------------+ //| Verifica as condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição curta, resultado=80) | //| 2) Saída do mercado (fechar posição longa, resultado=40) | //+------------------------------------------------------------------+ int CDC_PL_RSI::ShortCondition()   {    int result=0; //--- o idx pode ser usado para determinar o modo de operação do EA //--- idx=0 - nesse caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - nesse caso, o EA verifica as condições de negociação apenas em novas barras    int idx   =StartIndex(); //--- verificando as condições para abrir posição curta //--- formação do padrão Dark Cloud Cover e RSI>60   if(CheckCandlestickPattern(CANDLE_PATTERN_DARK_CLOUD_COVER) && (RSI(1)>60))      result=80; //--- verificando as condições para fechar a posição longa //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo 70, para baixo 30)    if(((RSI(1)<70) && (RSI(2)>70)) || ((RSI(1)<30) && (RSI(2)>30)))      result=40; //--- retorna o resultado    return(result);   } 2.3. Criando o Expert Advisor Usando o MQL5 Wizard A classe CDC_PL_RSI não está incluída nas classes da Biblioteca Padrão, para utilizá-la, é necessário baixar o arquivo adc_pl_rsi.mqh (veja os anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo acandlepatterns.mqh. Você pode usá-lo no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Expert Advisor, inicie o MQL5 Wizard: Figura 4. Criando o Expert Advisor usando o MQL5 Wizard Vamos especificar o nome do Expert Advisor: Figura 5. Propriedades gerais do Expert Advisor Depois, precisamos selecionar os módulos de sinais de negociação que usaremos. Figura 6. Propriedades de sinal do Expert Advisor Neste caso, usaremos apenas um módulo de sinais de negociação. Adicionando o módulo Sinais baseados em Dark Cloud Cover/Piercing Line confirmados pelo RSI: Figura 7. Propriedades de sinal do Expert Advisor Módulo de sinais de negociação adicionado: Figura 8. Propriedades de sinal do Expert Advisor Você pode selecionar quaisquer propriedades de trailing, mas usaremos "Trailing Stop não utilizado": Figura 9. Propriedades de money management do Expert Advisor Referente às propriedades de gerenciamento de dinheiro, usaremos "Negociação com volume fixo": Figura 10. Propriedades de gerenciamento de dinheiro do Expert Advisor Ao pressionar o botão "Finalizar", obteremos o código do Expert Advisor gerado, localizado em Expert_ADC_PL_RSI.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrão do Expert Advisor gerado: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =10;     // Valor de limiar do sinal para abrir [0...100] input int            Signal_ThresholdClose  =10;     // Valor de limiar do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar uma negociação input double         Signal_StopLevel       =50.0   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0   // Nível de Take Profit (em pontos) devem ser substituídos por: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =40;     // Valor de limiar do sinal para abrir [0...100] input int            Signal_ThresholdClose  =20;     // Valor de limiar do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar uma negociação input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis de limiar para abrir e fechar posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de negociação, especificamos os valores fixos dos limiares: Abrir posição: 80; Fechar posição: 40. O Expert Advisor, gerado pelo MQL5 Wizard, abre e fecha posições utilizando os “votos” dos módulos de sinais de negociação. O voto do módulo principal (como um contêiner, que consiste em todos os módulos adicionados) também é utilizado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal também são utilizados na média dos “votos”. No nosso caso, temos: módulo principal + 1 módulo de sinais de negociação, então precisamos levar esse fato em consideração ao definir os valores de limiar. Por causa disso, os valores de ThresholdOpen e ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, o que significa que o fechamento das posições será feito apenas quando as condições de fechamento forem verdadeiras. 2.4. Resultados de Backtesting da História Vamos considerar o backtesting do Expert Advisor em dados históricos (EURUSD H1, período de teste: 2010.01.01-2011.02.23, PeriodRSI=20, MA_period=14). Na criação do Expert Advisor, utilizamos um volume fixo (Negociação com Lote Fixo, 0.1), e o algoritmo de Trailing Stop não é utilizado (Trailing não utilizado). Figura 11. Resultados do teste do Expert Advisor baseado em Dark Cloud Cover/Piercing Line + RSI O melhor conjunto de parâmetros de entrada pode ser encontrado usando o Strategy Tester do terminal MetaTrader 5. O código do Expert Advisor criado pelo MQL5 Wizard está anexado em expert_ad_pl_rsi.mq5.

2011.02.25
Como Criar um Expert Advisor com MQL5: Sinais de Negociação Baseados em Padrões de Candlestick
MetaTrader5
Como Criar um Expert Advisor com MQL5: Sinais de Negociação Baseados em Padrões de Candlestick

O MQL5 Wizard é uma ferramenta fantástica que possibilita a criação de Expert Advisors prontos, utilizando as classes da biblioteca padrão que vem com o terminal cliente (veja Criando Expert Advisors Prontos no MQL5 Wizard para mais detalhes). Essa ferramenta permite que você teste suas ideias de negociação rapidamente, tudo que você precisa é criar sua própria classe de sinais de negociação. A estrutura dessa classe e um exemplo podem ser encontrados no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação. A ideia básica é a seguinte: a classe de sinais de negociação é derivada de CExpertSignal. A próxima etapa é sobrepor os métodos virtuais LongCondition() e ShortCondition() com os seus próprios métodos. Há um livro chamado "Estratégias dos Melhores Traders" (em russo) que aborda muitas estratégias de negociação. Neste artigo, vamos focar em padrões de reversão de candlestick, confirmados pelos osciladores como Stochastic, CCI, MFI e RSI. A melhor abordagem é criar uma classe separada, derivada de CExpertSignal, para verificar a formação de padrões de candlestick. Para confirmar os sinais de negociação gerados por esses padrões, basta escrever uma classe derivada de CCandlePattern e adicionar as funcionalidades necessárias (por exemplo, confirmação por osciladores). Aqui, vamos considerar os sinais baseados no padrão de candlestick de reversão "Dark Cloud Cover/Piercing Line", confirmados pelo Market Facilitation Index (MFI). O módulo de sinais de negociação é baseado na classe CCandlePattern, que é um exemplo simples de como utilizá-la para criar sinais de negociação com padrões de candlestick. 1. Padrões de Candlestick de Reversão: "Dark Cloud Cover" e "Piercing Line" 1.1. Dark Cloud Cover O "Dark Cloud Cover" é um padrão de reversão de candlestick bearish que ocorre no final de uma tendência de alta. Um longo candlestick branco é formado no primeiro dia e um gap de alta é criado no segundo dia. No entanto, o fechamento do segundo dia é abaixo do ponto médio do primeiro dia. Fig. 1. Padrão de candlestick "Dark Cloud Cover" O reconhecimento do padrão "Dark Cloud Cover" é implementado no método CheckPatternDarkCloudCover() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de candlestick "Dark Cloud Cover" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternDarkCloudCover()   { //--- Dark Cloud Cover    if((Close(2)-Open(2)>AvgBody(1))  && // (long white)       (Close(1)<Close(2))            && //       (Close(1)>Open(2))             && // (close dentro do corpo anterior)       (MidOpenClose(2)>CloseAvg(1))  && // (tendência de alta)       (Open(1)>High(2)))                // (abre em nova alta)       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_DARK_CLOUD_COVER) da classe CCandlePattern é utilizado para verificar a formação do padrão "Dark Cloud Cover". 1.2. Piercing Line O gap de baixa no segundo dia perpetua a tendência de baixa. No entanto, o fechamento do segundo dia está acima do ponto médio do corpo do primeiro dia. Isso sugere aos vendedores que um fundo pode estar se formando. Essa ação de preço não é tão discernível em gráficos de barras quanto em gráficos de candlestick. Quanto mais profundo o fechamento do segundo dia em relação ao corpo do primeiro dia, maior a probabilidade de que o sinal de reversão tenha sucesso. Fig. 2. Padrão de candlestick "Piercing Line" O reconhecimento do padrão "Piercing Line" é implementado no método CheckPatternPiercingLine() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de candlestick "Piercing Line" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternPiercingLine()   { //--- Piercing Line    if((Close(1)-Open(1)>AvgBody(1)) && // (long white)       (Open(2)-Close(2)>AvgBody(1)) && // (long black)       (Close(1)>Close(2))           && //         (Close(1)<Open(2))            && // (fecha dentro do corpo anterior)       (MidOpenClose(2)<CloseAvg(2)) && // (tendência de baixa)       (Open(1)<Low(2)))                // (abre abaixo da baixa anterior)       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_PIERCING_LINE) da classe CCandlePattern é utilizado para verificar a formação do padrão "Piercing Line". 2. Sinais de Negociação Confirmados pelo Indicador MFI Os sinais de negociação para abrir posições longas ou curtas devem ser confirmados pelo MFI. O valor do indicador MFI deve ser inferior a 40 (para posições longas) ou superior a 60 (para posições curtas). O fechamento das posições abertas depende dos valores do indicador MFI. Isso pode ser feito em 2 casos: se o MFI atingiu o nível crítico oposto (70 para posição longa e 30 para posição curta) se o sinal reverso não for confirmado (quando o indicador MFI atinge os seguintes níveis: 30 para posição longa e 70 para posição curta) Fig. 3. Padrão "Dark Cloud Cover" confirmado pelo indicador MFI int CDC_PL_MFI::LongCondition() - verifica as condições para abrir uma posição longa (retorna 80) e fechar a posição curta (retorna 40); int CDC_PL_MFI::ShortCondition() - verifica as condições para abrir uma posição curta (retorna 80) e fechar a posição longa (retorna 40). 2.1. Abrindo Posição Longa/Fechando Posição Curta A formação do padrão "Morning Star" deve ser confirmada pelo MFI: MFi(1)<40 (o valor do MFI do último candle fechado deve ser menor que 40). A posição curta deve ser fechada se o MFI tiver cruzado para cima os níveis críticos (70 ou 30). //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado             | //| 1) Entrada no mercado (abrir posição longa, resultado=80)                  | //| 2) Saída do mercado (fechar posição curta, resultado=40)                 | //+------------------------------------------------------------------+ int CDC_PL_MFI::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do Expert Advisor //--- idx=0 - neste caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, o EA verifica as condições de negociação apenas em novos candles   int idx   =StartIndex(); //--- verificando condições para abrir posição longa //--- formação do padrão Piercing Line e MFI<40   if(CheckCandlestickPattern(CANDLE_PATTERN_PIERCING_LINE) && (MFI(1)<40))      result=80; //--- verificando condições para fechar posição curta //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para cima 30, para cima 70)   if(((MFI(1)>30) && (MFI(2)<30)) || ((MFI(1)>70) && (MFI(2)<70)))      result=40; //--- retornar resultado    return(result);   } 2.2. Abrindo Posição Curta/Fechando Posição Longa A formação do padrão "Dark Cloud Cover" deve ser confirmada pelo MFI: MFI(1)>60 (o valor do MFI do último candle fechado deve ser maior que 60). A posição longa deve ser fechada se o MFI tiver cruzado para cima os níveis críticos (70 ou 30). //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado             | //| 1) Entrada no mercado (abrir posição curta, resultado=80)                 | //| 2) Saída do mercado (fechar posição longa, resultado=40)                  | //+------------------------------------------------------------------+ int CDC_PL_MFI::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do Expert Advisor //--- idx=0 - neste caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, o EA verifica as condições de negociação apenas em novos candles   int idx   =StartIndex(); //--- verificando condições para abrir posição curta //--- formação do padrão Dark Cloud Cover e MFI>60   if(CheckCandlestickPattern(CANDLE_PATTERN_DARK_CLOUD_COVER) && (MFI(1)>60))      result=80; //--- verificando condições para fechar posição longa //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para cima 70, para baixo 30)    if(((MFI(1)>70) && (MFI(2)<70)) || ((MFI(1)<30) && (MFI(2)>30)))      result=40; //--- retornar resultado    return(result);   } 2.3. Criando um Expert Advisor usando MQL5 Wizard A classe CDC_PL_MFI não está incluída nas classes da Biblioteca Padrão, para utilizá-la, é necessário baixar o arquivo adc_pl_mfi.mqh (veja os anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo acandlepatterns.mqh. Você poderá utilizá-los no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Expert Advisor, inicie o MQL5 Wizard: Fig. 4. Criando Expert Advisor usando MQL5 Wizard Vamos especificar o nome do Expert Advisor: Fig. 5. Propriedades gerais do Expert Advisor Depois disso, precisamos selecionar os módulos de sinais de negociação utilizados. Fig. 6. Propriedades de sinal do Expert Advisor Neste caso, usamos apenas um módulo de sinais de negociação. Adicionando o módulo Sinais baseados no Dark Cloud Cover/Piercing Line confirmados pelo MFI: Fig. 7. Propriedades de sinal do Expert Advisor Módulo de sinais de negociação adicionado: Fig. 8. Propriedades de sinal do Expert Advisor Você pode selecionar quaisquer propriedades de trailing, mas usaremos "Trailing Stop não utilizado": Fig. 9. Propriedades de trailing do Expert Advisor Quanto às propriedades de gerenciamento de dinheiro, usaremos "Negociação com volume fixo": Fig. 10. Propriedades de gerenciamento de dinheiro do Expert Advisor Ao pressionar o botão "Finalizar", obteremos o código do Expert Advisor gerado, localizado em Expert_ADC_PL_MFI.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrão do Expert Advisor gerado: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =10;     // Valor do limite do sinal para abrir [0...100] input int            Signal_ThresholdClose  =10     // Valor do limite do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar uma negociação input double         Signal_StopLevel       =50.0   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0    // Nível de Take Profit (em pontos) devem ser substituídos por: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =40;     // Valor do limite do sinal para abrir [0...100] input int            Signal_ThresholdClose  =20     // Valor do limite do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar uma negociação input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis limites para abrir e fechar posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de negociação, definimos os valores fixos do limite: Abrir posição: 80; Fechar posição: 40. O Expert Advisor gerado pelo MQL5 Wizard abre e fecha posições utilizando os "votos" dos módulos de sinais de negociação. O voto do módulo principal (como contêiner, consiste em todos os módulos adicionados) também é utilizado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal são também utilizados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de negociação, então precisamos levar isso em conta ao definir os valores limites. Por causa disso, o ThresholdOpen e ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, isso significa que o fechamento das posições será feito apenas quando as condições de fechamento forem verdadeiras. 2.4. Resultados de Backtesting Histórico Vamos considerar o backtesting do Expert Advisor em dados históricos (EURUSD H1, período de teste: 01/01/2010 a 16/03/2011, PeriodMFI=49, MA_period=11). Na criação do Expert Advisor, utilizamos o volume fixo (Trading Fixed Lot, 0.1), o algoritmo de Trailing Stop não é utilizado (Trailing not used). Fig. 11. Resultados do teste do Expert Advisor baseado em Dark Cloud Cover/Piercing Line + MFI O melhor conjunto de parâmetros de entrada pode ser encontrado usando o Strategy Tester do terminal cliente MetaTrader 5. O código do Expert Advisor, criado pelo MQL5 Wizard está anexado em expert_adc_pl_mfi.mq5.

2011.02.25
MQL5 Wizard: Sinais de Compra e Venda com Padrões de Candlestick e CCI
MetaTrader5
MQL5 Wizard: Sinais de Compra e Venda com Padrões de Candlestick e CCI

O MQL5 Wizard permite criar EAs prontos baseados nas classes da biblioteca padrão que vem junto com o terminal cliente (veja Criando EAs Prontos no MQL5 Wizard para mais detalhes). Ele possibilita checar rapidamente suas ideias de trading, basta criar sua própria classe de sinais de trading. A estrutura dessa classe e um exemplo podem ser encontrados no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Trading. A ideia básica é a seguinte: a classe de sinais de trading é derivada de CExpertSignal, e é necessário sobrescrever os métodos virtuais LongCondition() e ShortCondition() com os seus próprios métodos. Há um livro chamado "Estratégias dos Melhores Traders" (em russo), onde muitas estratégias de trading são discutidas, e nosso foco será nos padrões de candlestick de reversão, confirmados pelo Estocástico, CCI, MFI e RSI osciladores. A melhor abordagem é criar uma classe separada, derivada de CExpertSignal, para verificar a formação dos padrões de candlestick. Para confirmar os sinais de trading gerados pelos padrões de candlestick, é suficiente escrever a classe, derivada de CCandlePattern, e adicionar as funcionalidades necessárias (por exemplo, confirmação por osciladores). Aqui, vamos considerar os sinais baseados no padrão de candlestick de reversão "Dark Cloud Cover/Piercing Line", confirmados pelo indicador CCI. O módulo de sinais de trading é baseado na classe CCandlePattern, que é um exemplo simples de seu uso para criar sinais de trading com padrões de candlestick. 1. Padrões de Candlestick: "Dark Cloud Cover" e "Piercing Line" 1.1. Dark Cloud Cover É um padrão de reversão de alta que ocorre no final de uma tendência de alta. Um longo candlestick branco é formado no primeiro dia e um gap de alta é criado no segundo dia. No entanto, o segundo dia fecha abaixo do ponto médio do primeiro dia. Fig. 1. Padrão de Candlestick 'Dark Cloud Cover' O reconhecimento do padrão "Dark Cloud Cover" é implementado no método CheckPatternDarkCloudCover() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de candlestick "Dark Cloud Cover" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternDarkCloudCover()   { //--- Dark Cloud Cover    if((Close(2)-Open(2)>AvgBody(1))  && // (longo branco)       (Close(1)<Close(2))            && //       (Close(1)>Open(2))             && // (fechar dentro do corpo anterior)       (MidOpenClose(2)>CloseAvg(1))  && // (tendência de alta)       (Open(1)>High(2)))                // (abertura em nova alta)       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_DARK_CLOUD_COVER) da classe CCandlePattern é usado para verificar a formação do padrão de candlestick "Dark Cloud Cover". 1.2. Piercing Line O gap de baixa no segundo dia perpetua a tendência de baixa. No entanto, o fechamento do segundo dia é acima do ponto médio do corpo do primeiro dia. Isso sugere aos ursos que um fundo pode estar se formando. Essa ação de preço não é tão discernível usando gráficos de barras como é com gráficos de candlestick. Quanto mais penetração do fechamento no segundo dia para o corpo do primeiro dia, mais provável será o sucesso do sinal de reversão. Fig. 2. Padrão de Candlestick 'Piercing Line' O reconhecimento do padrão "Piercing Line" é implementado no método CheckPatternPiercingLine() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de candlestick "Piercing Line" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternPiercingLine()   { //--- Piercing Line    if((Close(1)-Open(1)>AvgBody(1)) && // (longo branco)       (Open(2)-Close(2)>AvgBody(1)) && // (longo preto)       (Close(1)>Close(2))           && //         (Close(1)<Open(2))            && // (fechar dentro do corpo anterior)       (MidOpenClose(2)<CloseAvg(2)) && // (tendência de baixa)       (Open(1)<Low(2)))                // (abertura abaixo da baixa anterior)       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_PIERCING_LINE) da classe CCandlePattern é usado para verificar a formação do padrão de candlestick "Piercing Line". 2. Sinais de Trading Confirmados pelo Indicador CCI Os sinais de trading para abrir posições longas ou curtas devem ser confirmados pelo indicador CCI. O valor do CCI deve ser maior/menor que os níveis críticos (-50 para posição longa e 50 para posição curta). O fechamento das posições abertas depende dos valores do CCI. Isso pode ser feito em 2 casos: se a linha do CCI atingir o nível crítico oposto (80 para posição longa e -80 para posição curta) se o sinal reverso não for confirmado (quando o CCI atinge os níveis seguintes: -80 para posição longa e 80 para posição curta) Fig. 3. Padrão 'Dark Cloud Cover', confirmado pelo indicador CCI int CDC_PL_CCI::LongCondition() - verifica as condições para abrir posição longa (retorna 80) e fechar a posição curta (retorna 40); int CDC_PL_CCI::ShortCondition() - verifica as condições para abrir posição curta (retorna 80) e fechar a posição longa (retorna 40). 2.1. Abrir Posição Longa/Fechar Posição Curta A formação do padrão "Piercing Line" deve ser confirmada pelo indicador CCI: CCI(1)<-50 (o valor do CCI da última barra concluída deve ser menor que -50). A posição curta deve ser fechada se o indicador CCI cruzar para cima o nível crítico -80 ou cruzar para baixo o nível crítico 80. //+------------------------------------------------------------------+ //| Verifica as condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição longa, resultado=80) | //| 2) Saída do mercado (fechar posição curta, resultado=40) | //+------------------------------------------------------------------+ int CDC_PL_CCI::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do Expert Advisor //--- idx=0 - nesse caso o EA verifica as condições de trading a cada tick //--- idx=1 - nesse caso o EA verifica as condições de trading apenas em novas barras    int idx   =StartIndex(); //--- verificação das condições para abrir posição longa //--- formação do padrão Piercing Line e CCI<-50    if(CheckCandlestickPattern(CANDLE_PATTERN_PIERCING_LINE) && (CCI(1)<-50))      result=80; //--- verificação das condições para fechar a posição curta //--- crossover da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo -80, para baixo -80)    if(((CCI(1)>-80) && (CCI(2)<-80)) || ((CCI(1)<80) && (CCI(2)>80)))      result=40; //--- retorno do resultado    return(result);   } 2.2. Abrir Posição Curta/Fechar Posição Longa A formação do padrão "Dark Cloud Cover" deve ser confirmada pelo indicador CCI: CCI(1)>50 (o valor do indicador CCI da última barra concluída deve ser maior que 50). A posição longa deve ser fechada se o indicador CCI cruzar para baixo os níveis -80 ou 80. //+------------------------------------------------------------------+ //| Verifica as condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição curta, resultado=80) | //| 2) Saída do mercado (fechar posição longa, resultado=40) | //+------------------------------------------------------------------+ int CDC_PL_CCI::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do Expert Advisor //--- idx=0 - nesse caso o EA verifica as condições de trading a cada tick //--- idx=1 - nesse caso o EA verifica as condições de trading apenas em novas barras    int idx   =StartIndex(); //--- verificação das condições para abrir posição curta //--- formação do padrão Dark Cloud Cover e CCI>50    if(CheckCandlestickPattern(CANDLE_PATTERN_DARK_CLOUD_COVER) && (CCI(1)>50))      result=80; //--- verificação das condições para fechar posição longa //--- crossover da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo -80, para baixo 80)    if(((CCI(1)<80) && (CCI(2)>80)) || ((CCI(1)<-80) && (CCI(2)>-80)))      result=40; //--- retorno do resultado    return(result);   } 2.3. Criando um Expert Advisor Usando MQL5 Wizard A classe CDC_PL_CCI não está incluída nas classes da Biblioteca Padrão, para usá-la, é necessário baixar o arquivo acdc_pl_cci.mqh (veja os anexos) e salvá-lo no diretório client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo candlepatterns.mqh. Você pode usá-lo no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Expert Advisor, inicie o MQL5 Wizard: Fig. 4. Criando um Expert Advisor usando MQL5 Wizard Vamos especificar o nome do Expert Advisor: Fig. 5. Propriedades gerais do Expert Advisor Após isso, precisamos selecionar os módulos de sinais de trading utilizados. Fig. 6. Propriedades de sinal do Expert Advisor No nosso caso, usamos apenas um módulo de sinais de trading. Adicionando o módulo de sinais "Sinais baseados em Dark Cloud Cover/Piercing Line confirmados por CCI": Fig. 7. Propriedades de sinal do Expert Advisor Módulo de sinais de trading adicionado: Fig. 8. Propriedades de sinal do Expert Advisor Você pode selecionar quaisquer propriedades de trailing, mas usaremos "Trailing Stop não utilizado": Fig. 9. Propriedades de trailing do Expert Advisor Quanto às propriedades de gerenciamento de dinheiro, usaremos "Trading com volume fixo": Fig. 10. Propriedades de gerenciamento de dinheiro do Expert Advisor Ao pressionar o botão "Finalizar", receberemos o código do Expert Advisor gerado, localizado em Expert_ADC_PL_CCI.mq5, que será salvo em terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrão do Expert Advisor gerado: //--- entradas para sinal principal input int            Signal_ThresholdOpen   =10;     // Valor do limite de sinal para abrir [0...100] input int            Signal_ThresholdClose  =10;     // Valor do limite de sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar um negócio input double         Signal_StopLevel       =50.0;   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0   // Nível de Take Profit (em pontos)devem ser substituídos por://--- entradas para sinal principal input int            Signal_ThresholdOpen   =40;     // Valor do limite de sinal para abrir [0...100] input int            Signal_ThresholdClose  =20;     // Valor do limite de sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar um negócio input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis de limite para abertura e fechamento de posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de trading, especificamos os valores fixos do limite: Abrir posição: 80; Fechar posição: 40. O Expert Advisor, gerado pelo MQL5 Wizard, abre e fecha posições usando os "votos" dos módulos de sinais de trading. O voto do módulo principal (como um container, que consiste em todos os módulos adicionados) também é usado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal também são utilizados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de trading, então precisamos levar isso em consideração ao definir os valores de limite. Devido a esse fato, os ThresholdOpen e ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, o que significa que o fechamento das posições será feito apenas quando as condições de fechamento forem verdadeiras. 2.4. Resultados de Backtesting Histórico Vamos considerar o backtesting do Expert Advisor em dados históricos (EURUSD H1, período de teste: 01/01/2010 a 16/03/2011, PeriodCCI=15, MA_period=19). Na criação do Expert Advisor, usamos o volume fixo (Trading Fixed Lot, 0.1), e o algoritmo de Trailing Stop não foi utilizado (Trailing não utilizado). Fig. 11. Resultados do teste do Expert Advisor com base em Dark Cloud Cover/Piercing Line + CCI O melhor conjunto de parâmetros de entrada pode ser encontrado usando o Strategy Tester do terminal cliente MetaTrader 5. O código do Expert Advisor, criado pelo MQL5 Wizard, está anexado em expert_adc_pl_cci.mq5.

2011.02.25
Como Criar um Expert Advisor com Sinais de Negócios Usando MQL5 e Padrões de Candlestick
MetaTrader5
Como Criar um Expert Advisor com Sinais de Negócios Usando MQL5 e Padrões de Candlestick

O MQL5 Wizard é uma ferramenta incrível que permite criar Expert Advisors prontos para o uso, baseados nas classes da Biblioteca Padrão que vêm junto com o terminal do cliente. Com ele, você pode testar suas ideias de negociação rapidamente, basta criar sua própria classe de sinais de negociação. A estrutura dessa classe e exemplos podem ser encontrados no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação. A ideia básica é a seguinte: a classe de sinais de negociação é derivada de CExpertSignal. Em seguida, você precisará sobrescrever os métodos virtuais LongCondition() e ShortCondition() com seus próprios métodos. Um livro interessante que você pode conferir é "Estratégias dos Melhores Traders" (em russo), que aborda diversas estratégias de negociação. Neste artigo, vamos nos concentrar em padrões de candlestick de reversão, confirmados pelo Stochastic, CCI, MFI e RSI. O melhor caminho é criar uma classe separada, derivada de CExpertSignal, para verificar a formação dos padrões de candlestick. Para confirmar os sinais de negociação gerados pelos padrões de candlestick, basta criar uma classe derivada de CCandlePattern e adicionar as funcionalidades necessárias (por exemplo, confirmação pelos osciladores). Neste artigo, vamos considerar os sinais baseados no padrão de candlestick de reversão "Dark Cloud Cover/Piercing Line", confirmados pelo Stochastic. O módulo de sinais de negociação é baseado na classe CCandlePattern, que é um exemplo simples de como criar sinais de negociação com padrões de candlestick. 1. Padrões de Candlestick de Reversão: "Dark Cloud Cover" e "Piercing Line" 1.1. Dark Cloud Cover O padrão "Dark Cloud Cover" é um padrão de reversão de baixa que ocorre no final de uma tendência de alta. Um candlestick branco longo se forma no primeiro dia e um gap de alta é criado no segundo dia. No entanto, o segundo dia fecha abaixo do ponto médio do primeiro dia. Fig. 1. Padrão de candlestick "Dark Cloud Cover" O reconhecimento do padrão "Dark Cloud Cover" é implementado no método CheckPatternDarkCloudCover() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de candlestick "Dark Cloud Cover" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternDarkCloudCover()   { //---Dark Cloud Cover    if((Close(2)-Open(2)>AvgBody(1))  && // (candlestick branco longo)       (Close(1)<Close(2))            && //       (Close(1)>Open(2))            && // (fecho dentro do corpo anterior)       (MidOpenClose(2)>CloseAvg(1))  && // (tendência de alta)       (Open(1)>High(2)))                // (abre em nova máxima)       return(true); //---    return(false);   } A verificação do padrão de candlestick "Dark Cloud Cover" é feita pelo método CheckCandlestickPattern(CANDLE_PATTERN_DARK_CLOUD_COVER) da classe CCandlePattern. 1.2. Piercing Line O gap de baixa no segundo dia perpetua a tendência de baixa. No entanto, o fechamento do segundo dia está acima do ponto médio do corpo do primeiro dia. Isso sugere que uma mínima pode estar se formando. Essa ação de preço não é tão discernível em gráficos de barras quanto em gráficos de candlestick. Quanto mais penetrante o fechamento do segundo dia no corpo do primeiro dia, maior a probabilidade de que o sinal de reversão tenha sucesso. Fig. 2. Padrão de candlestick "Piercing Line" O reconhecimento do padrão "Piercing Line" é implementado no método CheckPatternPiercingLine() da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de candlestick "Piercing Line" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternPiercingLine()   { //---Piercing Line    if((Close(1)-Open(1)>AvgBody(1)) && // (candlestick branco longo)       (Open(2)-Close(2)>AvgBody(1)) && // (candlestick preto longo)       (Close(1)>Close(2))           && //       (Close(1)<Open(2))            && // (fecho dentro do corpo anterior)       (MidOpenClose(2)<CloseAvg(2)) && // (tendência de baixa)       (Open(1)<Low(2)))                // (abre abaixo da mínima anterior)       return(true); //---    return(false);   } A verificação do padrão de candlestick "Piercing Line" é feita pelo método CheckCandlestickPattern(CANDLE_PATTERN_PIERCING_LINE) da classe CCandlePattern. 2. Sinais de Negociação Confirmados pelo Indicador Stochastic Os sinais de negociação para abrir posições longas ou curtas devem ser confirmados pelo Stochastic. A linha %D deve ser maior ou menor que os níveis críticos correspondentes (30 ou 70). O fechamento das posições abertas depende dos valores do indicador %D. Isso pode ser feito em 2 casos: se a linha %D atingiu o nível crítico oposto (80 para posição longa e 20 para posição curta) se o sinal reverso não for confirmado (quando a linha %D atinge os seguintes níveis: 20 para posição longa e 80 para posição curta) Fig. 3. Padrão "Dark Cloud Cover", confirmado pelo indicador Stochastic 2.1. Abrir Posição Longa/Fechar Posição Curta A formação do padrão "Piercing Line" deve ser confirmada pelo Stochastic: StochSignal(1)<30 (o valor da linha de sinal do indicador Stochastic da última barra completada deve ser menor que 30). A posição curta deve ser fechada se a linha de sinal do Stochastic cruzou para cima os níveis 20 ou 80. //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição longa, resultado=80) | //| 2) Saída do mercado (fechar posição curta, resultado=40) | //+------------------------------------------------------------------+ int CDC_PL_Stoch::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do Expert Advisor //--- idx=0 - neste caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, o EA verifica as condições de negociação apenas em novas barras   int idx   =StartIndex(); //--- verificando as condições para abrir posição longa //--- formação do padrão Piercing Line e linha de sinal<30   if (CheckCandlestickPattern(CANDLE_PATTERN_PIERCING_LINE) && (StochSignal(1)<30))      result=80; //--- verificando as condições para fechar posição curta //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo 20, para cima 80)    if((((StochSignal(1)>20) && (StochSignal(2)<20)) ||        ((StochSignal(1)>80) && (StochSignal(2)<80))))      result=40; //--- retorna o resultado    return(result);   } 2.2. Abrir Posição Curta/Fechar Posição Longa A formação do padrão "Dark Cloud Cover" deve ser confirmada pelo Stochastic: StochSignal(1)>70 (o valor da linha de sinal do indicador Stochastic da última barra completada deve ser maior que 70). A posição longa deve ser fechada se a linha de sinal do Stochastic cruzou para baixo os níveis 80 ou 20. //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição curta, resultado=80) | //| 2) Saída do mercado (fechar posição longa, resultado=40) | //+------------------------------------------------------------------+ int CDC_PL_Stoch::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do Expert Advisor //--- idx=0 - neste caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, o EA verifica as condições de negociação apenas em novas barras   int idx   =StartIndex(); //--- verificando as condições para abrir posição curta //--- formação do padrão Dark Cloud Cover e linha de sinal>70   if (CheckCandlestickPattern(CANDLE_PATTERN_DARK_CLOUD_COVER) && (StochSignal(1)>70))      result=80; //--- verificando as condições para fechar posição longa //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo 80, para cima 20)    if((((StochSignal(1)<80) && (StochSignal(2)>80)) ||        ((StochSignal(1)<20) && (StochSignal(2)>20))))      result=40; //--- retorna o resultado    return(result);   } 2.3. Criando um Expert Advisor Usando o MQL5 Wizard A classe CDC_PL_Stoch não está incluída nas classes da Biblioteca Padrão, para usá-la, é necessário baixar o arquivo adc_pl_stoch.mqh (veja os anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo candlepatterns.mqh. Você pode usá-los no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Expert Advisor, inicie o MQL5 Wizard: Fig. 4. Criando Expert Advisor usando MQL5 Wizard Vamos especificar o nome do Expert Advisor: Fig. 5. Propriedades gerais do Expert Advisor Depois disso, precisamos selecionar os módulos de sinais de negociação utilizados. Fig. 6. Propriedades de sinal do Expert Advisor No nosso caso, usamos apenas um módulo de sinais de negociação. Adicionando o módulo de sinais Baseados em Dark Cloud Cover/Piercing Line confirmados pelo Stochastic: Fig. 7. Propriedades de sinal do Expert Advisor Módulo de sinais de negociação adicionado: Fig. 8. Propriedades de sinal do Expert Advisor Você pode selecionar quaisquer propriedades de trailing, mas usaremos "Trailing Stop não utilizado": Fig. 9. Propriedades de gestão de dinheiro do Expert Advisor Quanto às propriedades de gestão de dinheiro, usaremos "Negociação com volume fixo": Fig. 10. Propriedades de gestão de dinheiro do Expert Advisor Ao pressionar o botão "Finalizar", obteremos o código do Expert Advisor gerado, localizado em Expert_ADC_PL_Stoch.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrão do Expert Advisor gerado: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =10;     // Valor do limite de sinal para abrir [0...100] input int            Signal_ThresholdClose  =10;     // Valor do limite de sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar uma negociação input double         Signal_StopLevel       =50.0;   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0  // Nível de Take Profit (em pontos) devem ser substituídos por: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =40;     // Valor do limite de sinal para abrir [0...100] input int            Signal_ThresholdClose  =20;     // Valor do limite de sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar uma negociação input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis limites para abrir e fechar posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de negociação, especificamos os valores fixos do limite: Abrir posição: 80; Fechar posição: 40. O Expert Advisor gerado pelo MQL5 Wizard abre e fecha posições usando os "votos" dos módulos de sinais de negociação. O voto do módulo principal (como um contêiner, que consiste em todos os módulos adicionados) também é usado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal também são utilizados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de negociação, então precisamos levar esse fato em consideração ao definir os valores de limite. Por causa disso, os ThresholdOpen e ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, isso significa que o fechamento das posições será feito somente quando as condições de fechamento forem verdadeiras. 2.4. Resultados de Backtesting da História Vamos considerar o backtesting do Expert Advisor em dados históricos (EURUSD H1, período de teste: 01.01.2010 - 02.02.2011, PeriodK=9, PeriodD=5, PeriodSlow=20, MA_period=27). Na criação do Expert Advisor, usamos o volume fixo (Negociação com Lote Fixo, 0.1), o algoritmo Trailing Stop não é utilizado (Trailing não utilizado). Fig. 11. Resultados de teste do Expert Advisor baseado em Dark Cloud Cover/Piercing Line + Stochastic O melhor conjunto de parâmetros de entrada pode ser encontrado usando o Strategy Tester do terminal MetaTrader 5. O código do Expert Advisor, criado pelo MQL5 Wizard, está anexado em expert_adc_pl_stoch.mq5.

2011.02.25
MQL5 Wizard: Sinais de Negociação com Padrões Candlestick e RSI no MetaTrader 5
MetaTrader5
MQL5 Wizard: Sinais de Negociação com Padrões Candlestick e RSI no MetaTrader 5

O MQL5 Wizard é uma ferramenta poderosa que possibilita a criação de Robôs de Negociação prontos, utilizando as classes da biblioteca padrão que acompanham o terminal cliente. Com ele, você pode verificar suas ideias de negociação de forma rápida, basta criar sua própria classe de sinais de negociação. Para mais detalhes sobre a estrutura dessa classe, confira o artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação. A ideia básica é a seguinte: a classe de sinais de negociação deve ser derivada de CExpertSignal. A partir daí, é necessário sobrescrever os métodos virtuais LongCondition() e ShortCondition() com suas próprias implementações. Um livro interessante é "Estratégias dos melhores traders" (em russo), que aborda várias estratégias de negociação. Vamos focar nos padrões de reversão de candlestick, confirmados pelos osciladores Estocástico, CCI, MFI e RSI. A melhor abordagem é criar uma classe separada, derivada de CExpertSignal, para verificar a formação de padrões de candlestick. Para confirmar os sinais de negociação gerados por esses padrões, basta escrever uma classe derivada de CCandlePattern e adicionar as funcionalidades necessárias (como a confirmação por osciladores). Neste artigo, vamos analisar os sinais baseados no padrão de reversão "3 Corvos Negros / 3 Soldados Brancos", confirmados pelo indicador Índice de Força Relativa (RSI). O módulo de sinais de negociação é baseado na classe CCandlePattern, que oferece um exemplo simples de como criar sinais de negociação com padrões de candlestick. 1. Padrões de Candlestick "3 Corvos Negros" e "3 Soldados Brancos" 1.1. 3 Corvos Negros Esse é um padrão de candlestick de baixa que indica a reversão de uma tendência de alta. O padrão é formado por três candlesticks consecutivos com corpo longo, que fecharam abaixo do dia anterior, e cada abertura ocorrendo dentro do corpo da vela anterior. Fig. 1. Padrão de Candlestick "3 Corvos Negros" O reconhecimento do padrão "3 Corvos Negros" é realizado pelo método CheckPatternThreeBlackCrows da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de candlestick "3 Corvos Negros" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternThreeBlackCrows()   { //--- 3 Corvos Negros    if((Open(3)-Close(3)>AvgBody(1)) && // (vela preta longa)       (Open(2)-Close(2)>AvgBody(1)) &&       (Open(1)-Close(1)>AvgBody(1)) &&       (MidPoint(2)<MidPoint(3))     && // (meios inferiores)       (MidPoint(1)<MidPoint(2)))         return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS) da classe CCandlePattern é utilizado para verificar a formação do padrão "3 Corvos Negros". 1.2. Padrão de Candlestick 3 Soldados Brancos Esse é um padrão de candlestick de alta que indica a reversão de uma tendência de baixa. O padrão é formado por três candlesticks consecutivos com corpo longo, que fecharam acima do dia anterior, com cada abertura ocorrendo dentro do corpo da vela anterior. O padrão é válido enquanto a vela do segundo dia abrir na metade superior do intervalo do primeiro dia. Ao final do segundo dia, deve fechar perto de sua máxima, com uma sombra superior bem pequena ou inexistente. O mesmo padrão é então repetido no terceiro dia. Fig. 2. Padrão de Candlestick "3 Soldados Brancos" Aqui está o método para reconhecimento do padrão "3 Soldados Brancos": //+------------------------------------------------------------------+ //| Verifica a formação do padrão de candlestick "3 Soldados Brancos" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternThreeWhiteSoldiers()   {    //--- 3 Soldados Brancos    if((Close(3)-Open(3)>AvgBody(1)) && // vela branca longa       (Close(2)-Open(2)>AvgBody(1)) &&       (Close(1)-Open(1)>AvgBody(1)) &&       (MidPoint(2)>MidPoint(3))     && // meios superiores       (MidPoint(1)>MidPoint(2)))       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS) da classe CCandlePattern é utilizado para verificar a formação do padrão "3 Soldados Brancos". 2. Sinais de Negociação confirmados pelo indicador RSI Os sinais de negociação para abrir posições longas ou curtas devem ser confirmados pelo indicador RSI. O valor do RSI deve estar abaixo/acima dos níveis críticos (40 para posição longa e 60 para posição curta). O fechamento das posições abertas depende dos valores do RSI. Isso pode ocorrer em duas situações: se o RSI atingir o nível crítico oposto (70 para posição longa e 30 para posição curta) se o sinal reverso não for confirmado (quando o RSI atinge os seguintes níveis: 30 para posição longa e 70 para posição curta) Fig. 3. Padrão "3 Corvos Negros", confirmado pelo indicador Estocástico int CML_RSI::LongCondition() - verifica as condições para abrir posição longa (retorna 80) e fechar posição curta (retorna 40); int CML_RSI::ShortCondition() - verifica as condições para abrir posição curta (retorna 80) e fechar posição longa (retorna 40). 2.1. Abrir posição longa/Fechar posição curta A formação do padrão "3 Soldados Brancos" deve ser confirmada pelo indicador RSI: RSI(1)<40 (o valor do RSI da última barra completada deve ser menor que 40). A posição curta deve ser fechada se o indicador RSI cruzar para cima os níveis críticos 70 ou 30. //+------------------------------------------------------------------+ //| Verifica as condições de entrada e saída do mercado                 | //| 1) Entrada no mercado (abrir posição longa, resultado=80)                  | //| 2) Saída do mercado (fechar posição curta, resultado=40)                 | //+------------------------------------------------------------------+ int CBC_WS_RSI::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do Robô de Negociação //--- idx=0 - neste caso o Robô verifica as condições de negociação a cada tick //--- idx=1 - neste caso o Robô verifica as condições de negociação apenas em novas barras   int idx   =StartIndex(); //--- verificando as condições para abrir posição longa //--- formação do padrão 3 Soldados Brancos e RSI<30   if(CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS) && (RSI(1)<40))      result=80; //--- verificando as condições para fechar posição curta //--- cruzamento da linha sinal de níveis de sobrecompra/sobrevenda (para cima 30, para cima 70)   if(((RSI(1)>30) && (RSI(2)<30)) || ((RSI(1)>70) && (RSI(2)<70)))      result=40; //--- retornar resultado    return(result);   } 2.2. Abrir posição curta/Fechar posição longa A formação do padrão "3 Corvos Negros" deve ser confirmada pelo indicador RSI: RSI(1)>60 (o valor do RSI da última barra completada deve ser maior que 60). A posição longa deve ser fechada se o indicador RSI cruzar para baixo os níveis críticos 70 ou 30. //+------------------------------------------------------------------+ //| Verifica as condições de entrada e saída do mercado                 | //| 1) Entrada no mercado (abrir posição curta, resultado=80)                 | //| 2) Saída do mercado (fechar posição longa, resultado=40)                  | //+------------------------------------------------------------------+ int CBC_WS_RSI::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do Robô de Negociação //--- idx=0 - neste caso o Robô verifica as condições de negociação a cada tick //--- idx=1 - neste caso o Robô verifica as condições de negociação apenas em novas barras   int idx   =StartIndex(); //--- verificando as condições para abrir posição curta //--- formação do padrão 3 Corvos Negros e RSI>60   if(CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS) && (RSI(1)>60))      result=80; //--- verificando as condições para fechar posição longa //--- cruzamento da linha sinal de níveis de sobrecompra/sobrevenda (para baixo 70, para baixo 30)   if(((RSI(1)<70) && (RSI(2)>70)) || ((RSI(1)<30) && (RSI(2)>30)))      result=40; //--- retornar resultado    return(result);   } 2.3. Criando um Robô de Negociação usando o MQL5 Wizard A classe CML_RSI não está inclusa nas classes da Biblioteca Padrão, para usá-la, é necessário baixar o arquivo acml_rsi.mqh (veja os anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo candlepatterns.mqh. Você pode utilizá-los no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Robô de Negociação, inicie o MQL5 Wizard: Fig. 4. Criando Robô de Negociação usando o MQL5 Wizard Vamos especificar o nome do Robô de Negociação: Fig. 5. Propriedades gerais do Robô de Negociação Após isso, precisamos selecionar os módulos de sinais de negociação utilizados. Fig. 6. Propriedades de sinal do Robô de Negociação No nosso caso, usamos apenas um módulo de sinais de negociação. Adicionando o módulo Sinais baseados em 3 Corvos Negros / 3 Soldados Brancos de sinais de negociação: Fig. 7. Propriedades de sinal do Robô de Negociação Módulo de sinais de negociação adicionado: Fig. 8. Propriedades de sinal do Robô de Negociação Você pode selecionar quaisquer propriedades de trailing, mas utilizaremos "Trailing Stop não utilizado": Fig. 9. Propriedades de trailing do Robô de Negociação Em relação às propriedades de gestão de dinheiro, utilizaremos "Negociação com volume fixo": Fig. 10. Propriedades de gestão de dinheiro do Robô de Negociação Ao pressionar o botão "Finalizar", obteremos o código do Robô de Negociação gerado, localizado em Expert_ABC_WS_RSI.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrões do Robô de Negociação gerado: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =10;     // Valor de limite do sinal para abrir [0...100] input int            Signal_ThresholdClose  =10;     // Valor de limite do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar um negócio input double         Signal_StopLevel       =50.0;   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0  // Nível de Take Profit (em pontos) Devem ser alterados para: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =40;     // Valor de limite do sinal para abrir [0...100] input int            Signal_ThresholdClose  =20;     // Valor de limite do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar um negócio input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis de limite para abrir e fechar posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de negociação, foram especificados os valores fixos dos limites: Abertura de posição: 80; Fechamento de posição: 40. O Robô de Negociação gerado pelo MQL5 Wizard abre e fecha posições usando os "votos" dos módulos de sinais de negociação. O voto do módulo principal (como um contêiner, que consiste em todos os módulos adicionados) também é usado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal também são usados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de negociação, então precisamos levar esse fato em conta ao definir os valores de limite. Por conta disso, os valores ThresholdOpen e ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, o que significa que o fechamento das posições será realizado apenas quando as condições de fechamento forem verdadeiras. 2.4. Resultados de Backtesting Histórico Vamos considerar o backtesting do Robô de Negociação em dados históricos (EURUSD H1, período de teste: 2010.01.01-2011.02.02, PeriodRSI=37, MA_period=51). Na criação do Robô de Negociação, utilizamos o volume fixo (Negociação com Lote Fixo, 0.1), e o algoritmo de Trailing Stop não foi utilizado (Trailing não utilizado). Fig. 11. Resultados de teste do Robô de Negociação baseado em 3 Corvos Negros/3 Soldados Brancos + RSI O melhor conjunto de parâmetros de entrada pode ser encontrado usando o Testador de Estratégia do terminal cliente MetaTrader 5. O código do Robô de Negociação, criado pelo MQL5 Wizard, está anexado em expert_abc_ws_rsi.mq5.

2011.02.18
MQL5 Wizard: Sinais de Negociação com 3 Corvos Negros/3 Soldados Brancos e MFI
MetaTrader5
MQL5 Wizard: Sinais de Negociação com 3 Corvos Negros/3 Soldados Brancos e MFI

O MQL5 Wizard é uma ferramenta incrível que te permite criar Robôs de Investimento prontos, baseados nas classes da Biblioteca Padrão do MetaTrader 5. Isso torna mais fácil testar suas ideias de negociação. Para isso, basta criar sua própria classe de sinais de negociação, cuja estrutura e exemplo você pode encontrar no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação. A ideia principal é que a classe de sinais de negociação deriva de CExpertSignal. Depois, você precisa sobrescrever os métodos virtuais LongCondition() e ShortCondition() com os seus métodos personalizados. Um livro interessante é "Estratégias dos Melhores Traders" (em russo), onde várias estratégias de negociação são discutidas. Neste artigo, vamos focar em padrões de velas de reversão, que são confirmados pelos osciladores Estocástico, CCI, MFI e RSI.A melhor abordagem é criar uma classe separada, derivada de CExpertSignal para verificar a formação dos padrões de velas. Para a confirmação dos sinais de negociação gerados pelos padrões de velas, basta escrever uma classe derivada de CCandlePattern e adicionar as características necessárias (por exemplo, a confirmação por osciladores). 1. Padrões de Velas Reversais: "3 Corvos Negros" e "3 Soldados Brancos" 1.1. 3 Corvos Negros Esse padrão de velas de baixa é utilizado para prever uma reversão na tendência de alta atual. Ele é composto por três velas longas consecutivas que fecharam abaixo do dia anterior, com a abertura de cada sessão ocorrendo dentro do corpo da vela anterior. Fig. 1. Padrão de vela "3 Corvos Negros" O reconhecimento do padrão "3 Corvos Negros" é feito pelo método CheckPatternThreeBlackCrows da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de vela "3 Corvos Negros" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternThreeBlackCrows()   { //--- 3 Corvos Negros    if((Open(3)-Close(3)>AvgBody(1)) && // (vela longa preta)       (Open(2)-Close(2)>AvgBody(1)) &&       (Open(1)-Close(1)>AvgBody(1)) &&       (MidPoint(2)<MidPoint(3))     && // (pontos médios mais baixos)       (MidPoint(1)<MidPoint(2)))         return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS) da classe CCandlePattern é utilizado para verificar a formação do padrão "3 Corvos Negros". 1.2. Padrão "3 Soldados Brancos" Esse padrão de alta é usado para prever a reversão da tendência de baixa atual. Ele consiste em três velas longas consecutivas que fecharam acima do dia anterior, com a abertura de cada sessão ocorrendo dentro do corpo da vela anterior. O padrão é válido desde que a vela do segundo dia abra na metade superior da faixa do primeiro dia. Até o final do segundo dia, ela deve fechar perto da máxima, deixando uma sombra superior muito pequena ou inexistente. O mesmo padrão deve ser repetido no terceiro dia. Fig. 2. Padrão de vela "3 Soldados Brancos" Aqui está o método para reconhecer o padrão "3 Soldados Brancos": //+------------------------------------------------------------------+ //| Verifica a formação do padrão de vela "3 Soldados Brancos" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternThreeWhiteSoldiers()   {    //--- 3 Soldados Brancos    if((Close(3)-Open(3)>AvgBody(1)) && // vela longa branca       (Close(2)-Open(2)>AvgBody(1)) &&       (Close(1)-Open(1)>AvgBody(1)) &&       (MidPoint(2)>MidPoint(3))     && // pontos médios mais altos       (MidPoint(1)>MidPoint(2)))       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS) da classe CCandlePattern é utilizado para verificar a formação do padrão "3 Soldados Brancos". 2. Sinais de Negociação Confirmados pelo Indicador MFI Os sinais de negociação para abrir posições longas ou curtas devem ser confirmados pelo indicador MFI. O valor do indicador MFI deve ser menor que 40 (para posições longas) ou maior que 60 (para posições curtas). O fechamento das posições abertas depende dos valores do indicador MFI. Isso pode ser feito em 2 casos: se o MFI atingir o nível crítico oposto (70 para posição longa e 30 para posição curta) se o sinal reverso não for confirmado (quando o indicador MFI atinge os seguintes níveis: 30 para posição longa e 70 para posição curta) Fig. 3. Padrão '3 Corvos Negros', confirmado pelo indicador MFI int CBC_WS_MFI::LongCondition() - verifica as condições para abrir posição longa (retorna 80) e fechar a posição curta (retorna 40); int CBC_WS_MFI::ShortCondition() - verifica as condições para abrir posição curta (retorna 80) e fechar a posição longa (retorna 40). 2.1. Abrindo posição longa/Fechando posição curta A formação do padrão "3 Soldados Brancos" deve ser confirmada pelo indicador MFI: MFI(1)<40 (o valor do indicador MFI da última barra completada deve ser menor que 40). A posição curta deve ser fechada se o indicador MFI cruzar para cima os níveis críticos (70 ou 30). //+------------------------------------------------------------------+ //| Verifica as condições de entrada e saída do mercado                 | //| 1) Entrada no mercado (abrir posição longa, resultado=80)                  | //| 2) Saída do mercado (fechar posição curta, resultado=40)                 | //+------------------------------------------------------------------+ int CBC_WS_MFI::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do Robô //--- idx=0 - neste caso o Robô verifica as condições de negociação a cada tick //--- idx=1 - neste caso o Robô verifica as condições de negociação apenas em barras de notícias   int idx   =StartIndex(); //--- verificando as condições para abrir posição longa //--- formação do padrão 3 Soldados Brancos e MFI<40   if(CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS) && (MFI(1)<40))      result=80; //--- verificando as condições para fechar a posição curta //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para cima 30, para cima 70)   if(((MFI(1)>30) && (MFI(2)<30)) || ((MFI(1)>70) && (MFI(2)<70)))      result=40; //--- retornar resultado    return(result);   } 2.2. Abrindo posição curta/Fechando posição longa A formação do padrão "3 Corvos Negros" deve ser confirmada pelo indicador MFI: MFI(1)>60 (o valor do indicador MFI da última barra completada deve ser maior que 60). A posição longa deve ser fechada se o indicador MFI cruzar para cima os níveis críticos (70 ou 30). //+------------------------------------------------------------------+ //| Verifica as condições de entrada e saída do mercado                 | //| 1) Entrada no mercado (abrir posição curta, resultado=80)                 | //| 2) Saída do mercado (fechar posição longa, resultado=40)                  | //+------------------------------------------------------------------+ int CBC_WS_MFI::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do Robô //--- idx=0 - neste caso o Robô verifica as condições de negociação a cada tick //--- idx=1 - neste caso o Robô verifica as condições de negociação apenas em barras de notícias   int idx   =StartIndex(); //--- verificando as condições para abrir posição curta //--- formação do padrão 3 Corvos Negros e MFI>60   if(CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS) && (MFI(1)>60))      result=80; //--- verificando as condições para fechar a posição longa //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para cima 70, para baixo 30)    if(((MFI(1)>70) && (MFI(2)<70)) || ((MFI(1)<30) && (MFI(2)>30)))      result=40; //--- retornar resultado    return(result);   } 2.3. Criando o Robô de Investimento com o MQL5 Wizard A classe CBC_WS_MFI não está incluída nas classes da Biblioteca Padrão; para usá-la, é necessário baixar o arquivo abc_ws_mfi.mqh (veja os anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo acandlepatterns.mqh. Você poderá usá-los no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Robô de Investimento, inicie o MQL5 Wizard: Fig. 4. Criando Robô de Investimento com o MQL5 Wizard Vamos especificar o nome do Robô de Investimento: Fig. 5. Propriedades gerais do Robô de Investimento Após isso, precisamos selecionar os módulos de sinais de negociação utilizados. Fig. 6. Propriedades de sinal do Robô de Investimento No nosso caso, utilizamos apenas um módulo de sinais de negociação. Adicionando o módulo de Sinais baseados em 3 Corvos Negros/3 Soldados Brancos, confirmados por MFI: Fig. 7. Propriedades de sinal do Robô de Investimento Módulo de sinais de negociação adicionado: Fig. 8. Propriedades de sinal do Robô de Investimento Você pode selecionar quaisquer propriedades de trailing, mas usaremos "Trailing Stop não utilizado": Fig. 9. Propriedades de trailing do Robô de Investimento Quanto às propriedades de gerenciamento de dinheiro, usaremos "Negociação com volume fixo": Fig. 10. Propriedades de gerenciamento de dinheiro do Robô de Investimento Ao pressionar o botão "Finalizar", obteremos o código do Robô de Investimento gerado, localizado em Expert_ABC_WS_MFI.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrão do Robô de Investimento gerado: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =10;     // Valor de limiar do sinal para abrir [0...100] input int            Signal_ThresholdClose  =10;     // Valor de limiar do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar um negócio input double         Signal_StopLevel       =50.0;   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0;  // Nível de Take Profit (em pontos) devem ser substituídos por: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =40;     // Valor de limiar do sinal para abrir [0...100] input int            Signal_ThresholdClose  =20;     // Valor de limiar do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0    // Nível de preço para executar um negócio input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis de limiar para a abertura e fechamento de posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de negociação, especificamos os valores fixos do limiar: Abrir posição: 80; Fechar posição: 40. O Robô de Investimento gerado pelo MQL5 Wizard abre e fecha posições utilizando os "votos" dos módulos de sinais de negociação. O voto do módulo principal (como um contêiner, que consiste em todos os módulos adicionados) também é usado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal também são usados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de negociação, então precisamos levar em conta esse fato ao definir os valores dos limiares. Por causa disso, o ThresholdOpen e o ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, o que significa que o fechamento das posições será feito apenas quando as condições de fechamento forem verdadeiras. 2.4. Resultados de Testes de Retrospectiva Vamos considerar o teste de um Robô de Investimento em dados históricos (EURUSD H1, período de teste: 01/01/2010 a 16/03/2011, PeriodMFI=37, MA_period=13). Na criação do Robô de Investimento, utilizamos o volume fixo (Negociação com Lote Fixo, 0.1), o algoritmo de Trailing Stop não é utilizado (Trailing não utilizado). Fig. 11. Resultados de teste do Robô de Investimento, baseado em 3 Corvos Negros/3 Soldados Brancos + MFI O melhor conjunto de parâmetros de entrada pode ser encontrado usando o Strategy Tester do terminal cliente MetaTrader 5. O código do Robô de Investimento, criado pelo MQL5 Wizard, está anexado em expert_abc_ws_mfi.mq5.

2011.02.18
Sinais de Negociação com Padrões de Candlestick e CCI no MetaTrader 5
MetaTrader5
Sinais de Negociação com Padrões de Candlestick e CCI no MetaTrader 5

O MQL5 Wizard é uma ferramenta poderosa que permite criar Consultores Especializados prontos com base nas classes da biblioteca padrão que vem com o terminal cliente. Com ele, você pode validar rapidamente suas ideias de negociação, bastando criar sua própria classe de sinais de negociação. Para mais detalhes sobre a estrutura da classe, confira o artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Negociação. A ideia básica é a seguinte: a classe de sinais de negociação é derivada de CExpertSignal. Em seguida, é necessário sobrescrever os métodos virtuais LongCondition() e ShortCondition() com suas próprias implementações. Se você está em busca de estratégias eficazes, um bom ponto de partida é o livro "Estratégias dos Melhores Traders" (em russo), onde são discutidas diversas estratégias de negociação. Neste artigo, vamos focar nos padrões de candlestick de reversão, confirmados pelos osciladores Estocástico, CCI, MFI e RSI. A melhor abordagem é criar uma classe separada, derivada de CExpertSignal, para verificar a formação dos padrões de candlestick. Para confirmar os sinais de negociação gerados por esses padrões, você só precisará escrever uma classe derivada de CCandlePattern e adicionar os recursos necessários (como a confirmação pelos osciladores). Neste artigo, vamos discutir os sinais baseados no padrão de reversão de "3 Corvos Negros/3 Soldados Brancos", confirmados pelo indicador Índice de Canal de Commodities (CCI). O módulo de sinais de negociação será baseado na classe CCandlePattern, que é um exemplo simples de como criar sinais de negociação com padrões de candlestick. 1. Padrões de Candlestick "3 Corvos Negros" e "3 Soldados Brancos" 1.1. 3 Corvos Negros Um padrão de candlestick de baixa que prevê a reversão da tendência de alta atual. Esse padrão consiste em três candlesticks consecutivos com corpo longo, que fecharam abaixo do dia anterior, com a abertura de cada sessão ocorrendo dentro do corpo da vela anterior. Padrão de candlestick "3 Corvos Negros" O reconhecimento do padrão "3 Corvos Negros" é implementado no método CheckPatternThreeBlackCrows da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de candlestick "3 Corvos Negros" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternThreeBlackCrows()   { //--- 3 Corvos Negros    if((Open(3)-Close(3)>AvgBody(1)) && // (corpo longo)       (Open(2)-Close(2)>AvgBody(1)) &&       (Open(1)-Close(1)>AvgBody(1)) &&       (MidPoint(2)<MidPoint(3))     && // (midpoints inferiores)       (MidPoint(1)<MidPoint(2)))         return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS) da classe CCandlePattern é usado para verificar a formação do padrão "3 Corvos Negros". 1.2. Padrão de candlestick 3 Soldados Brancos Um padrão de candlestick de alta que prevê a reversão da tendência de baixa atual. Esse padrão é composto por três candlesticks consecutivos com corpo longo, que fecharam acima do dia anterior, com a abertura de cada sessão ocorrendo dentro do corpo da vela anterior. O padrão é válido enquanto a vela do segundo dia abrir na metade superior do intervalo do primeiro dia. Ao final do segundo dia, deve fechar próximo ao seu ponto mais alto, deixando uma sombra superior muito pequena ou inexistente. O mesmo padrão é então repetido no terceiro dia. Padrão de candlestick "3 Soldados Brancos" Aqui está o método para reconhecimento do padrão "3 Soldados Brancos": //+------------------------------------------------------------------+ //| Verifica a formação do padrão de candlestick "3 Soldados Brancos" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternThreeWhiteSoldiers()   {    //--- 3 Soldados Brancos    if((Close(3)-Open(3)>AvgBody(1)) && // (corpo longo)       (Close(2)-Open(2)>AvgBody(1)) &&       (Close(1)-Open(1)>AvgBody(1)) &&       (MidPoint(2)>MidPoint(3))     && // (midpoints superiores)       (MidPoint(1)>MidPoint(2)))       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS) da classe CCandlePattern é usado para verificar a formação do padrão "3 Soldados Brancos". 2. Sinais de Negociação, Confirmados pelo Indicador CCI Os sinais de negociação para abrir uma posição longa ou curta devem ser confirmados pelo indicador CCI. O valor do CCI deve ser maior/menor do que os níveis críticos (-50 para posição longa e 50 para posição curta). O fechamento da posição aberta depende dos valores do CCI. Isso pode ser feito em duas situações: se a linha do CCI atingir o nível crítico oposto (80 para posição longa e -80 para posição curta) se o sinal reverso não for confirmado (quando o CCI atingir os seguintes níveis: -80 para posição longa e 80 para posição curta) Padrão "3 Corvos Negros", confirmado pelo indicador CCI int CBC_WS_CCI::LongCondition() - verifica as condições para abrir posição longa (retorna 80) e fechar a posição curta (retorna 40); int CBC_WS_CCI::ShortCondition() - verifica as condições para abrir posição curta (retorna 80) e fechar a posição longa (retorna 40). 2.1. Abrir Posição Longa/Fechar Posição Curta A formação do padrão "3 Corvos Negros" deve ser confirmada pelo indicador CCI: CCI(1)<-50 (o valor do CCI da última barra completada deve ser menor que -50). A posição curta deve ser fechada se o indicador CCI cruzar para cima o nível crítico -80 ou cruzar para baixo o nível crítico 80. //+------------------------------------------------------------------+ //| Verifica as condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição longa, resultado=80) | //| 2) Saída do mercado (fechar posição curta, resultado=40) | //+------------------------------------------------------------------+ int CBC_WS_CCI::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do EA //--- idx=0 - neste caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, o EA verifica as condições de negociação apenas em barras de notícias    int idx   =StartIndex(); //--- verificação das condições para abrir posição longa //--- formação do padrão 3 Soldados Brancos e CCI<-50    if(CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS) && (CCI(1)<-50))      result=80; //--- verificação das condições para fechar posição curta //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo -80, para cima -80)    if(((CCI(1)>-80) && (CCI(2)<-80)) || ((CCI(1)<80) && (CCI(2)>80)))      result=40; //--- retornar resultado    return(result);   } 2.2. Abrir Posição Curta/Fechar Posição Longa A formação do padrão "3 Soldados Brancos" deve ser confirmada pelo indicador CCI: CCI(1)>50 (o valor do CCI da última barra completada deve ser maior que 50). A posição longa deve ser fechada se o indicador CCI cruzar para baixo os níveis -80 ou 80. //+------------------------------------------------------------------+ //| Verifica as condições para entrada e saída do mercado | //| 1) Entrada no mercado (abrir posição curta, resultado=80) | //| 2) Saída do mercado (fechar posição longa, resultado=40) | //+------------------------------------------------------------------+ int CBC_WS_CCI::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de operação do EA //--- idx=0 - neste caso, o EA verifica as condições de negociação a cada tick //--- idx=1 - neste caso, o EA verifica as condições de negociação apenas em barras de notícias    int idx   =StartIndex(); //--- verificação das condições para abrir posição curta //--- formação do padrão 3 Corvos Negros e CCI>50    if(CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS) && (CCI(1)>50))      result=80; //--- verificação das condições para fechar posição longa //--- cruzamento da linha de sinal dos níveis de sobrecompra/sobrevenda (para baixo -80, para cima 80)    if(((CCI(1)<80) && (CCI(2)>80)) || ((CCI(1)<-80) && (CCI(2)>-80)))      result=40; //--- retornar resultado    return(result);   } 2.3. Criando um Consultor Especializado Usando o MQL5 Wizard A classe CBC_WS_CCI não está incluída nas classes da Biblioteca Padrão. Para utilizá-la, é necessário baixar o arquivo acbc_ws_cci.mqh (veja os anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo candlepatterns.mqh. Você pode usá-los no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Consultor Especializado, inicie o MQL5 Wizard: Criando Consultor Especializado com MQL5 Wizard Vamos especificar o nome do Consultor Especializado: Propriedades gerais do Consultor Especializado Depois disso, precisamos selecionar os módulos de sinais de negociação utilizados. Propriedades dos sinais do Consultor Especializado Neste caso, usamos apenas um módulo de sinais de negociação. Adicionando o módulo de Sinais baseados em 3 Corvos Negros/3 Soldados Brancos confirmados pelo CCI: Propriedades dos sinais do Consultor Especializado Módulo de sinais de negociação adicionado: Propriedades dos sinais do Consultor Especializado Você pode selecionar quaisquer propriedades de trailing, mas vamos usar "Trailing Stop não utilizado": Propriedades de trailing do Consultor Especializado Quanto às propriedades de gerenciamento de dinheiro, usaremos "Negociar com volume fixo": Propriedades de gerenciamento de dinheiro do Consultor Especializado Ao pressionar o botão "Finalizar", obteremos o código do Consultor Especializado gerado, localizado em Expert_ABC_WS_CCI.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts\. Os parâmetros de entrada padrão do Consultor Especializado gerado: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =10;     // Valor do limiar do sinal para abrir [0...100] input int            Signal_ThresholdClose  =10;     // Valor do limiar do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar um negócio input double         Signal_StopLevel       =50.0;   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0   // Nível de Take Profit (em pontos) devem ser substituídos por: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =40;     // Valor do limiar do sinal para abrir [0...100] input int            Signal_ThresholdClose  =20;     // Valor do limiar do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar um negócio input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis de limiar para abrir e fechar posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de negociação, especificamos os valores fixos do limiar: Abrir posição: 80; Fechar posição: 40. O Consultor Especializado gerado pelo MQL5 Wizard abre e fecha posições utilizando os "votos" dos módulos de sinais de negociação. O voto do módulo principal (como contêiner, que consiste em todos os módulos adicionados) também é utilizado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal também são usados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de negociação, então precisamos considerar esse fato ao definir os valores limites. Por causa disso, os valores ThresholdOpen e ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel são definidos como 0, o que significa que o fechamento das posições será feito apenas quando as condições de fechamento forem verdadeiras. 2.4. Resultados de Backtesting Histórico Vamos considerar o backtesting do Consultor Especializado em dados históricos (EURUSD H1, período de teste: 2010.01.01-2011.03.16, PeriodCCI=37, MA_period=13). Na criação do Consultor Especializado, usamos o volume fixo (Negociação com Lote Fixo, 0.1), o algoritmo de Trailing Stop não foi utilizado (Trailing não utilizado). Resultados do teste do Consultor Especializado, baseado em 3 Corvos Negros/3 Soldados Brancos + CCI O melhor conjunto de parâmetros de entrada pode ser encontrado usando o Tester de Estratégias do terminal cliente MetaTrader 5. O código do Consultor Especializado, criado pelo MQL5 Wizard está anexado em expert_abc_ws_cci.mq5.

2011.02.18
MQL5 Wizard: Sinais de Negócios com 3 Corvos Negros/3 Soldados Brancos + Estocástico para MetaTrader 5
MetaTrader5
MQL5 Wizard: Sinais de Negócios com 3 Corvos Negros/3 Soldados Brancos + Estocástico para MetaTrader 5

O MQL5 Wizard é uma ferramenta incrível que permite criar Expert Advisors prontos, utilizando as classes da biblioteca padrão do terminal cliente (veja Criando Expert Advisors no MQL5 Wizard para mais detalhes). Com ele, você pode verificar suas ideias de trading rapidamente, bastando criar sua própria classe de sinais de trading. A estrutura dessa classe e um exemplo podem ser encontrados no artigo MQL5 Wizard: Como Criar um Módulo de Sinais de Trading. A ideia básica é a seguinte: a classe de sinais de trading é derivada de CExpertSignal. Em seguida, você precisa sobrepor os métodos virtuais LongCondition() e ShortCondition() com seus próprios métodos. Há um livro chamado "Estratégias dos Melhores Traders" (em russo), onde são discutidas muitas estratégias de trading. Aqui, vamos focar em padrões de velas de reversão, confirmados pelo Estocástico, CCI, MFI e RSI. A melhor abordagem é criar uma classe separada, derivada de CExpertSignal, para verificar a formação dos padrões de velas. Para confirmar os sinais de trading gerados pelos padrões de velas, basta escrever a classe derivada de CCandlePattern e adicionar os recursos necessários (por exemplo, confirmação por osciladores). Vamos considerar os sinais baseados no padrão de velas de reversão "3 Corvos Negros/3 Soldados Brancos", confirmados pelo Estocástico. O módulo de sinais de trading é baseado na classe CCandlePattern, que é um exemplo simples de seu uso para criação de sinais de trading com padrões de velas. 1. Padrões de Velas de Reversão: "3 Corvos Negros" e "3 Soldados Brancos" 1.1. 3 Corvos Negros Um padrão de velas de baixa que é usado para prever a reversão da tendência de alta atual. Este padrão consiste em três velas longas consecutivas que fecharam abaixo do dia anterior, com a abertura de cada sessão ocorrendo dentro do corpo da vela anterior. Figura 1. Padrão de velas '3 Corvos Negros' O reconhecimento do padrão "3 Corvos Negros" é implementado no método CheckPatternThreeBlackCrows da classe CCandlePattern: //+------------------------------------------------------------------+ //| Verifica a formação do padrão de velas "3 Corvos Negros" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternThreeBlackCrows()   { //--- 3 Corvos Negros    if((Open(3)-Close(3)>AvgBody(1)) && // (vela longa preta)       (Open(2)-Close(2)>AvgBody(1)) &&       (Open(1)-Close(1)>AvgBody(1)) &&       (MidPoint(2)<MidPoint(3))     && // (midpoints inferiores)       (MidPoint(1)<MidPoint(2)))         return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS) da classe CCandlePattern é utilizado para verificar a formação do padrão de velas "3 Corvos Negros". 1.2. Padrão de Velas "3 Soldados Brancos" Um padrão de velas de alta que é usado para prever a reversão da tendência de baixa atual. Este padrão consiste em três velas longas consecutivas que fecharam acima do dia anterior, com a abertura de cada sessão ocorrendo dentro do corpo da vela anterior. O padrão é válido enquanto a vela do segundo dia abrir na metade superior da faixa do primeiro dia. Ao final do segundo dia, deve fechar perto de sua máxima, deixando uma sombra superior muito pequena ou inexistente. O mesmo padrão é repetido no terceiro dia. Figura 2. Padrão de velas '3 Soldados Brancos' Aqui está o método para reconhecer o padrão "3 Soldados Brancos": //+------------------------------------------------------------------+ //| Verifica a formação do padrão de velas "3 Soldados Brancos" | //+------------------------------------------------------------------+ bool CCandlePattern::CheckPatternThreeWhiteSoldiers()   {    //--- 3 Soldados Brancos    if((Close(3)-Open(3)>AvgBody(1)) && // vela longa branca       (Close(2)-Open(2)>AvgBody(1)) &&       (Close(1)-Open(1)>AvgBody(1)) &&       (MidPoint(2)>MidPoint(3))     && // midpoints superiores       (MidPoint(1)>MidPoint(2)))       return(true); //---    return(false);   } O método CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS) da classe CCandlePattern é utilizado para verificar a formação do padrão de velas "3 Soldados Brancos". 2. Sinais de Trading, Confirmados pelo Indicador Estocástico Os sinais de trading para abrir posições longas ou curtas devem ser confirmados pelo oscilador Estocástico. A linha %D deve ser maior ou menor que o nível crítico correspondente (30 ou 70). O fechamento de uma posição aberta depende dos valores do indicador %D. Isso pode ser feito em dois casos: se a linha %D atingiu o nível crítico oposto (80 para a posição longa e 20 para a posição curta) se o sinal reverso não for confirmado (quando a linha %D atinge os seguintes níveis: 20 para a posição longa e 80 para a posição curta) Fig. 3. Padrão '3 Soldados Brancos', confirmado pelo indicador Estocástico Verificamos as condições de trading para entrada e saída em dois métodos: int CBC_WS_Stoch::LongCondition() - verifica as condições para abrir uma posição longa (retorna 80) e fechar a posição curta (retorna 40); int CBC_WS_Stoch::ShortCondition() - verifica as condições para abrir uma posição curta (retorna 80) e fechar a posição longa (retorna 40). 2.1. Abrir Posição Longa/Fechar Posição Curta A formação do padrão "Três Soldados Brancos" deve ser confirmada pelo indicador Estocástico: StochSignal(1)<30 (o valor da linha de sinal do indicador Estocástico do último candle deve ser menor que 30). A posição curta deve ser fechada se a linha de sinal do Estocástico cruzar para cima os níveis 20 ou 80. //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado                  | //| 1) Entrada no mercado (abrir posição longa, resultado=80)            | //| 2) Saída do mercado (fechar posição curta, resultado=40)          | //+------------------------------------------------------------------+ int CBC_WS_Stoch::LongCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do Expert Advisor //--- idx=0 - neste caso, o EA verifica condições de trading a cada tick //--- idx=1 - neste caso, o EA verifica condições de trading apenas em barras de notícias   int idx   =StartIndex(); //--- verificando as condições para abrir posição longa //--- formação do padrão 3 Soldados Brancos e linha de sinal<30   if (CheckCandlestickPattern(CANDLE_PATTERN_THREE_WHITE_SOLDIERS) && (StochSignal(1)<30))      result=80; //--- verificando as condições para fechar posição curta //--- cruzamento da linha de sinal nos níveis de sobrecompra/sobrevenda (para baixo 20, para cima 80)    if((((StochSignal(1)>20) && (StochSignal(2)<20)) ||        ((StochSignal(1)>80) && (StochSignal(2)<80))))      result=40; //--- retornar resultado    return(result);   } 2.2. Abrir Posição Curta/Fechar Posição Longa A formação do padrão "Três Corvos Negros" deve ser confirmada pelo indicador Estocástico: StochSignal(1)>70 (o valor da linha de sinal do indicador Estocástico do último candle deve ser maior que 70). A posição longa deve ser fechada se a linha de sinal do Estocástico cruzar para baixo os níveis 80 ou 20. //+------------------------------------------------------------------+ //| Verifica condições para entrada e saída do mercado                  | //| 1) Entrada no mercado (abrir posição curta, resultado=80)           | //| 2) Saída do mercado (fechar posição longa, resultado=40)          | //+------------------------------------------------------------------+ int CBC_WS_Stoch::ShortCondition()   {    int result=0; //--- idx pode ser usado para determinar o modo de trabalho do Expert Advisor //--- idx=0 - neste caso, o EA verifica condições de trading a cada tick //--- idx=1 - neste caso, o EA verifica condições de trading apenas em barras de notícias   int idx   =StartIndex(); //--- verificando as condições para abrir posição curta //--- formação do padrão 3 Corvos Negros e linha de sinal>70   if (CheckCandlestickPattern(CANDLE_PATTERN_THREE_BLACK_CROWS) && (StochSignal(1)>70))      result=80; //--- verificando as condições para fechar posição longa //--- cruzamento da linha de sinal nos níveis de sobrecompra/sobrevenda (para baixo 80, para cima 20)    if((((StochSignal(1)<80) && (StochSignal(2)>80)) ||        ((StochSignal(1)<20) && (StochSignal(2)>20))))      result=40; //--- retornar resultado    return(result);   } 2.3. Criando um Expert Advisor com o MQL5 Wizard A classe CBC_WS_Stoch não está inclusa nas classes da Biblioteca Padrão, para utilizá-la, é necessário baixar o arquivo acbc_ws_stoch.mqh (veja os anexos) e salvá-lo na pasta client_terminal_data\MQL5\Include\Expert\Signal\MySignals. O mesmo deve ser feito com o arquivo candlepatterns.mqh. Você pode usá-lo no MQL5 Wizard após reiniciar o MetaEditor. Para criar um Expert Advisor, inicie o MQL5 Wizard: Fig. 4. Criando Expert Advisor usando o MQL5 Wizard Vamos especificar o nome do Expert Advisor: Fig. 5. Propriedades gerais do Expert Advisor Depois disso, precisamos selecionar os módulos de sinais de trading usados. Fig. 6. Propriedades de sinal do Expert Advisor Neste caso, utilizamos apenas um módulo de sinais de trading. Adicionando o módulo "Sinais baseados em 3 Corvos Negros/3 Soldados Brancos confirmados pelo Estocástico": Fig. 7. Propriedades de sinal do Expert Advisor Módulo de sinais de trading adicionado: Fig. 8. Propriedades de sinal do Expert Advisor Você pode selecionar qualquer propriedade de trailing, mas usaremos "Trailing Stop não utilizado": Fig. 9. Propriedades de trailing do Expert Advisor Sobre as propriedades de gestão de dinheiro, utilizaremos "Trading com volume fixo": Fig. 10. Propriedades de gestão de dinheiro do Expert Advisor Ao pressionar o botão "Finalizar", obteremos o código do Expert Advisor gerado, localizado em Expert_ABC_WS_Stoch.mq5, que será salvo na pasta terminal_data_folder\MQL5\Experts. Os parâmetros de entrada padrão do Expert Advisor gerado: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =10;     // Valor do limiar do sinal para abrir [0...100] input int            Signal_ThresholdClose  =10;     // Valor do limiar do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar um negócio input double         Signal_StopLevel       =50.0;   // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =50.0;  // Nível de Take Profit (em pontos) devem ser substituídos por: //--- entradas para o sinal principal input int            Signal_ThresholdOpen   =40;     // Valor do limiar do sinal para abrir [0...100] input int            Signal_ThresholdClose  =20;     // Valor do limiar do sinal para fechar [0...100] input double         Signal_PriceLevel      =0.0;    // Nível de preço para executar um negócio input double         Signal_StopLevel       =0.0    // Nível de Stop Loss (em pontos) input double         Signal_TakeLevel       =0.0    // Nível de Take Profit (em pontos) Os parâmetros de entrada Signal_ThresholdOpen/Signal_ThresholdClose permitem especificar os níveis de limiar para abertura e fechamento de posições. No código dos métodos LongCondition() e ShortCondition() da classe de sinais de trading, especificamos os valores fixos do limiar: Abrir posição: 80; Fechar posição: 40. O Expert Advisor, gerado pelo MQL5 Wizard, abre e fecha posições usando os "votos" dos módulos de sinais de trading. O voto do módulo principal (como contêiner, que consiste em todos os módulos adicionados) também é usado, mas seus métodos LongCondition() e ShortCondition() sempre retornam 0. Os resultados dos votos do módulo principal também são utilizados na média dos "votos". No nosso caso, temos: módulo principal + 1 módulo de sinais de trading, então precisamos levar esse fato em consideração ao definir os valores de limiar. Por conta disso, ThresholdOpen e ThresholdClose devem ser definidos como 40=(0+80)/2 e 20=(0+40)/2. Os valores dos parâmetros de entrada Signal_StopLevel e Signal_TakeLevel estão definidos como 0, o que significa que o fechamento das posições será feito apenas quando as condições de fechamento forem verdadeiras. 2.4. Resultados de Backtesting Vamos considerar o backtesting do Expert Advisor em dados históricos (EURUSD H1, período de teste: 2010.01.01-2011.02.02, PeriodK=47, PeriodD=9, PeriodSlow=13, MA_period=5). Na criação do Expert Advisor, utilizamos o volume fixo (Trading Fixed Lot, 0.1), o algoritmo Trailing Stop não é utilizado (Trailing não utilizado). Fig. 11. Resultados do teste do Expert Advisor, baseado em 3 Corvos Negros/3 Soldados Brancos + Estocástico O melhor conjunto de parâmetros de entrada pode ser encontrado usando o Strategy Tester do terminal cliente MetaTrader 5. O código do Expert Advisor, criado pelo MQL5 Wizard, está anexado em expert_abc_ws_stoch.mq5.

2011.02.16
Demo_resource_EA: Expert Advisor para MetaTrader 5
MetaTrader5
Demo_resource_EA: Expert Advisor para MetaTrader 5

Esta é a versão do Demo_Create_OBJ_BITMAP_LABEL_EA, um Expert Advisor com recursos embutidos no arquivo .EX5. Os arquivos euro.bmp e dollar.bmp estão incluídos e utilizados como recursos: #resource "\Images\euro.bmp";    // euro.bmp está localizado em client_terminal_data_folder\MQL5\Images\ #resource "\Images\dollar.bmp"  // dollar.bmp está localizado em client_terminal_data_folder\MQL5\Images\ O objeto gráfico do tipo OBJ_BITMAP_LABEL permite criar botões com tamanhos e formas diferentes. O objeto do tipo OBJ_BITMAP_LABEL pode mudar seu estado ao ser clicado, mas a seleção do objeto deve estar desativada. Por padrão, a propriedade "Desativar seleção" está habilitada para todos os objetos gráficos criados em MQL5.

2011.02.15
Como Criar Botões com OBJ_BITMAP_LABEL no MetaTrader 5
MetaTrader5
Como Criar Botões com OBJ_BITMAP_LABEL no MetaTrader 5

Olá, traders! Hoje vamos falar sobre como utilizar o objeto gráfico OBJ_BITMAP_LABEL no MetaTrader 5 para criar botões personalizados. Esse recurso é super útil para quem deseja deixar suas estratégias de trading mais interativas e visuais. Vale lembrar que, por padrão, a propriedade "Desabilitar seleção" já vem ativada para todos os objetos gráficos criados em MQL5. Isso é importante para garantir que a interação com os botões funcione corretamente.

2011.02.11
eKeyboardTrader: O EA que Facilita Seu Trading no MetaTrader 5
MetaTrader5
eKeyboardTrader: O EA que Facilita Seu Trading no MetaTrader 5

O eKeyboardTrader é um Sistema de Trading que permite operar utilizando apenas o teclado. Ele suporta as operações de Compra, Venda e Fechar negócio, além de possibilitar a configuração de: Volume de Negócio (lotes), Stop Loss, Take Profit e Slippage. Após o lançamento do Sistema de Trading, ele exibirá os parâmetros atuais (Lote, StopLoss, TakeProfit, Slippage) e uma lista de comandos disponíveis (Fig. 1): b - comprar, s - vender, c - fechar, i - menu de parâmetros Figura 1. Menu principal No menu de parâmetros, os seguintes comandos (Fig. 2) estão disponíveis: l - Lote, k - StopLoss, j - TakeProfit, h - Slippage, i e Esc - voltar ao menu principal. Figura 2. Seleção de parâmetro de entrada Ao selecionar um parâmetro de entrada, o sistema entrará no modo de entrada (Fig. 3). No modo de entrada, os seguintes comandos estão disponíveis: i - aplicar; se o valor não for especificado, o resultado de "aplicar" será igual ao de Esc, Esc - cancelar (retornar ao menu principal), BackSpace - deletar o último caractere inserido. Figura 3. Valor do parâmetro de entrada

2011.02.02
Primeiro Anterior 56 57 58 59 60 61 62 63 64 Próximo Último