Como Integrar o Conceito de Smart Money (BOS) Junto com o Indicador RSI em um EA

Introdução

No mundo acelerado do comércio de câmbio, ter um sistema de negociação confiável e eficiente é crucial para o sucesso. O comércio em geral possui muitos termos, conceitos e estratégias. Muitas vezes, pode ser sobrecarregante, especialmente para os novos traders que ainda estão tentando encontrar seu caminho na indústria de negociações. O Smart Money Concept (SMC) é um dos conceitos em tendência no comércio de forex, mas pode ser difícil, às vezes, para novos traders ou para qualquer pessoa usar os conceitos de smart money em suas negociações.

Para resolver esse problema, deve haver uma ferramenta robusta para automatizar as decisões de negociação com base na estrutura do mercado e na ação do preço. A solução é acoplar o Smart Money Concept (Break Of Structure) com o popular indicador Relative Strength Index (RSI). Essa combinação fornece uma vantagem estratégica, aproveitando tanto a ação do preço quanto a análise de momentum, o que melhora a precisão das entradas e saídas de negociação, visando otimizar o desempenho das operações.

A ideia do exemplo de Expert Advisor

A ideia e a funcionalidade deste exemplo de Expert Advisor (EA) é que o expert detectará os pontos baixos e altos das oscilações, já que alguns conceitos de smart money utilizam as oscilações. O indicador RSI continuará usando a conversão tradicional do nível 70 para o mercado sobrecomprado e o nível 30 para o mercado sobrevendido, e o período será 8. Quando o preço do mercado estiver acima do alto detectado anteriormente, isso indicará uma quebra de estrutura para cima. Da mesma forma, quando o preço do mercado estiver abaixo do baixo detectado anteriormente, isso indicará uma quebra de estrutura para baixo.

Agora vamos desenvolver o exemplo de Expert Advisor

 O EA tem como objetivo abrir ordens de compra e venda com base nas condições do mercado e nos níveis do RSI. Especificamente, ele:

1. Identifica os altos e baixos das oscilações no mercado.
2. Verifica se o mercado está acima do alto anterior (para um sinal de venda) ou abaixo do baixo anterior (para um sinal de compra).
3. Em seguida, confirma o sinal com os níveis do RSI.

Dito isso, basicamente, o Expert Advisor procurará pela quebra de estrutura ou pela quebra das oscilações anteriores (alto/baixo) e, se o valor do RSI estiver dentro das configurações especificadas, uma ordem de mercado será executada (BUY/SELL).

Análise do Código

1. Propriedades e Includes

#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#include <Trade/Trade.mqh>

Essas linhas definem as propriedades do EA e incluem a biblioteca de negociação necessária para executar as ordens.

2. Variáveis Globais e Entradas

long MagicNumber = 76543;
double lotsize = 0.01;
input int RSIperiod = 8;
input int RSIlevels = 70;
int stopLoss = 200;
int takeProfit = 500;
bool closeSignal = false;

• MagicNumber: Um identificador único para as negociações do EA.
• Lotsize: O tamanho de cada negociação.
• RSIperiod: Período para os cálculos do RSI.
• RSIlevels: Níveis de limiar para o RSI.
• Stoploss e TakeProfit: Níveis de SL e TP em pontos.
• CloseSignal: Indicador para fechar posições com base no sinal oposto em comparação com a posição que está aberta atualmente.
  

3. Variáveis do RSI

int handle;
double buffer[];
MqlTick currentTick;
CTrade trade;
datetime openTimeBuy = 0;
datetime openTimeSell = 0;

• Handle: Handle para o indicador RSI.
  
• Buffer: Array para armazenar os valores do RSI.
• currentTick: Estrutura para armazenar os preços atuais do mercado.
• Trade: Este é o objeto para operações de negociação.
• openTimeBuy e openTimeSell: Os timestamps para os últimos sinais e operações de compra e venda.

4. Função de Inicialização

