Como trabalhar com linhas usando MQL5

Introdução

Ao negociar, as linhas ajudam a observar níveis importantes que são usados para tomar/confirmar decisões de negociação e para realizar análises em geral. Como esses níveis são tão importantes para os traders, surge a questão de saber se existe uma maneira de traçar linhas automaticamente e tomar decisões com base nelas automaticamente, o que tornaria o uso as linhas ainda mais conveniente. A resposta é sim. E isso pode ser feito usando a linguagem de programação MQL5 (MetaQuotes Language 5).

Neste artigo, veremos exemplos de como você pode trabalhar com linhas usando MQL5. Existem muitos métodos diferentes para fazer isso, e a escolha de um específico depende do que você deseja alcançar. Existe uma variedade enorme de tipos de linhas, mas neste artigo vamos trabalhar apenas com três das mais populares: linhas de tendência, linhas de suporte e linhas de resistência.

Neste artigo, abordaremos os seguintes tópicos:

1. Linhas de tendência e MQL5
2. Linhas de suporte e MQL5
3. Linhas de resistência e MQL5
4. Considerações finais

Estritamente falando, existem muitos métodos para trabalhar com linhas por meio das ferramentas MQL5. Aqui vamos considerar apenas um método simples. Você provavelmente precisará trabalhar um pouco mais com ele para aplicá-lo à sua estratégia específica. Primeiro, consideraremos o método de determinação de níveis de preço e, em seguida, aprenderemos como traçar o tipo de linha selecionado no gráfico.

Neste artigo, vamos explorar as linhas de tendência, suporte e resistência e como trabalhar com elas na negociação. Aprenderemos a identificar diferentes tipos de linhas, como desenhá-las manualmente e usar a linguagem MQL5 para automatizar processos e melhorar resultados. Utilizaremos a linguagem MQL5 (MetaQuotes Language 5) do terminal MetaTrader 5, juntamente com o MetaEditor para escrever código. Já conhece como instalar o MetaTrader 5 ou usar o MetaEditor? Caso contrário, consulte a seção "Como escrever código MQL5 no MetaEditor" de um artigo anterior.

Recomendo que os leitores pratiquem escrever os códigos sobre os quais falaremos neste artigo. Dessa forma, desenvolverão suas habilidades de programação, entenderão melhor o assunto e, quem sabe, poderão encontrar novas ideias para si mesmos e melhorar seus resultados de negociação.

Atenção! Todo o conteúdo deste artigo é apresentado "tal qual como está", apenas para fins educacionais e não constitui uma recomendação de trading. O artigo não envolve nenhuma garantia de resultados. Tudo o que você colocar em prática com base neste artigo, você faz exclusivamente por sua conta e risco, o autor não garante nenhum resultado.

Linhas de tendência e MQL5

As linhas são ferramentas de análise técnica usadas na negociação nos mercados financeiros. Linhas podem ser traçadas com base em preços ou níveis importantes, que, por sua vez, podem ser usados como gatilhos para a tomada de decisões oportunas. Existem muitos tipos de linhas. Vamos começar com os três tipos principais: linhas de tendência, linhas de suporte e linhas de resistência.

Linhas de tendência: o que são e como utilizá-las? As linhas de tendência são representações gráficas da direção dos preços, sejam eles subindo ou descendo. Elas podem ser desenhadas acima ou abaixo dos preços, dependendo da direção do mercado. O objetivo principal é identificar a direção da tendência de preços. Uma linha de tendência ascendente é indicada por uma série de mínimos e máximos crescentes, enquanto uma tendência de baixa é representada por pelo menos três mínimos e máximos decrescentes. Quando usada corretamente, a linha de tendência pode ser uma poderosa ferramenta para análise de mercado.

As linhas de tendência são uma ferramenta útil na negociação para colocar ordens na direção da tendência. Se uma linha de tendência ascendente estiver formada, é provável que o preço teste essa linha por cima antes de subir, permitindo colocar uma ordem de compra nesse ponto. Por outro lado, em caso de uma linha de tendência descendente, o preço pode subir para testar essa linha antes de cair, possibilitando uma ordem de venda na linha de tendência de baixa.

Abaixo está uma linha de tendência de alta:

A figura acima mostra um movimento ascendente. Se você conectar os três pontos mínimos com uma linha, descobrirá que eles estão em uma mesma linha que aponta para cima.

Abaixo está um exemplo de uma linha de tendência ascendente:

Como se pode ver no gráfico anterior, uma linha de tendência ascendente se formou, com o preço se aproximando e se afastando dela várias vezes, impulsionado pela força dos compradores, o que confirma a existência de uma tendência de alta.

Abaixo está uma linha de tendência descendente:

A figura mostra um claro movimento descendente. Se você conectar os três pontos máximos com uma linha, descobrirá que eles estão em uma mesma linha que aponta para baixo.

Abaixo está um exemplo de uma linha de tendência de baixa:

Como você pode ver no gráfico anterior, uma linha de tendência descendente se formou, o preço se afastou dessa linha várias vezes, impulsionado pelos vendedores, o que confirma a existência de uma tendência descendente.

1. Sistema de linha de tendência ascendente

Agora vamos criar um programa que para criar automaticamente uma linha de tendência de alta no MetaTrader 5. Ele será exibido abaixo dos preços, permitindo que você veja o possível movimento ascendente. O programa verificará as mínimas do preço em cada tick e determinará se uma tendência de alta se formou. Também excluiremos a linha anterio, se existir, e criaremos uma nova linha azul abaixo do preço. 

Vamos dar uma olhada nas etapas para fazer isso.

Para definir a primeira vela, vamos criar uma variável inteira do tipo long da propriedade correspondente do gráfico atual, para isso utilizamos a função ChartGetInteger com os seguintes parâmetros:

• chart_id — identificador do gráfico, 0 significa o gráfico atual.
• prop_id — determinamos o identificador da propriedade do gráfico, usamos os valores da enumeração ENUM_CHART_PROPERTY_INTEGER. Para nós, este será o valor CHART_FIRST_VISIBLE_BAR.
• sub_window=0 — número da subjanela do gráfico. Usamos o valor 0, que corresponde à janela principal do gráfico.

int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);

Criamos um array com valores mínimos de preço, obtemos variáveis do tipo double para pLow.

double pLow[];

