Qual parametro está errado.

Para adicionar comentários, por favor Faça o login ou registrar
Masternook
18
Masternook  
O indicador define uma quantidade de velas para entrar a favor ex: você quer 3 velas da mesma cor e quando chegar na 2 vela ele abre um alerta.
Eu quero mudar para abrir um alerta no lugar de velas da mesma cor velas alternadas.

Ex: indicador original: verde - verde - alerta - Verde*.
      O que eu quero fazer : verde - vermelha - alerta - verde*.


#property strict 
#property indicator_chart_window // 


const string ArquivoDeSomParaAlertarAberturaDeCiclo = "alert.wav"; // Arquivo deve estar disponível na pasta "<mt4-dir>/Sounds/"
const string prefixoDasSetasDeAberturaDeCiclo = "Abertura do ciclo ";
const string prefixoDasMoldurasDelimitadorasDeCiclo = "Ciclo ";
const bool DIAGNOSTICO = false; // Ativar somente durante desenvolvimento!
input bool Check = True;
//--- Configurações disponíveis
input string Separador1 = "............................................................................................................."; // ### Disparo dos alertas ### 
   // Disparar alerta antes da abertura do ciclo de numero indicado
   input int AlertarAntesDaAberturaDeQualCiclo = 3; // Alertar antes da abertura de qual ciclo?
   input int AlertarComQuantosSegundosDeAntecedencia = 10; // Alertar com quantos segundos de antecedência? 
   input int QtdeVelasSeguidasParaAberturaDeUmCiclo = 2; // Velas seguidas para abertura de cada ciclo
   input int QtdeVelasSeguidasParaConfirmacaoDeUmCiclo = 3; // Velas seguidas para confirmação de um ciclo
   // Quanto menor a quantidade de velas percorridas, melhor o desempenho
   input int QtdeDeVelasAnterioresASeremConsideradas = 10; // Velas anteriores a ser consideradas
input string Separador2 = "............................................................................................................."; // ### Tipos de alerta ### 
   input bool AlertaSonoro = true; // Alerta sonoro (popup)?
   input bool AlertaPorEmail = false; // Alerta por e-mail?
input string Separador3 = "............................................................................................................."; // ### Formatação ### 
   input color corDaSetaDeAberturaDosCiclosDeAlta = clrDeepSkyBlue; // Cor para ciclos de alta
   input color corDaSetaDeAberturaDosCiclosDeBaixa = clrDeepPink; // Cor para ciclos de baixa
   input color corDaMolduraDelimitadoraDeCiclosConfirmados = clrDeepSkyBlue; // Cor para ciclos confirmados
   input color corDaMolduraDelimitadoraDeCiclosNaoConfirmados = clrDeepPink; // Cor para ciclos não confirmados
   input ENUM_LINE_STYLE tracejadoDosCiclos = STYLE_DASH; // Estilo da moldura
input string Separador4 = "............................................................................................................."; // ### Licença de uso ### 



#include <stdlib.mqh> // ErrorDescription(...)

#define MAIN_SUBWINDOW 0
#define TAMANHO_MAXIMO_DO_CODIGO_DOS_OBJETOS 62
#define TAMANHO_MAXIMO_DA_DESCRICAO_DOS_OBJETOS 63

enum ENUM_TIPO_DE_CICLO
{
   CICLO_DE_BAIXA = -1,
   NENHUM_CICLO = 0,
   CICLO_DE_ALTA = 1
};

//--- Variáveis globais (Inicializaçao deve ocorrer no bloco "OnInit()")   
int
   qtdeVelasSeguidasDeAlta, 
   qtdeVelasSeguidasDeBaixa,
   qtdeCiclosNaoConfirmados;
ENUM_TIPO_DE_CICLO tipoDoCicloAnterior;
bool houveVelaNaDirecaoOpostaDoCicloAnterior;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---
   // Inicialização de variáveis globais
   zerarContagemDeCiclos();
//--- indicator buffers mapping
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
int start()
{
   handleTick();
   return(0);
}
//+------------------------------------------------------------------+
int deinit()
{
   const int reason = UninitializeReason();
   limpeza();
   return(0);  
}
//+------------------------------------------------------------------+
void zerarContagemDeCiclos()
{
   qtdeVelasSeguidasDeAlta = 0;
   qtdeVelasSeguidasDeBaixa = 0;
   qtdeCiclosNaoConfirmados = 0;
   
   tipoDoCicloAnterior = NENHUM_CICLO;
   houveVelaNaDirecaoOpostaDoCicloAnterior = true;
   
   Comment("Ex Tentativa: nenhuma rodada de ciclos não confirmados em andamento");    
}