int OnInit() {
    if (RSIperiod <= 1) {
        Alert("RSI period <= 1");
        return INIT_PARAMETERS_INCORRECT;
    }
    if (RSIlevels >= 100 || RSIlevels <= 50) {
        Alert("RSI level >= 100 or <= 50");
        return INIT_PARAMETERS_INCORRECT;
    }
    trade.SetExpertMagicNumber(MagicNumber);
    handle = iRSI(_Symbol, PERIOD_CURRENT, RSIperiod, PRICE_CLOSE);
    if (handle == INVALID_HANDLE) {
        Alert("Failed to create indicator handle");
        return INIT_FAILED;
    }
    ArraySetAsSeries(buffer, true);
    return INIT_SUCCEEDED;
}

• Valida o período e os níveis do RSI.
• Define o número mágico para a identificação das negociações.
• Cria um handle para o indicador RSI.
• Define o buffer como uma série para armazenar os valores do RSI em ordem cronológica reversa.
  

5. Função de Desinicialização

void OnDeinit(const int reason) {
    if (handle != INVALID_HANDLE) {
        IndicatorRelease(handle);
    }
}

Libera o handle do indicador RSI quando o EA é removido.

6. Função OnTick

Como todos sabem, a função OnTick contém a lógica principal para detectar sinais e executar negociações.

void OnTick() {
    static bool isNewBar = false;
    int newbar = iBars(_Symbol, _Period);
    static int prevBars = newbar;
    if (prevBars == newbar) {
        isNewBar = false;
    } else if (prevBars != newbar) {
        isNewBar = true;
        prevBars = newbar;
    }

Primeiramente, como a função OnTick é executada a cada tick, precisamos garantir que, ao detectar um sinal ou executar uma negociação, ela seja executada uma vez por barra. Conseguimos isso declarando uma variável booleana estática isNewBar Que inicialmente é definida como falsa, e depois declaramos uma variável int newBar que recebe a função iBars para que possamos acompanhar cada barra de vela.

• static bool isNewBar: Controla se uma nova barra (candlestick) foi formada.
• int newbar = iBars(_Symbol, _Period): Obtém o número atual de barras no gráfico.
• static int prevBars = newbar: Inicializa a contagem da barra anterior.
• O bloco if-else verifica se o número de barras foi alterado, indicando que uma nova barra foi formada. Se uma nova barra foi formada, 'isNewBar' é definido como 'true', caso contrário, é 'false'.

    const int length = 10;
    int right_index, left_index;
    int curr_bar = length;
    bool isSwingHigh = true, isSwingLow = true;
    static double swing_H = -1.0, swing_L = -1.0;

Em seguida, precisamos definir as variáveis para detectar os altos e baixos das oscilações:

• const int length = 10: Define o intervalo para detectar os altos e baixos das oscilações.
• int right_index, left_index: Índices para as barras à direita e à esquerda da barra atual.
• int curr_bar = length: Define o índice da barra atual.
• bool isSwingHigh = true, isSwingLow = true: São indicadores para determinar se uma barra é um alto ou baixo de oscilação.
• static double swing_H = -1.0, swing_L = -1.0: Armazena os últimos valores detectados de alto e baixo de oscilação.

    double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol, SYMBOL_ASK), _Digits);
    double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol, SYMBOL_BID), _Digits);

As variáveis são do tipo double e a variável 'Ask' é usada para obter o preço atual de ASK do mercado, e a variável 'Bid' é usada para obter o preço atual de BID do mercado:

• double Ask: Obtém o preço atual de ask.
• double Bid: Obtém o preço atual de bid.
• NormalizeDouble: Arredonda o preço para o número correto de casas decimais.

    if (isNewBar) {
        for (int a = 1; a <= length; a++) {
            right_index = curr_bar - a;
            left_index = curr_bar + a;

            if ((high(curr_bar) <= high(right_index)) || (high(curr_bar) < high(left_index))) {
                isSwingHigh = false;
            }
            if ((low(curr_bar) >= low(right_index)) || (low(curr_bar) > low(left_index))) {
                isSwingLow = false;
            }
        }

        if (isSwingHigh) {
            swing_H = high(curr_bar);
            Print("We do have a swing high at: ", curr_bar, " H: ", high(curr_bar));
            drawswing(TimeToString(time(curr_bar)), time(curr_bar), high(curr_bar), 32, clrBlue, -1);
        }
        if (isSwingLow) {
            swing_L = low(curr_bar);
            Print("We do have a swing low at: ", curr_bar, " L: ", low(curr_bar));
            drawswing(TimeToString(time(curr_bar)), time(curr_bar), low(curr_bar), 32, clrRed, +1);
        }
    }

Em seguida, procedemos para procurar os altos e baixos das oscilações, mas antes disso, se uma nova barra for detectada, a função verifica as barras ao redor dentro do intervalo definido 'length' para identificar se existem altos ou baixos de oscilação. A variável length define um intervalo de velas para procurar por oscilações, e para cada barra dentro do intervalo, a função compara o alto/baixo da barra atual com as barras adjacentes.

Se o alto da barra atual não for maior do que as barras ao redor, então não é um alto de oscilação. Se o baixo da barra atual não for menor do que as barras ao redor, então não é um baixo de oscilação. Dado que todas essas condições são atendidas, um alto ou baixo de oscilação é confirmado, o respectivo valor é armazenado, e então um marcador é desenhado no gráfico usando a função 'drawswing'.

    int values = CopyBuffer(handle, 0, 0, 2, buffer);
    if (values != 2) {
        Print("Failed to get indicator values");
        return;
    }

    Comment("Buffer[0]: ", buffer[0],
            "\nBuffer[1]: ", buffer[1]);

• copyBuffer(handle, 0, 0, 2, buffer): Copia os últimos valores do RSI para o buffer.
• Se a função falhar ao recuperar os valores do RSI, ela sai.
• Os valores do RSI serão exibidos como um comentário no gráfico.

    int cntBuy = 0, cntSell = 0;
    if (!countOpenPositions(cntBuy, cntSell)) {
        return;
    }

'countOpenPositions(cntBuy, cntSell)': Essa função conta o número de posições de compra e venda abertas, se a função falhar, 'OnTick' sai.

    if (swing_H > 0 && Ask > swing_H && buffer[0] >= 70) {
        Print("Sell Signal: Market is above previous high and RSI >= 70");
        int swing_H_index = 0;
        for (int i = 0; i <= length * 2 + 1000; i++) {
            if (high(i) == swing_H) {
                swing_H_index = i;
                break;
            }
        }
        drawBreakLevels(TimeToString(time(0)), time(swing_H_index), high(swing_H_index), time(0), high(swing_H_index), clrBlue, -1);

        if (cntSell == 0) {
            double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol, SYMBOL_BID), _Digits);
            double sl = Bid + stopLoss * _Point;
            double tp = Bid - takeProfit * _Point;
            trade.PositionOpen(_Symbol, ORDER_TYPE_SELL, lotsize, currentTick.bid, sl, tp, "RSI EA");
        }

        swing_H = -1.0;
        return;
    }

