English Русский 中文 Español Deutsch 日本語
Alert e Comment para Indicadores Externos. Análise de Multimoedas Através de Varredura Externa

Alert e Comment para Indicadores Externos. Análise de Multimoedas Através de Varredura Externa

MetaTrader 4Exemplos | 1 outubro 2015, 09:39
1 820 0
Vladimir
Vladimir

Introdução

Em artigos anteriores, vimos como a informação pode ser obtida a partir de indicadores que utilizam símbolos Wingdings exibidos num gráfico, como uma fonte de informação ("Alert e Comment para Indicadores Externos") e como criar estes indicadores. Estes indicadores de alertas usam buffers de indicador para armazenar informações ("Alert e Comment para Indicadores Externos. Parte dois"), enquanto a produção das informações é implementada através da alteração de cores.

O cruzamento de linhas do indicador que são armazenados em buffers de indicador representa uma outra forma de informar o usuário sobre o comportamento do indicador.

Como já vimos, obter valores de buffers do indicador em si não é algo complicado que possa afetar a carga do processador. Em nosso indicador, implementaremos a possibilidade de mostrar as informações das multimoedas.

Se o número de instrumentos (ativos) disponíveis for grande, o trader sofre considerável tensão na sua vista, devido ao monitoramento gráfico constante, por isto os traders costumam escolher apenas alguns símbolos e negociam exclusivamente neles.

Olhando o mercado mais tarde, muitas vezes é visto que havia uma oportunidade para executar um negócio ou um número de negócios para outro par de moedas, cujo mapa não foi aberto na tela no momento certo. É por isso que precisamos da análise de multimoedas nos instrumentos disponíveis usando um indicador.

Com base na ideia que venho trabalhando, uma função de alerta é usada como uma maneira de exibir rapidamente informações sobre as alterações na lista dos instrumentos disponíveis.


"Alert" Baseado no Indicator de Multimoedas

Primeiro, vamos dar uma olhada no código do bloco de processamento de dados que obtém informações dos buffers do indicador externo.

double buffer1, buffer2, buffer12, buffer22;
// Analisar as primeiras e segundas barras nos gráficos
            buffer1  = iCustom(Sym_, TF, nameIndicator, 0, ExtBuff1, 1);
            buffer12 = iCustom(Sym_, TF, nameIndicator, 0, ExtBuff1, 2);
            buffer2  = iCustom(Sym_, TF, nameIndicator, 0, ExtBuff2, 1);
            buffer22 = iCustom(Sym_, TF, nameIndicator, 0, ExtBuff2, 2);
            if(buffer12<=buffer22&&buffer1>buffer2)
               {
                  Alert (text+"UP"); // Existe um 
                  send_email (text+"UP");
                  return (1);
               }
            if(buffer12>=buffer22&&buffer1<buffer2)
               {
                  Alert (text+"DN"); // Existe um cruzamento
                  send_email (text+"DN");
                  return (1);
               } 
            return (0);

Como podemos ver, tudo aqui é simples, a lógica é semelhante ao nosso artigo anterior. Na última vez usamos a mudança de cor dos buffers exibidos, enquanto aqui usamos os valores da posição destes buffers em relação a cada outra posição.

O processamento necessário será implementado como um bloco separado. Multi-moedas e múltiplos timeframes exigirão o uso deste procedimento repetido.

A lista de instrumentos disponíveis serão armazenados num arquivo externo, o que nos permite simplificar o processo de fazer alterações no caso de quaisquer modificações necessárias no futuro. Usando essa abordagem, a fim de modificar a lista de instrumentos disponíveis, o usuário pode de forma independente recriar ou fazer alterações no arquivo dos instrumentos disponíveis, sem ter que modificar o código do programa do indicador.

No final do artigo, você verá como pode criar um arquivo personalizado dos instrumentos disponíveis.

Um subprograma de leitura dos dados de arquivo é fornecida abaixo.

//+------------------------------------------------------------------+
//|                                           SymbolList_fromSet.mq4 |
//|                                      Copyright © 2006, komposter |
//|                                      mailto:komposterius@mail.ru |
//+------------------------------------------------------------------+
void LoadFileToSymbol()
   {
      {
              int file_handle = FileOpen(SetFile_name + ".set", FILE_READ);
              //---- Se ocorrer um erro
              if(file_handle < 0)
                {
                         Print("Error No.", GetLastError(), " when opening the file!!!");
                         return(-1);
                }
              int SymbolsCount = 0;
              while(true)
                {
                         Symbols[SymbolsCount] = FileReadString(file_handle);
                         //---- Se você chegou ao final do arquivo, pare
                         if(GetLastError() == 4099) 
                             break;
                         if(FileIsEnding(file_handle)) 
                             break;
                         SymbolsCount ++;
                         ArrayResize(Symbols, SymbolsCount + 1);
                }
              FileClose(file_handle);
      }
   
   }  