//+------------------------------------------------------------------+
int handleTick()
{
   int    qtdeVelasProcessadas = IndicatorCounted(); // Returns the number of bars that have not changed since the last indicator call.
   
   //---- check for possible errors
   if(qtdeVelasProcessadas < 0) return(-1);
   int idxPrimeiraVela = (Bars -qtdeVelasProcessadas -1); // Index of the oldest bar, starting from which calculations must be started
   if (idxPrimeiraVela > (QtdeDeVelasAnterioresASeremConsideradas -1))                 // If there are too many bars...
      idxPrimeiraVela = (QtdeDeVelasAnterioresASeremConsideradas -1);                  // ..calculate for specified amount.   

   for(int idxVelaAtual = idxPrimeiraVela; idxVelaAtual >= 0; idxVelaAtual--) // The indicator array is calculated from the oldest bar to the zero one.
   { // 0 = Vela ainda aberta; 1 = Ultima vela fechada

      bool 
         velaFechada;
      int idxUltimaVelaFechada = idxVelaAtual;
      if(idxVelaAtual > 0)
      {
         velaFechada = true;
      }
      else if(novaVela())
      {
         velaFechada = true;
         idxUltimaVelaFechada = 1;
         /*
         int segundosRestantes = segundosRestantesNaVelaAberta();
         int percentualRestante = (int)(((1.0 * segundosRestantes)/PeriodSeconds()) * 100);
         idxUltimaVelaFechada = (percentualRestante < 67? 0: 1);
      */
      }
      else
      {
         velaFechada = false;
         if(qtdeCiclosNaoConfirmados == (AlertarAntesDaAberturaDeQualCiclo -1))
         {
            bool 
               aberturaIminenteDeUmCicloDeAlta  = (qtdeVelasSeguidasDeAlta  == (QtdeVelasSeguidasParaAberturaDeUmCiclo -1) && Close[0] > Open[0]),
               aberturaIminenteDeUmCicloDeBaixa = (qtdeVelasSeguidasDeBaixa == (QtdeVelasSeguidasParaAberturaDeUmCiclo -1) && Close[0] < Open[0]);
            if(aberturaIminenteDeUmCicloDeAlta
            || aberturaIminenteDeUmCicloDeBaixa)
            {
               // Abertura do último ciclo deve ser indicada com antecedencia!
               bool velaFechando = velaAbertaFechando(AlertarComQuantosSegundosDeAntecedencia, idxUltimaVelaFechada);
               if(velaFechando)
               {
                  // Alerta
                  AlertarComAntecedenciaAAberturaDoProximoCiclo();
               }            
            }
         }
      }
      
      static datetime ultimaVelaFechadaProcessada;
      if(velaFechada 
      && Time[idxUltimaVelaFechada] > ultimaVelaFechadaProcessada) // Considera apenas uma vez a vela aberta
      {         
         bool cicloEstavaAberto = false;
         ENUM_TIPO_DE_CICLO tipoDoMovimentoASerConfirmado = NENHUM_CICLO; // alta ou baixa
         if(qtdeVelasSeguidasDeAlta == QtdeVelasSeguidasParaAberturaDeUmCiclo
         || qtdeVelasSeguidasDeBaixa == QtdeVelasSeguidasParaAberturaDeUmCiclo)
         {
            cicloEstavaAberto = true; // Confirmação pendente
            if(qtdeVelasSeguidasDeAlta == QtdeVelasSeguidasParaAberturaDeUmCiclo)
            {
               tipoDoMovimentoASerConfirmado = CICLO_DE_ALTA;   
            }
            else if(qtdeVelasSeguidasDeBaixa == QtdeVelasSeguidasParaAberturaDeUmCiclo)
            {
               tipoDoMovimentoASerConfirmado = CICLO_DE_BAIXA;                    
            }
         }
   
         // Desempenho máximo: cada vela (incluindo a vela aberta) é lida uma e apenas uma vez
         if(Close[idxUltimaVelaFechada] > Open[idxUltimaVelaFechada]) // Alta
         {
            if(tipoDoCicloAnterior == CICLO_DE_BAIXA)
            {
               houveVelaNaDirecaoOpostaDoCicloAnterior = true;
            }   
            if(houveVelaNaDirecaoOpostaDoCicloAnterior)
            {
               qtdeVelasSeguidasDeAlta++;
               qtdeVelasSeguidasDeBaixa = 0;
            }
         }
         else if(Close[idxUltimaVelaFechada] < Open[idxUltimaVelaFechada]) // Baixa
         {
            if(tipoDoCicloAnterior == CICLO_DE_ALTA)
            {
               houveVelaNaDirecaoOpostaDoCicloAnterior = true;
            }  
            if(houveVelaNaDirecaoOpostaDoCicloAnterior)
            {
               qtdeVelasSeguidasDeBaixa++;
               qtdeVelasSeguidasDeAlta = 0;
            } 
         }
         else
         {
            qtdeVelasSeguidasDeAlta = 0;
            qtdeVelasSeguidasDeBaixa = 0;         
         }
         
         bool cicloFoiAberto = (qtdeVelasSeguidasDeAlta == QtdeVelasSeguidasParaAberturaDeUmCiclo
                             || qtdeVelasSeguidasDeBaixa == QtdeVelasSeguidasParaAberturaDeUmCiclo);
         if(cicloFoiAberto)
         {
            ENUM_TIPO_DE_CICLO tipoDoCicloQueFoiAberto = NENHUM_CICLO;
            if(qtdeVelasSeguidasDeAlta == QtdeVelasSeguidasParaAberturaDeUmCiclo)
            {
               tipoDoCicloQueFoiAberto = CICLO_DE_ALTA;   
            }
            else if(qtdeVelasSeguidasDeBaixa == QtdeVelasSeguidasParaAberturaDeUmCiclo)
            {
               tipoDoCicloQueFoiAberto = CICLO_DE_BAIXA;                    
            }         
            IlustrarAberturaDoCiclo(idxUltimaVelaFechada, tipoDoCicloQueFoiAberto);            
         }
   
         if(cicloEstavaAberto)
         {
            int numeroDoCicloAtual = qtdeCiclosNaoConfirmados + 1;
            bool confirmado;
            if(qtdeVelasSeguidasDeAlta == QtdeVelasSeguidasParaConfirmacaoDeUmCiclo
            || qtdeVelasSeguidasDeBaixa == QtdeVelasSeguidasParaConfirmacaoDeUmCiclo)
            {
               qtdeCiclosNaoConfirmados = 0; // Zera contagem de ciclos
               confirmado = true;
            }
            else // Caso o ciclo aberto não seja confirmado
            {
               qtdeCiclosNaoConfirmados++;
               confirmado = false;
            }
            if(confirmado == false)
            {
               // Sobreposição de ciclos: restaura o último incremento na contagem das velas seguidas, pois 
               //  a última vela deve ser considerada também no próximo ciclo
               if(qtdeVelasSeguidasDeAlta > 0)
               {
                  qtdeVelasSeguidasDeAlta = 1;
                  qtdeVelasSeguidasDeBaixa = 0;
               }
               else if(qtdeVelasSeguidasDeBaixa > 0)
               {
                  qtdeVelasSeguidasDeBaixa = 1;
                  qtdeVelasSeguidasDeAlta = 0;
               }
               houveVelaNaDirecaoOpostaDoCicloAnterior = true;
            }
            else
            {
               qtdeVelasSeguidasDeAlta = 0;
               qtdeVelasSeguidasDeBaixa = 0;
               houveVelaNaDirecaoOpostaDoCicloAnterior = false;
            }
                        
            IlustrarFechamentoDoCiclo(idxUltimaVelaFechada, numeroDoCicloAtual, tipoDoMovimentoASerConfirmado, confirmado);
            tipoDoCicloAnterior = tipoDoMovimentoASerConfirmado;
         }
         
         ultimaVelaFechadaProcessada = Time[idxUltimaVelaFechada];
      }      
   }      
//---
   return(0);
}
//+------------------------------------------------------------------+
void AlertarComAntecedenciaAAberturaDoProximoCiclo()
{
   string
       assunto = "Alerta do indicador '" + WindowExpertName() + "' (" + TimeToString(TimeCurrent()) + ")",
       msg = "Atenção: abertura do " + IntegerToString(AlertarAntesDaAberturaDeQualCiclo) + "º ciclo em andamento no par " + Symbol();
   if(AlertaSonoro)
   {
      Alert(msg);
      bool arquivoDeSomEncontrado = PlaySound(ArquivoDeSomParaAlertarAberturaDeCiclo);
      if(arquivoDeSomEncontrado == false)
      {
         Alert("Erro: arquivo de som não encontrado (", ArquivoDeSomParaAlertarAberturaDeCiclo, ")" );   
      }
   }
   if(AlertaPorEmail)
   {
      bool mensagemEnviadaPorEmail = SendMail(assunto, msg);
      if(mensagemEnviadaPorEmail == false)
      {
         Alert("Erro durante envio de e-mail: ", ErrorDescription(GetLastError()));   
      }
   }          
}
//+------------------------------------------------------------------+
 bool velaAbertaFechando(int segundos_de_antecedencia, int& idxUltimaVelaFechada)
 {
   /*
       Detecta fechamento da vela aberta antes da abertura da proxima vela
        permitindo o uso posterior do indice zero para se referir a ultima vela cheia.
       Ou seja: High[0] - Low[0] dificilmente retornara zero apos detecçao de nova vela, pois 
         o indice zero referenciara a maioria dos ticks da vela que esta proxima do fechamento! 
    */
   int segundos_restantes = segundosRestantesNaVelaAberta();
   bool ultimo_tick_da_vela_aberta = (segundos_restantes <= segundos_de_antecedencia);
   static datetime ultima_vela_fechada; // Static variables do not loose their values after a function execution is over
   bool fechamento_pendente_da_vela_anterior = (novaVela() && (ultima_vela_fechada < Time[1])); // Necessario caso nao houver ticks no intervalo
   if(ultimo_tick_da_vela_aberta || fechamento_pendente_da_vela_anterior)
   {
     if(Time[0] > ultima_vela_fechada) // Evita sinalizar varias vezes o fechamento da mesma vela  
     {
        if(fechamento_pendente_da_vela_anterior)
        {
           ultima_vela_fechada = Time[1]; // Novo fechamento
           idxUltimaVelaFechada = 1;
        }
        else
        {           
           ultima_vela_fechada = Time[0]; // Novo fechamento
           idxUltimaVelaFechada = 0;
        }  
     }
     else
     {
        ultimo_tick_da_vela_aberta = false; // Fechamento ja foi sinalizado em tick anterior 
     }  
   }
   return ultimo_tick_da_vela_aberta;
 }