Como expliquei anteriormente, vamos verificar um sinal de venda. A lógica é que o preço de ask deve estar acima do alto de oscilação anterior. Além disso, o valor do RSI deve ser maior ou igual ao nível 70. Se as condições forem atendidas, ele marca o alto de oscilação e desenha um nível de quebra no gráfico. Se não houver posições de venda abertas, ele procede para abrir uma posição de venda. Essa negociação será aberta com o nível calculado de stop loss e take profit, e então o valor do alto de oscilação será redefinido.

    if (swing_L > 0 && Bid < swing_L && buffer[0] <= 30) {
        Print("Buy Signal: Market is below previous low and RSI <= 30");
        int swing_L_index = 0;
        for (int i = 0; i <= length * 2 + 1000; i++) {
            if (low(i) == swing_L) {
                swing_L_index = i;
                break;
            }
        }
        drawBreakLevels(TimeToString(time(0)), time(swing_L_index), low(swing_L_index), time(0), low(swing_L_index), clrRed, +1);

        if (cntBuy == 0) {
            double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol, SYMBOL_ASK), _Digits);
            double sl = Ask - stopLoss * _Point;
            double tp = Ask + takeProfit * _Point;
            trade.PositionOpen(_Symbol, ORDER_TYPE_BUY, lotsize, currentTick.ask, sl, tp, "RSI EA");
        }

        swing_L = -1.0;
        return;
    }
}

Para o sinal de compra, aplica-se a lógica oposta: Se o preço de bid estiver abaixo do baixo de oscilação anterior, e o valor do RSI for menor ou igual ao nível 30, então tecnicamente a lógica de compra está em ordem e a condição é atendida. Quando a condição é atendida, marca o baixo de oscilação e desenha um nível de quebra no gráfico. E se não houver posições de compra abertas, ele prossegue para abrir uma nova negociação de compra com os níveis calculados de stop loss e take profit, e por último, redefine o valor do baixo de oscilação.

O que estamos tentando realizar é o seguinte:

_ Uma negociação de venda com todas as condições atendidas:

_ Uma negociação de compra com todas as condições atendidas:

Resumo da função OnTick:

O Expert realiza as seguintes ações principais em cada tick do mercado

1. Detecta Novas Barras: Primeiro verifica se temos uma nova barra de vela que pode ter se formado desde o último tick, e também mantém o controle de todas as velas.
2. Identifica Altos e Baixos de Oscilação: Em seguida, identifica os pontos de oscilação no mercado para usar como níveis de referência posteriormente, quando o preço de mercado estiver acima do alto de oscilação ou o mercado estiver abaixo do baixo de oscilação.
3. Recupera Valores do RSI: Obtém os últimos valores do RSI para confirmação do sinal.
4. Conta Posições Abertas: Mantém o controle das posições de compra e venda abertas atualmente.
5. Gera Sinais de Negociação: Usa os pontos de oscilação, que são o alto de oscilação e o baixo de oscilação, e os níveis do RSI para gerar sinais de compra ou venda.
6. Executa Negociações: Abre novas posições com base nos sinais gerados, se todas as condições forem atendidas.

Funções Personalizadas para Valores de Alto, Baixo e Tempo

double high(int index){
       return (iHigh(_Symbol, _Period, index));
}

double low(int index){
       return (iLow(_Symbol, _Period, index));
}

datetime time(int index){
       return (iTime(_Symbol, _Period, index));
}

A função high (int index) retorna o preço alto da barra no índice especificado index. Ela recebe index como parâmetro do tipo 'int'. A função embutida em MQL5 iHigh(_symbol,_Period,index) é usada para obter o preço alto da barra no index para o símbolo e período atuais. Em seguida, temos a função low (int index), que retorna o preço baixo da barra no índice especificado index, e também recebe index como parâmetro, que é do tipo int, e depois temos <i>iLow(_symbol, _Period, index)</i>. É também uma função embutida em MQL5, que obtém o preço baixo para a barra no index para o símbolo atual. Finalmente, temos a função time (int index), que retorna o tempo da barra no índice especificado. iTime(_symbol, _Period, index) também é uma função embutida em MQL5 para obter o tempo da barra no index para o símbolo e período atuais. O tipo de dados de iTime é do tipo datetime.

Função para Desenhar os Pontos de Oscilação