Classificamos o array de dados atuais criado usando a função ArraySetAsSeries que retorna um valor booleano (true se for bem-sucedido ou false caso contrário.

ArraySetAsSeries(pLow,true);

Preenchemos o array pLow criado com dados usando a função CopyLow, que é o valor do mínimo do símbolo atual no timeframe atual. Parâmetros de função:

• symbol_name — nome do símbolo, _Symbol significa o símbolo do gráfico atual.
• timeframe — período gráfico para cálculo, _Period significa o período gráfico atual.
• start_pos — posição inicial para copiar elementos, para nós será 0.
  
• count — número de elementos a serem copiados, usamos a variável candles criada anteriormente.
  
• low_array[] — array alvo para copiar elementos, pLow.
  

CopyLow(_Symbol,_Period,0,candles,pLow);

Criamos e calculamos o valor mínimo da vela. Para isso, criamos uma variável candleLow do tipo inteiro igual ao elemento mínimo no array. Para retornar o valor mínimo, usamos a função ArrayMinimum. Parâmetros de função:

• array[] — array no qual analisamos os elementos, pLow.
  
• start=0 — índice do elemento a partir do qual a verificação começa, usamos 0.
  
• count=WHOLE_ARRAY— número de elementos a serem verificados, no nosso caso é igual a candles.
  

int candleLow = ArrayMinimum(pLow,0,candles);

Com a função MqlRates, criamos um array pArray, para armazenar informações sobre preços, volumes e spreads.

MqlRates pArray[];

Classificamos o array de preços pArray usando a função ArraySetAsSeries.

ArraySetAsSeries(pArray,true);

Copiamos os dados dos preços para o array de preços depois de criarmos a variável inteira Data e, em seguida, usamos CopyRates para obter os dados históricos da estrutura MqlRates. Parâmetros da função:

• symbol_name — nome do símbolo, usamos _Symbol para trabalhar com o símbolo do gráfico atual.
• timeframe — define o timeframe, _Period significa o timeframe atual.
• start_pos — defina a posição do início do cálculo, especificamos 0.
• count — número de elementos a serem copiados, usamos a variável candles criada anteriormente.
  
• rates_array[] — array onde copiamos os dados; pArray é o array de preços.
  

int Data = CopyRates(_Symbol,_Period,0,candles,pArray);

Excluímos a linha criada anteriormente para atualizá-la. Para fazer isso, usamos a função ObjectDelete, que remove qualquer objeto especificado de qualquer gráfico especificado. Parâmetros da função:

• chart_id — ID do gráfico, _Symbol — gráfico do símbolo atual.
• name — nome do objeto a ser removido do gráfico. No nosso caso, é a UpwardTrendline (linha de tendência ascendente).

ObjectDelete(_Symbol,"UpwardTrendline");

Criamos uma nova linha de tendência usando ObjectCreate para gerar um objeto de linha de tendência. Parâmetros da função:

• chart_id — gráfico do símbolo no qual o objeto será construído, _Symbol — gráfico do símbolo atual.
• name — nome do objeto, especificaremos "UpwardTrendline" como o nome.
• type — tipo de objeto, OBJ_TREND é a linha de tendência.
• nwin — índice da janela, 0 é a janela principal do gráfico.
• time1 — tempo do primeiro ponto de ancoragem, pArray[candleLow].time.
• price1 — preço do primeiro ponto de ancoragem, pArray[candleLow].low.
• timeN — tempo do enésimo ponto de ancoragem, pArray[0].time.
• priceN — preço do enésimo ponto de ancoragem, pArray[0].low.

ObjectCreate(_Symbol,"UpwardTrendline",OBJ_TREND,0,pArray[candleLow].time,pArray[candleLow].low,pArray[0].time,pArray[0].low);

Vamos definir a cor da linha de tendência usando a função ObjectSetInteger com o valor da cor do objeto. Parâmetros da função:

• chart_id — identificador do gráfico, usamos 0, que é o gráfico atual.
• name — nome do objeto, UpwardTrendline é um nome predefinido para nossa linha de tendência.
• prop_id — identificador de propriedade do objeto, usamos o valor OBJPROP_COLOR a partir da enumeração ENUM_OBJECT_PROPERTY_INTEGER.
• prop_value — valor da propriedade, no nosso caso, Blue é a cor da nossa linha de tendência.

ObjectSetInteger(0,"UpwardTrendline",OBJPROP_COLOR,Blue);

Definimos o estilo da linha, usamos a função ObjectSetInteger novamente, mas desta vez com outro valor para ENUM_OBJECT_PROPERTY_INTEGER, este é OBJPROP_STYLE, prop_value = STYLE_SOLID é uma linha sólida como o estilo da linha de tendência a ser criada.

ObjectSetInteger(0,"UpwardTrendline",OBJPROP_STYLE,STYLE_SOLID);

Vamos definir a espessura da linha. Usamos a função ObjectSetInteger com o valor OBJPROP_WIDTH a partir da enumeração ENUM_OBJECT_PROPERTY_INTEGER, o valor da variável é 3. que corresponde à espessura real da linha de tendência que está sendo criada.

ObjectSetInteger(0,"UpwardTrendline",OBJPROP_WIDTH,3);

Vamos fazer a linha continuar para a direita. Usamos a função ObjectSetInteger com o valor OBJPROP_RAY_RIGHT a partir da enumeração ENUM_OBJECT_PROPERTY_INTEGER, o valor da variável é true, ou seja, continuamos a linha para a direita.

ObjectSetInteger(0,"UpwardTrendline",OBJPROP_RAY_RIGHT,true);

E o seguinte é o código completo para para criar uma linha de tendência ascendente automaticamente:

//+------------------------------------------------------------------+
//|                                       UpwardTrendline System.mq5 |
//+------------------------------------------------------------------+
void OnTick()
  {
   int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);
   double pLow[];
   ArraySetAsSeries(pLow,true);
   CopyLow(_Symbol,_Period,0,candles,pLow);
   int candleLow = ArrayMinimum(pLow,0,candles);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int Data = CopyRates(_Symbol,_Period,0,candles,pArray);
   ObjectDelete(_Symbol,"UpwardTrendline");
   ObjectCreate(_Symbol,"UpwardTrendline",OBJ_TREND,0,pArray[candleLow].time,pArray[candleLow].low,pArray[0].time,pArray[0].low);
   ObjectSetInteger(0,"UpwardTrendline",OBJPROP_COLOR,Blue);
   ObjectSetInteger(0,"UpwardTrendline",OBJPROP_STYLE,STYLE_SOLID);
   ObjectSetInteger(0,"UpwardTrendline",OBJPROP_WIDTH,3);
   ObjectSetInteger(0,"UpwardTrendline",OBJPROP_RAY_RIGHT,true);
  }