//+------------------------------------------------------------------+
 int segundosRestantesNaVelaAberta()
 {
   datetime 
      momento_da_ultima_abertura_de_vela = Time[0],
      momento_atual = TimeCurrent(), // Horario no servidor
      momento_da_proxima_abertura_de_vela = momento_da_ultima_abertura_de_vela + PeriodSeconds();
   int qtde_segundos_restantes_para_o_fechamento_da_vela_aberta = (int)(momento_da_proxima_abertura_de_vela - momento_atual);
   return qtde_segundos_restantes_para_o_fechamento_da_vela_aberta;
 } 
//+------------------------------------------------------------------+
bool novaVela()                              // Funct. detecting a new bar
  {                                           
   /*
       Detecta fechamento da vela aberta somente apos a abertura da proxima vela
        impedindo o uso posterior do indice zero para se referir a ultima vela cheia.
       Ou seja: High[0] - Low[0] sempre retornara zero apos detecçao de nova vela, pois 
         o indice zero referenciara apenas o primeiro tick da vela que acabou de ser aberta! 
    */
   // Static variables do not loose their values after a function execution is over
   static datetime New_Time=0;                  // Time of the current bar
   bool New_Bar=false;                          // No new bar
   if(New_Time != Time[0])                        // Compare time
     {
      New_Time = Time[0];                         // Now time is so
      New_Bar = true;                             // A new bar detected
     }
   return(New_Bar);  
  }