void drawswing(string objName, datetime time, double price, int arrCode, color clr, int direction){
   if(ObjectFind(0, objName) < 0){
      ObjectCreate(0, objName, OBJ_ARROW, 0, time, price);
      ObjectSetInteger(0, objName, OBJPROP_ARROWCODE, arrCode);
      ObjectSetInteger(0, objName, OBJPROP_COLOR, clr);
      ObjectSetInteger(0, objName, OBJPROP_FONTSIZE, 10);
      
      if(direction > 0){ObjectSetInteger(0, objName, OBJPROP_ANCHOR, ANCHOR_TOP);}
      if(direction < 0){ObjectSetInteger(0, objName, OBJPROP_ANCHOR, ANCHOR_BOTTOM);}
      
      string text = "";
      string Descr = objName + text;
      ObjectCreate(0, Descr, OBJ_TEXT, 0, time, price);
      ObjectSetInteger(0, Descr, OBJPROP_COLOR, clr);
      ObjectSetInteger(0, Descr, OBJPROP_FONTSIZE, 10);
      
      if(direction > 0){
         ObjectSetString(0, Descr, OBJPROP_TEXT,"  "+text);
         ObjectSetInteger(0, Descr, OBJPROP_ANCHOR, ANCHOR_LEFT_UPPER);
      }
      if(direction < 0){
         ObjectSetString(0, Descr, OBJPROP_TEXT,"  "+text);
         ObjectSetInteger(0, Descr, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);
      }
   }
   ChartRedraw(0);
}

Esta função cria marcadores visuais para os pontos de oscilação (altos e baixos) no gráfico. Ela recebe os seguintes parâmetros:

• ObjName: É o nome do objeto a ser criado.
• Time: O momento em que a oscilação ocorreu ou foi detectada.
• Price: O preço no qual a oscilação se formou.
• ArrCode: Código da seta para a representação visual.
• Clr: Cor para a seta.
• Direction: Direção da oscilação (positiva para alto, negativa para baixo).

Funcionalidade:

1. Criação do Objeto:

• ObjectFind(0, objName) < 0: Verifica se já existe um objeto com o nome fornecido.
• ObjectCreate(0, objName, OBJ-ARROW, 0, time, price): Cria um objeto de seta no tempo e preço especificados.
• ObjectSetInteger(0, objName, OBJPROP-ARROWCODE, arrCode): Define o código da seta.
• ObjectSetInteger(0, objName, OBJPROP-COLOR, clr): Define a cor da seta.
• ObjectSetInteger(0, objName, OBJPROP-FONTSIZE, 10): Define o tamanho da fonte.

2. Manipulação de Direção:

• Define a posição de ancoragem com base na direção.
• OBJPROP-ANCHOR: Define a posição do ponto de ancoragem para a seta.

3. Criação do Objeto de Texto:

• Cria um objeto de texto associado à seta para exibir informações adicionais.
• Define a cor, tamanho da fonte e ponto de ancoragem para o texto com base na direção.

4. Atualização do Gráfico:

• ChartRedraw(0): Redesenha o gráfico para refletir as mudanças.
  

Função para Desenhar os Níveis de Quebra

void drawBreakLevels(string objName, datetime time1, double price1, datetime time2, double price2, color clr, int direction){
   if(ObjectFind(0, objName) < 0){
         ObjectCreate(0, objName, OBJ_ARROWED_LINE, 0, time1, price1, time2, price2);
         ObjectSetInteger(0, objName, OBJPROP_TIME, 0, time1);
         ObjectSetDouble(0, objName, OBJPROP_PRICE, 0, price1);
         ObjectSetInteger(0, objName, OBJPROP_TIME, 1, time2);
         ObjectSetDouble(0, objName, OBJPROP_PRICE, 1, price2);
         ObjectSetInteger(0, objName, OBJPROP_COLOR, clr);
         ObjectSetInteger(0, objName, OBJPROP_WIDTH, 2);
         
         string text = "Break";
         string Descr = objName + text;
         ObjectCreate(0, Descr, OBJ_TEXT, 0, time2, price2);
         ObjectSetInteger(0, Descr, OBJPROP_COLOR, clr);
         ObjectSetInteger(0, Descr, OBJPROP_FONTSIZE, 10);  
         
         if(direction > 0){
            ObjectSetString(0, Descr, OBJPROP_TEXT,text+"  ");
            ObjectSetInteger(0, Descr, OBJPROP_ANCHOR, ANCHOR_RIGHT_UPPER);
         }
         if(direction < 0){
            ObjectSetString(0, Descr, OBJPROP_TEXT,text+"  ");
            ObjectSetInteger(0, Descr, OBJPROP_ANCHOR, ANCHOR_RIGHT_LOWER);
         }          
   }
   ChartRedraw(0);
}