//*-------------------------------------------------------------------+

Agora, depois de preparar o array dos instrumentos, somente precisamos implementar o processamento dos múltiplos timeframe para cada instrumento.

Vamos começar os cálculos com o timeframe atual.

// Analisar o array dos símbolos (cálculos sobre o símbolo atual e todos timeframes menores)
         for (int i=0; i<ArraySize(Symbols); i++)
            {  Total = 0;
               switch (Period())
                  {
                     case 43200: Total = Total +  process ( Symbols[i], 43200);
                     case 10080: Total = Total +  process ( Symbols[i], 10080);
                     case  1440: Total = Total +  process ( Symbols[i],  1440);
                     case   240: Total = Total +  process ( Symbols[i],   240);
                     case    60: Total = Total +  process ( Symbols[i],    60);
                     case    30: Total = Total +  process ( Symbols[i],    30);
                     case    15: Total = Total +  process ( Symbols[i],    15);
                     case     5: Total = Total +  process ( Symbols[i],     5);
//                     case     1: Total = Total +  process ( Symbols[i],     1);
                  }

Os cálculos são feitos a partir do intervalo do timeframe corrente ao timeframe menor. Então, se você precisa calcular o alerta a partir de estrutura do timeframe diário, o gráfico com o indicador anexo deve ser aberto no timeframe diário. Se você precisa para obter um sinal a partir de estrutura do timeframe horário, o timeframe do gráfico deve ser horário e assim por diante. O indicador é recalculado somente em cada nova barra.

Essa abordagem permite ao usuário manipular os novos cálculos do indicador de uma forma mais prática: você simplesmente altera o timeframe de trabalho, sem ter de adicionar parâmetros adicionais e funções de cálculo ao código.

A seqüência de caracteres para trabalhar num timeframe está comentada. Ele precisa ser descomentada no caso de você ter de usar o indicador num timeframe de um minuto.

//                     case     1: Total = Total +  AlertComment ( Symbols[i],     1);


O indicador 2MA_forAlert.mq4 anexado ao artigo é usado como a fonte de dados para o indicador. O 2MA_forAlert é um indicador simples que exibe duas linhas MA. Você também pode usar qualquer outro indicador que tenha dois buffers (duas linhas), por exemplo, Estocástico, MACD, etc.

Nesta imagem temos como o alerta do terminal é mostrado quando diferentes indicadores são utilizados:


Os buffers onde os valores de linha são armazenados podem ter ordem diferente. Por exemplo:

0 - linha principal

1 - linha de sinal

ou

0 - linha de sinal

1 - linha principal

Então, ao usar o indicador externo, você deve determinar a seu gosto a ordem na qual as linhas serão utilizadas. Em caso de notificação de alerta incorreta, os parâmetros de entrada devem ser alterados.

extern int       ExtBuff1      = 0;
extern int       ExtBuff2      = 1;

Todos os 8 buffers disponíveis (números de 0 a 7) podem ser utilizados como parâmetros.

Vendo que o indicador usa o arquivo externo com uma lista de instrumentos, vou mostrar-lhe como ele pode ser gerado no terminal.

Primeiro, criamos todos os instrumentos necessários na janela de dados e para este efeito:

1. Abra todos os instrumentos disponíveis.



2. Deixe somente aqueles do qual vamos receber sinais.

Devem ter tantos instrumentos quanto o necessário para usar na negociação


3. Em seguida, clique com o botão direito na janela Observação do Mercado para salvar o arquivo.


4. O arquivo deve ser salvo na pasta que contém arquivos dos Expert Advisors do terminal MetaTrader


O arquivo pode ter qualquer nome, mas a extensão .set do arquivo não pode ser modificada. O exemplo fornecido no artigo utiliza o arquivo forexall.set.

extern string    SetFile_name  = "forexall"; // Arquivo que contém símbolos de instrumentos do usuário


Depois de criar o arquivo, você deve abrir gráficos para cada símbolo, um por um, para que o terminal carregue a histórico. Caso contrário, qualquer um dos instrumentos pode ser excluído do processamento.

Se você salvou o arquivo na pasta \experts\ symbolsets, certifique-se de copiá-lo para a pasta de arquivos MetaTrader\experts\files, uma vez que esta é a única pasta a partir do qual o indicador pode abrir o arquivo (limitações do terminal MetaTrader). No indicador, você deve ainda entrar com o nome do arquivo que será processado para ler os dados sobre os instrumentos disponíveis que ele contém.

Você também tem a oportunidade de obter informações sobre o funcionamento do scanner multimoedas ao seu e-mail. Basta definir o valor do parâmetro correspondente como "true" e receba os sinais por e-mail.

extern bool      Signal_email  = false;

Os usuários que continuarem o desenvolvimento de código, podem implementar o redirecionamento para receber sinais via SMS aos seus telefones. Abordagem é diferente a todo mundo.

Todos os indicadores devem estar na pasta MetaTrader\experts\indicators.


Conclusão

Esta abordagem permite que você use as funções de alerta para construir seu espaço de informações de vários módulos, sem ter que aprender programação ou procurar um especialista para implementar sua idéia num programa. A principal coisa para nós é obter as informações oportunas.

Como conclusão, eu vou fornecer um código completo do indicador de alerta.

//+------------------------------------------------------------------+
//|                                                    Alert_MT4.mq4 |
//|                                      Copyright © 2009, Fibook.ru |
//|                                             http://www.fibook.ru |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, Fibook.ru"
#property link      "http://www.fibook.ru"

#property indicator_chart_window

extern string    SetFile_name="forexall"; // Arquivo que contém símbolos dos instrumentos do usuário
extern string    nameIndicator = "input indicator name";
extern int       ExtBuff1      = 0;
extern int       ExtBuff2      = 1;
extern string    UserText      = "Cross";
extern bool      Signal_email  = false;

string Symbols[1],text;
int expBars=0;
//+------------------------------------------------------------------+
//| Função de iteração do indicador personalizado                    |
//+------------------------------------------------------------------+
int start()
  {
// Se não houver uma nova barra, sair
   if(!isNewBar()) return;
   int Total;
// ---- Verifique se há erros nos parâmetros de entrada
   if(ControlError()==false) return;
// ---- Carrega símbolos a partir do arquivo ao array Symbols
   LoadFileToSymbol();
//----

// Analisar o array dos símbolos (cálculos sobre o símbolo atual e todos timeframes menores)
   for(int i=0;i<ArraySize(Symbols);i++)
     {
      Total=0;
      switch(Period())
        {
         case 43200: Total = Total +  process ( Symbols[i], 43200);
         case 10080: Total = Total +  process ( Symbols[i], 10080);
         case  1440: Total = Total +  process ( Symbols[i],  1440);
         case   240: Total = Total +  process ( Symbols[i],   240);
         case    60: Total = Total +  process ( Symbols[i],    60);
         case    30: Total = Total +  process ( Symbols[i],    30);
         case    15: Total = Total +  process ( Symbols[i],    15);
         case     5: Total = Total +  process ( Symbols[i],     5);
         //                     case     1: Total = Total +  process ( Symbols[i],     1);
        }
      if(Total>1)
        {
         text=StringConcatenate(" Warning!!!      ",Symbols[i]," have ",UserText," for ",Total," TF");
         Alert(text);
         send_email(text);
        }
     }

//----
   return(0);
  }
//+------------------------------------------------------------------+

int process(string Sym_,int TF)
  {
   text=StringConcatenate(Sym_," ",TF," indicator ",nameIndicator," Crossing line ");
   double buffer1,buffer2,buffer12,buffer22;
// Analisar as primeiras e segundas barras nos gráficos
   buffer1  = iCustom(Sym_, TF, nameIndicator, 0, ExtBuff1, 1);
   buffer12 = iCustom(Sym_, TF, nameIndicator, 0, ExtBuff1, 2);
   buffer2  = iCustom(Sym_, TF, nameIndicator, 0, ExtBuff2, 1);
   buffer22 = iCustom(Sym_, TF, nameIndicator, 0, ExtBuff2, 2);
   if(buffer12<=buffer22 && buffer1>buffer2)
     {
      Alert(text+"UP"); // Existe um cruzamento
      send_email(text+"UP");
      return(1);
     }
   if(buffer12>=buffer22 && buffer1<buffer2)
     {
      Alert(text+"DN"); // Existe um cruzamento
      send_email(text+"DN");
      return(1);
     }
   return(0);

  }
//+------------------------------------------------------------------+
//|                                           SymbolList_fromSet.mq4 |
//|                                      Copyright © 2006, komposter |
//|                                      mailto:komposterius@mail.ru |
//+------------------------------------------------------------------+

void LoadFileToSymbol()
  {
     {
      int file_handle=FileOpen(SetFile_name+".set",FILE_READ);
      //---- Se ocorrer um erro
      if(file_handle<0)
        {
         Print("Error No.",GetLastError()," when opening the file!!!");
         return(-1);
        }
      int SymbolsCount=0;
      while(true)
        {
         Symbols[SymbolsCount]=FileReadString(file_handle);
         //---- Se você chegou ao final do arquivo, pare
         if(GetLastError()==4099)
            break;
         if(FileIsEnding(file_handle))
            break;
         SymbolsCount++;
         ArrayResize(Symbols,SymbolsCount+1);
        }
      FileClose(file_handle);
     }

  }
//--------------------------------------------------------------+
void send_email(string text)
  {
   if(Signal_email==true) SendMail("Alert ",text);
  }
//--------------------------------------------------------------+
bool ControlError()
  {
// Verifique se foi inserido o nome do indicador 
   if(nameIndicator=="input indicator name")
     {
      Alert("Enter the indicator name ");
      return(false);
     }
// Verifique se existe o arquivo que contém os símbolos
   int handle;
   handle=FileOpen(SetFile_name+".set",FILE_CSV|FILE_READ,';');
   if(handle<1)
     {
      Alert("The ",SetFile_name,".set file could not be found, last error ",GetLastError());
      return(false);
     }
// Verifique se existe qualquer erro na atribuição das variáveis de entrada analisadas dos buffers do indicador 
   if(ExtBuff1>7 || ExtBuff2>7)
     {
      Alert("Incorrect parameters of the ExtBuff1 or ExtBuff2 buffer");
      return(false);
     }
   if(ExtBuff1==ExtBuff2)
     {
      Alert("Error: ExtBuff1 and ExtBuff2 cannot be equal");
      return(false);
     }

   return(true);
  }
//+------------------------------------------------------------------+
//| A função retorna "true" com nova barra, do contrário será "false"|                                                                 |
//+------------------------------------------------------------------+
bool isNewBar()
  {
   bool res=false;
   if(expBars!=Bars)
     {
      expBars=Bars;
      res=true;
     }
   return(res);
  }
//+------------------------------------------------------------------+

Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/1371

Arquivos anexados |
2MA_forAlert.mq4 (2.72 KB)
Alert_MT4.mq4 (6.31 KB)
Alert e Comment para Indicadores Externos (Parte II) Alert e Comment para Indicadores Externos (Parte II)
Desde que publiquei o artigo "Alert e Comment para indicadores externos", tenho recebido pedidos e perguntas a respeito da possibilidade de desenvolver uma operação baseada em informação externa com linhas de indicador, tendo analisado as perguntas, eu decidi continuar com o assunto. Os dados armazenados em buffers de indicador acabaram despertando outra área de interesse dos usuários.
Controle Gráfico dos Parâmetros Externos dos Indicadores Controle Gráfico dos Parâmetros Externos dos Indicadores
Variáveis externas de indicadores são controladas usando uma janela especial, onde os parâmetros podem ser alterados e então o indicador é executado novamente. O inconveniente óbvio destas manipulações deu origem à necessidade de exibir os parâmetros na tela e controlar o indicador graficamente.
O Quanto é Confiável Negociar à Noite? O Quanto é Confiável Negociar à Noite?
O artigo aborda as peculiaridades da negociação em lateralidade de preço à noite nos pares de moedas cruzadas, explica onde você pode ter expectativa de lucros e porque grandes perdas não são improváveis. O artigo também apresenta um exemplo do Expert Advisor desenvolvido para negociação à noite e fala sobre a aplicação prática desta estratégia.
Lendo Feeds de Notícias RSS Via MQL4 Lendo Feeds de Notícias RSS Via MQL4
Este artigo mostra um exemplo da leitura de RSS via MQL4 utilizando as funções para análise de tags HTML. Vamos tentar fazer uma peça de trabalho que pode então ser transformada num indicador de notícias ou apenas um leitor na linguagem MQL4.