//+------------------------------------------------------------------+
void IlustrarAberturaDoCiclo(int idxVelaAtual, ENUM_TIPO_DE_CICLO tipoDoCicloQueFoiAberto)
{
   int numeroDoCicloAtual = (qtdeCiclosNaoConfirmados + 1);
   // http://book.mql4.com/functions/objects
   // http://docs.mql4.com/constants/objectconstants/enum_object/obj_arrow_up
   // http://docs.mql4.com/customind/setindexarrow
   // http://docs.mql4.com/constants/objectconstants/wingdings
   ENUM_OBJECT tipo = (tipoDoCicloQueFoiAberto == CICLO_DE_ALTA? OBJ_ARROW_UP: OBJ_ARROW_DOWN);
   ENUM_ARROW_ANCHOR ancora_da_seta = (tipoDoCicloQueFoiAberto == CICLO_DE_ALTA? ANCHOR_TOP: ANCHOR_BOTTOM);
   const int codigo_do_icone_da_seta = (tipoDoCicloQueFoiAberto == CICLO_DE_ALTA? 233: 234);
   color cor_da_seta = (tipoDoCicloQueFoiAberto == CICLO_DE_ALTA? corDaSetaDeAberturaDosCiclosDeAlta: corDaSetaDeAberturaDosCiclosDeBaixa);
   datetime x1 = Time[idxVelaAtual];
   double y1 = (tipoDoCicloQueFoiAberto == CICLO_DE_ALTA? Low[idxVelaAtual] - (3 * Point): High[idxVelaAtual] + (3 * Point));
   string 
      objectID = prefixoDasSetasDeAberturaDeCiclo + IntegerToString(numeroDoCicloAtual) + " de " + (tipoDoCicloQueFoiAberto == CICLO_DE_ALTA? "alta": "baixa") + " [" + obterSiglaDoPeriodoAtual() + "]: " + TimeToString(x1),
      descricao = objectID;
   objectID = StringSubstr(objectID, 0, TAMANHO_MAXIMO_DO_CODIGO_DOS_OBJETOS); // Trunca para evitar a perda de todo o valor quando o limite for ultrapassado    
   bool criou = ObjectCreate(ChartID(), objectID, tipo, MAIN_SUBWINDOW, x1, y1);
   if(criou)
   {
      descricao = StringSubstr(descricao, 0, TAMANHO_MAXIMO_DA_DESCRICAO_DOS_OBJETOS); // Trunca para evitar a perda de todo a descricao quando o limite for ultrapassado
      // Descriçao
      bool alterou = ObjectSetText(objectID, descricao, 10);
      if(alterou == false && DIAGNOSTICO)
      {
         Alert("Erro durante alteracao da descriçao do objeto.\nMotivo: ", ErrorDescription(GetLastError()));                  
      }
      
      // Espessura
      alterou = ObjectSetInteger(ChartID(), objectID, OBJPROP_WIDTH, 2);
      if(alterou == false && DIAGNOSTICO)
      {
         Alert("Erro durante alteracao da espessura do objeto.\nMotivo: ", ErrorDescription(GetLastError()));                  
      }      
      
      // Evita que a seta oculte a vela
      // http://docs.mql4.com/constants/objectconstants/enum_anchorpoint#enum_arrow_anchor
      alterou = ObjectSetInteger(ChartID(), objectID, OBJPROP_ANCHOR, ancora_da_seta);
      if(alterou == false && DIAGNOSTICO)
      {
         Alert("Erro durante alteracao da ancora do objeto.\nMotivo: ", ErrorDescription(GetLastError()));                  
      }               

      // Ícone da seta
      alterou = ObjectSetInteger(ChartID(), objectID, OBJPROP_ARROWCODE, codigo_do_icone_da_seta);
      if(alterou == false && DIAGNOSTICO)
      {
         Alert("Erro durante alteracao do ícone do objeto.\nMotivo: ", ErrorDescription(GetLastError()));                  
      }          
      
      // Cor da seta
      alterou = ObjectSetInteger(ChartID(), objectID, OBJPROP_COLOR, cor_da_seta);
      if(alterou == false && DIAGNOSTICO)
      {
         Alert("Erro durante alteracao da cor da seta de abertura de ciclo.\nMotivo: ", ErrorDescription(GetLastError()));                  
      }           
   }
   else if(DIAGNOSTICO)
   {
      Alert("Erro durante criaçao do objeto '", objectID, "'.\nMotivo: ", ErrorDescription(GetLastError()));
   }
   Comment("Ex Tentativa: ", numeroDoCicloAtual, "º ciclo iniciado");
}
//+------------------------------------------------------------------+
void IlustrarFechamentoDoCiclo(int idxVelaAtual, int numeroDoCicloAtual, ENUM_TIPO_DE_CICLO tipoDoMovimento, bool confirmado)
{
   // http://book.mql4.com/functions/objects
   // http://docs.mql4.com/constants/objectconstants/enum_object/obj_rectangle
   ENUM_OBJECT tipo = OBJ_RECTANGLE;
   datetime 
      meioPeriodo = PeriodSeconds()/2,
      x1 = Time[idxVelaAtual + QtdeVelasSeguidasParaConfirmacaoDeUmCiclo - 1] + meioPeriodo, // Lado esquerdo
      x2 = Time[idxVelaAtual] + meioPeriodo; // Lado direito
   double 
      y1 = High[iHighest(Symbol(), Period(), MODE_HIGH, QtdeVelasSeguidasParaConfirmacaoDeUmCiclo, idxVelaAtual)], // Lado superior
      y2 = Low[iLowest(Symbol(), Period(), MODE_LOW, QtdeVelasSeguidasParaConfirmacaoDeUmCiclo, idxVelaAtual)]; // Lado inferior
   string 
      objectID = prefixoDasMoldurasDelimitadorasDeCiclo + IntegerToString(numeroDoCicloAtual) + " de " + (tipoDoMovimento == CICLO_DE_ALTA? "alta": "baixa") + " (" + (confirmado? "Confirmado": "Não confirmado") + ") [" + obterSiglaDoPeriodoAtual() + "]: " + TimeToString(Time[idxVelaAtual]),
      descricao = objectID;
   objectID = StringSubstr(objectID, 0, TAMANHO_MAXIMO_DO_CODIGO_DOS_OBJETOS); // Trunca para evitar a perda de todo o valor quando o limite for ultrapassado    
   bool criou = ObjectCreate(ChartID(), objectID, tipo, MAIN_SUBWINDOW
                              // Canto superior esquerdo
                              , x1, y1
                              // Canto inferior direito
                              , x2, y2);
   if(criou)
   {
      descricao = StringSubstr(descricao, 0, TAMANHO_MAXIMO_DA_DESCRICAO_DOS_OBJETOS); // Trunca para evitar a perda de todo a descricao quando o limite for ultrapassado
      // Descriçao
      bool alterou = ObjectSetText(objectID, descricao, 10);
      if(alterou == false && DIAGNOSTICO)
      {
         Alert("Erro durante alteracao da descriçao do objeto.\nMotivo: ", ErrorDescription(GetLastError()));                  
      }
    
      // Cor
      color corDaMolduraDoCiclo = (confirmado? corDaMolduraDelimitadoraDeCiclosConfirmados: corDaMolduraDelimitadoraDeCiclosNaoConfirmados);
      alterou = ObjectSetInteger(ChartID(), objectID, OBJPROP_COLOR, corDaMolduraDoCiclo);
      if(alterou == false && DIAGNOSTICO)
      {
         Alert("Erro durante alteracao da cor do objeto.\nMotivo: ", ErrorDescription(GetLastError()));                  
      }
      
      // Espessura
      if(tracejadoDosCiclos == STYLE_SOLID)
      {
         alterou = ObjectSetInteger(ChartID(), objectID, OBJPROP_WIDTH, 4);
         if(alterou == false && DIAGNOSTICO)
         {
            Alert("Erro durante alteracao da espessura do objeto.\nMotivo: ", ErrorDescription(GetLastError()));                  
         }                  
      }

      // Tracejado
      ENUM_LINE_STYLE style = tracejadoDosCiclos;
      alterou = ObjectSetInteger(ChartID(), objectID, OBJPROP_STYLE, style);            
      if(alterou == false && DIAGNOSTICO)
      {
         Alert("Erro durante alteracao do tracejado do objeto.\nMotivo: ", ErrorDescription(GetLastError()));                  
      }
   
      // Primeiro ou segundo plano
      alterou = ObjectSetInteger(ChartID(), objectID, OBJPROP_BACK, false); // Ativa ou nao a transparencia
      if(alterou == false && DIAGNOSTICO)
      {
         Alert("Erro durante alteracao do plano do objeto.\nMotivo: ", ErrorDescription(GetLastError()));                  
      }         
   }
   else if(DIAGNOSTICO)
   {
      Alert("Erro durante criaçao do objeto '", objectID , "'.\nMotivo: ", ErrorDescription(GetLastError()));
   }
   
   if(qtdeCiclosNaoConfirmados == AlertarAntesDaAberturaDeQualCiclo)
   { // Alerta foi feito antes da abertura do ciclo final!
      zerarContagemDeCiclos();      
   }
   else
   {
      if(qtdeCiclosNaoConfirmados == 0)
      {
         Comment("Ex Tentativa: nenhuma rodada de ciclos não confirmados em andamento");    
      }
      else if(qtdeCiclosNaoConfirmados == 1)
      {
         Comment("Ex Tentativa: 1 ciclo não confirmado");                      
      }
      else if(qtdeCiclosNaoConfirmados > 1)
      {
         Comment("Ex Tentativa: ", qtdeCiclosNaoConfirmados , " ciclos consecutivos não confirmados");                      
      }   
   }   
}
//+------------------------------------------------------------------+
string obterSiglaDoPeriodoAtual()
{
   ENUM_TIMEFRAMES periodo = (ENUM_TIMEFRAMES) Period();
   string txt = EnumToString(periodo);
   StringReplace(txt, "PERIOD_", "");
   return(txt);
}
//+------------------------------------------------------------------+
void limpeza()
{
   // Apaga apenas objetos gerados pelo indicador
   int qtde_objetos = ObjectsTotal(ChartID(), MAIN_SUBWINDOW);
   
   // Parte 1 - coleta nome dos objetos
   string nomes[];
   ArrayResize(nomes, qtde_objetos);
   for(int i=0; i < qtde_objetos; i++)
   {
      string objectID = ObjectName(ChartID(), i, MAIN_SUBWINDOW);
      nomes[i] = objectID;
   }

   // Parte 2 - remove objetos
   for(int i=0; i < qtde_objetos; i++)
   {
         string objectID = nomes[i];
         if(StringSubstr(objectID, 0, StringLen(prefixoDasSetasDeAberturaDeCiclo)) == prefixoDasSetasDeAberturaDeCiclo
         || StringSubstr(objectID, 0, StringLen(prefixoDasMoldurasDelimitadorasDeCiclo)) == prefixoDasMoldurasDelimitadorasDeCiclo) // Se nome inicia com o prefixo
         {
            bool apagou = ObjectDelete(ChartID(), objectID);    
            if(apagou == false && DIAGNOSTICO)
            {
               Alert("Erro ao remover objeto: ", ErrorDescription(GetLastError()));   
            }                 
         }
   }
   //ChartRedraw(ChartID()); // Repaint
}
//+------------------------------------------------------------------+