Esta função cria representações visuais para a quebra dos níveis de preço, que são os pontos de oscilação que foram previamente detectados no gráfico. Ela tem os seguintes parâmetros:

• ObjName: É o nome do objeto a ser criado.
• time1, time2: O tempo de início é o momento em que a oscilação se formou, e o tempo de término é o momento em que ocorre a quebra.
• price1, price2: O preço inicial é o preço no qual o alto ou baixo de oscilação ocorreu, e price2 é o preço no qual ocorre a quebra do alto ou baixo de oscilação.
• Clr: Cor para a seta.
• Direction: Direção para ancorar o texto.

Funcionalidade:

1. Criação do Objeto:

• ObjectFind(0, objName) < 0: Verifica se um objeto com o nome fornecido já existe.
• ObjectCreate(0, objName, OBJ_ARROWED_LINE, 0, time1, price1, time2, price2): Cria o objeto da seta nas horas e preços especificados.
• Define os tempos e preços para os pontos de início e fim da linha de seta.
• ObjectSetInteger(0, objName, OBJPROP-COLOR, clr): Define a cor da linha.
• ObjectSetInteger(0, objName, OBJPROP-WIDTH, 2): Define a largura da linha.

2. Criação do Objeto de Texto:

• Cria um objeto de texto associado à linha para exibir informações adicionais.
• Define a cor, tamanho da fonte e ponto de ancoragem para o texto com base na direção.

3. Atualização do Gráfico:

• ChartRedraw<b1><i2>(0)</i2></b1>: Redesenha o gráfico para refletir as mudanças.

Conclusão

Em resumo, as funções personalizadas melhoram a experiência de negociação, pois proporcionam acesso conveniente aos valores de alto, baixo e tempo das barras. Ao acoplar o indicador RSI com os conceitos do SMC, podemos visualizar os indicadores e confirmar que o EA segue as instruções. Quando a função desenha a linha de seta no gráfico, ela marca pontos significativos, que são os pontos de oscilação (Altos e Baixos). Além disso, podemos observar os níveis de quebra. Também temos a atualização dinâmica, que garante que o gráfico esteja sempre atualizado em tempo real com os últimos marcadores e indicadores, auxiliando na análise visual e na tomada de decisões.

Através deste guia abrangente, foi fornecido um entendimento completo de como integrar o conceito SMC com o indicador RSI na estrutura e funcionalidade de qualquer Expert Advisor. Seguindo a explicação passo a passo, os leitores agora devem ter uma compreensão clara de como o Expert Advisor SMC_RSI opera, desde a inicialização das variáveis até a execução de negociações com base nos sinais calculados. Seja você um trader experiente ou iniciante, este conhecimento abrangente deve equipá-lo com o conhecimento necessário para utilizar e personalizar essas ferramentas poderosas de forma eficaz em suas atividades de negociação.

Aqui estão os resultados do backtest abaixo. Posso dizer que o EA ainda precisa de algum tipo de otimização para obter um fator de lucro mais alto. Agora, abaixo estão os resultados do backtest:

E abaixo, podemos ver a representação visual da curva de equidade. Eu só testei por 12 meses, então quem pode dizer com precisão como ele se comportaria se fosse testado por um período de 12 anos.

Referências

Artigo original: https://www.mql5.com/en/articles