//+------------------------------------------------------------------+

Uma vez escrito o código, ele precisa ser compilado. Não deve haver erros durante a compilação. Depois disso, o programa compilado deve aparecer no navegador do terminal de negociação:

Iniciamos o programa clicando duas vezes no arquivo ou arrastando-o para o gráfico. Depois disso, a janela do EA aparecerá:

Habilitamos a negociação automática "Allow Algo Trading" e clicamos em OK. Após isso, o programa rodará no gráfico e imediatamente começará a funcionar, conforme exemplo abaixo:

A indicação no canto superior direito do gráfico significa que o Expert Advisor está trabalhando neste gráfico. Além disso, a EA traçou uma linha de tendência de alta azul sob o preço.

2. Sistema de linha de tendência descendente

Agora vamos criar um programa que pode ser usado para criar automaticamente uma linha de tendência de baixa no MetaTrader 5. Ele será exibido no gráfico acima dos preços, permitindo que você veja o possível movimento descendente. O programa verificará as máximas de preço em cada tick e determinará se uma tendência de baixa se formou. Em seguida, ele excluirá a linha antiga, se houver, e criará uma nova linha azul acima dos máximos do preço. 

O código completo do programa que implementa essa funcionalidade é mostrado a seguir.

//+------------------------------------------------------------------+
//|                                     DownwardTrendline System.mq5 |
//+------------------------------------------------------------------+
void OnTick()
  {
   int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);
   double pHigh[];
   ArraySetAsSeries(pHigh,true);
   CopyHigh(_Symbol,_Period,0,candles,pHigh);
   int candleHigh = ArrayMaximum(pHigh,0,candles);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int Data = CopyRates(_Symbol,_Period,0,candles,pArray);
   ObjectDelete(_Symbol,"DnwardTrendline");
   ObjectCreate(_Symbol,"DnwardTrendline",OBJ_TREND,0,pArray[candleHigh].time,pArray[candleHigh].high,pArray[0].time,pArray[0].high);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_COLOR,Blue);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_STYLE,STYLE_SOLID);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_WIDTH,3);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_RAY_RIGHT,true);
  }
//+------------------------------------------------------------------+

Diferenças neste código:

Criamos um array com máximas de preços.

double pHigh[];

Classificamos os dados começando com os atuais.

ArraySetAsSeries(pHigh,true);

Preenchemos o array com dados.

CopyHigh(_Symbol,_Period,0,candles,pHigh);

Criamos uma variável candle e calculamos o valor máximo.

int candleHigh = ArrayMaximum(pHigh,0,candles);

Excluímos a linha de tendência de baixa criada anteriormente

ObjectDelete(_Symbol,"DnwardTrendline");

Criamos uma nova linha de tendência

ObjectCreate(_Symbol,"DnwardTrendline",OBJ_TREND,0,pArray[candleHigh].time,pArray[candleHigh].high,pArray[0].time,pArray[0].high);

Definimos a cor da linha de tendência de baixa como azul, para isso usamos a propriedade OBJPROP_COLOR

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_COLOR,Blue);

Para o estilo de linha, selecionamos uma linha sólida definindo a propriedade OBJPROP_STYLE como STYLE_SOLID

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_STYLE,STYLE_SOLID);

Definimos a espessura da linha de tendência de baixa como 3, para isso usamos a propriedade WIDTH

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_WIDTH,3);

Definimos a propriedade do raio OBJPROP_RAY_RIGHT como true

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_RAY_RIGHT,true);

Após a compilação bem-sucedida, localizamos o arquivo do EA na janela do navegador. Rodamos o EA e ele começará a criar imediatamente no gráfico uma linha de tendência descendente:

O ícone do EA é exibido no canto superior direito do gráfico e uma linha de tendência descendente azul é exibida acima dos preços.

Níveis de suporte e MQL5