Rodrigo Malacarne
Moderador
11060
Rodrigo Malacarne  

Olá Masternook,

Dificilmente você conseguirá uma resposta para sua dúvida...

Você colocou o código "completo" de um indicador que não compila, e ainda não descreve exatamente qual seria o problema.

Caso queira uma resposta de alguém na comunidade, o ideal seria mesmo especificar melhor qual sua dúvida.

Mas caso queira alguém pra "corrigir" o seu código, o ideal é usar o serviço de algum programador: https://www.mql5.com/pt/job

Abraços,
Malacarne

Aplicativos de negociação para o MetaTrader 5 por encomenda
Aplicativos de negociação para o MetaTrader 5 por encomenda
  • www.mql5.com
A estratégia funciona assim, a caixa azul de move quando a vela se fecha,entende? quando a vela se fecha a caixa azul de move, o sinal é a ultima vela, se a cor da vela for verde é sinal de compra se for vermelha e sinal de venda, a entrada que é na onde a seta tem que aparecer que é depois do sinal ( depois da caixa azul) a seta não pode...
Masternook
18
Masternook  
Consertei o código, eu quero que no lugar dele contar velas iguais conte velas alternadas.

Qual parâmetro está contando as velas iguais?. Nessa parte que eu me perdi, só preciso saber o parametro para alterar.
Masternook
18
Masternook  
Seria esse:

               aberturaIminenteDeUmCicloDeAlta  = (qtdeVelasSeguidasDeAlta  == (QtdeVelasSeguidasParaAberturaDeUmCiclo -1) && Close[0] > Open[0]),
               aberturaIminenteDeUmCicloDeBaixa = (qtdeVelasSeguidasDeBaixa == (QtdeVelasSeguidasParaAberturaDeUmCiclo -1) && Close[0] < Open[0]);


Como alterar para não contar velas seguidas mas sim alternadas?.

Para adicionar comentários, por favor Faça o login ou registrar