O nível de suporte é um nível de preço ou área que está abaixo dos preços atuais. Os preços sobem a partir deste nível porque o poder de compra é formado aqui. Portanto, eles são muito importantes, pois podemos usá-los como níveis para entrar em uma negociação de compra. Existem muitas formas de níveis de suporte, uma delas é o nível de suporte horizontal. Ele se parece com isso:

Exemplo do nível de suporte no mercado:

O gráfico acima mostra uma linha de suporte verde abaixo dos preços, e é a partir dela que os preços sobem.

Nosso programa verificará automaticamente as mínimos de preços em cada tick e determinará se há suporte. Uma vez removida a linha antiga, construiremos uma nova linha de suporte verde abaixo dos preços. O código completo do programa que desenha tal linha no modo automático é mostrado abaixo:

//+------------------------------------------------------------------+
//|                                          Support Line System.mq5 |
//+------------------------------------------------------------------+
void OnTick()
  {
   int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);
   double pLow[];
   ArraySetAsSeries(pLow,true);
   CopyLow(_Symbol,_Period,0,candles,pLow);
   int candleLow = ArrayMinimum(pLow,0,candles);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int Data = CopyRates(_Symbol,_Period,0,candles,pArray);
   ObjectDelete(_Symbol,"supportLine");
   ObjectCreate(_Symbol,"supportLine",OBJ_HLINE,0,pArray[candleLow].time,pArray[candleLow].low,pArray[0].time,pArray[0].low);
   ObjectSetInteger(0,"supportLine",OBJPROP_COLOR,Green);
   ObjectSetInteger(0,"supportLine",OBJPROP_STYLE,STYLE_SOLID);
   ObjectSetInteger(0,"supportLine",OBJPROP_WIDTH,3);
   ObjectSetInteger(0,"supportLine",OBJPROP_RAY,true);
  }
//+------------------------------------------------------------------+

Diferenças neste código:

Se um objeto chamado supportLine for encontrado no gráfico

ObjectDelete(_Symbol,"supportLine");

Criamos uma nova linha de suporte especificando OBJ_HLINE como o tipo do objeto que está sendo criado

ObjectCreate(_Symbol,"supportLine",OBJ_HLINE,0,pArray[candleLow].time,pArray[candleLow].low, pArray[0].time,pArray[0].low);

Definimos a cor da linha de suporte usando OBJPROP_COLOR

ObjectSetInteger(0,"supportLine",OBJPROP_COLOR,Green);

Definimos o estilo da linha de suporte, para isso definimos a propriedade OBJPROP_STYLE como STYLE_SOLID

ObjectSetInteger(0,"supportLine",OBJPROP_STYLE,STYLE_SOLID);

Definimos a largura da linha na propriedade OBJPROP_WIDTH

ObjectSetInteger(0,"supportLine",OBJPROP_WIDTH,3);

A linha continuará para a direita, para isso utilizamos a propriedade OBJPROP_RAY

ObjectSetInteger(0,"supportLine",OBJPROP_RAY,true);

Depois disso, compilamos o código do EA. Se tudo estiver correto e o programa compilado sem erros, o arquivo do EA aparecerá na janela Navegador do terminal, executado como o programa anterior. O fato de o EA estar em execução será indicado pelo ícone no canto superior direito. O EA irá traçar uma linha de suporte como no exemplo abaixo:

No gráfico acima, o Support System EA está funcionando, uma linha de suporte é exibida abaixo do preço.

Níveis de resistência e MQL5

Um nível de resistência é um nível de preço ou zona que está acima dos preços atuais. Os preços caem a partir desse nível, porque a força dos vendedores é formada aqui. Portanto, eles são muito importantes, pois podemos usá-los como níveis para entrar em uma negociação de venda. Existem muitas formas de níveis de resistência. Veremos um deles, em particular o nível de apoio horizontal.

Abaixo está um exemplo de um nível de resistência no mercado:

O gráfico acima mostra uma linha vermelha acima dos preços. Os preços a tocam por baixo e saltam dela. 

O programa verificará as máximas de preço em cada tick e determinará o nível de resistência. Se uma linha de resistência existente for encontrada no gráfico, vamos exclui-la e traçar uma nova linha de resistência vermelha acima das máximas de preço. O código completo do programa que desenha tal linha no modo automático é mostrado abaixo:

//+------------------------------------------------------------------+
//|                                       Resistance Line System.mq5 |
//+------------------------------------------------------------------+
void OnTick()
  {
   int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);
   double pHigh[];
   ArraySetAsSeries(pHigh,true);
   CopyHigh(_Symbol,_Period,0,candles,pHigh);
   int candleHigh = ArrayMaximum(pHigh,0,candles);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int Data = CopyRates(_Symbol,_Period,0,candles,pArray);
   ObjectDelete(_Symbol,"resistanceLine");
   ObjectCreate(_Symbol,"resistanceLine",OBJ_HLINE,0,pArray[candleHigh].time,pArray[candleHigh].high,pArray[0].time,pArray[0].high);
   ObjectSetInteger(0,"resistanceLine",OBJPROP_COLOR,Red);
   ObjectSetInteger(0,"resistanceLine",OBJPROP_STYLE,STYLE_SOLID);
   ObjectSetInteger(0,"resistanceLine",OBJPROP_WIDTH,3);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_RAY_RIGHT,true);
  }
//+------------------------------------------------------------------+

Diferenças neste código:

Se o gráfico já tiver uma linha chamada ResistanceLine, excluímos.

ObjectDelete(_Symbol,"resistanceLine");

Criamos uma nova linha de resistência especificando OBJ_HLINE como o tipo de objeto a ser criado

ObjectCreate(_Symbol,"resistanceLine",OBJ_HLINE,0,pArray[candleHigh].time,pArray[candleHigh].high,pArray[0].time,pArray[0].high);

Definimos a cor da linha de resistência com OBJPROP_COLOR

ObjectSetInteger(0,"resistanceLine",OBJPROP_COLOR,Red);

Definimos o estilo da linha, para isso definimos a propriedade OBJPROP_STYLE como STYLE_SOLID

ObjectSetInteger(0,"resistanceLine",OBJPROP_STYLE,STYLE_SOLID);

Definimos a largura da linha na propriedade OBJPROP_WIDTH

ObjectSetInteger(0,"resistanceLine",OBJPROP_WIDTH,3);

Vamos fazer a linha continuar para a direita. Para fazer isso, usamos a propriedade de raio OBJPROP_RAY_RIGHT com o valor true

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_RAY_RIGHT,true);

Depois disso, compilamos o código do EA. Se tudo estiver correto e o programa compilado sem erros, o arquivo do EA aparecerá na janela Navegador do terminal, executado como o programa anterior. O Resistance System EA começa a rodar no gráfico:

No gráfico acima, aparece o ícone do Expert Advisor no canto superior direito do gráfico para evidenciar o funcionamento do Resistance System EA. Há também uma linha de suporte vermelha acima dos máximos.

Considerações finais

Este artigo examina três das linhas mais importantes a serem utilizadas em negociações: linhas de tendência (ascendentes e descendentes), linhas de suporte e resistência. Explicamos o que elas significam e como usá-las. Também abordamos como trabalhar com essas linhas no MQL5 para construí-las automaticamente. Desenvolvemos sistemas próprios para cada tipo de linha. Você pode aprimorar ainda mais esse código, adicionando ordens de execução para realizar negociações baseadas em níveis. Porém, é importante testar completamente os programas antes de utilizá-los em uma conta real para garantir o seu funcionamento, pois o objetivo principal deste artigo é puramente educacional.

Espero que o artigo tenha sido útil e que você possa usar os desenvolvimentos dele como parte de outro sistema mais avançado ou separadamente. As informações deste artigo podem ajudá-lo a encontrar novas ideias, mesmo aquelas não abordadas diretamente neste artigo. Também espero que você mesmo tenha escrito todo o código deste artigo e testado. Esta prática é importante para o desenvolvimento de habilidades de programação.

Se você gostou deste artigo, se achar útil, recomendo que leia meus outros artigos sobre o desenvolvimento de sistemas de negociação usando indicadores técnicos populares, como o Indicador de Média Móvel, RSI, Sochastik, Parabolic SAR, etc.

Também em artigos anteriores, abordamos os fundamentos da linguagem de programação MQL5, aprendemos como criar sistemas de negociação algorítmica e por que fazê-lo. Você pode estar interessado em ler sobre isso.