Problemas ao postar no Market - Validação

 

Olá pessoal,


Depois de dezenas de tentativas tentando colocar hoje um update do meu EA no Market do MT5 e dando erros variados, acho que está com algum probleminha. Colegas Moderadores poderiam ajudar e dar uma checadinha se está com algum problema o processo de Validação? Ou se alteraram alguma coisa?

Já tentei até com EA que foi aprovado no Market em fevereiro/2020 e desta vez não passou, botei umas linhas em branco e mudei a versão para ele entender como se fosse um "novo" EA mesmo assim ele dá uns erros que antes não dava.

Por fim ainda criei um "TesteHomologação" que não tem setup algum, ele apenas verifica se tem saldo na conta e abre um compra a mercado com 50 pontos de TP e 100 pontos de SL, sem filtro de papel, período ou outra coisa que estivesse fora das regras de validação, mesmo assim foi barrado com erros desconexos ao EA, 

Alguém mais está tendo problemas?

Vou postar apenas o último erro, mas cada tentativa dá erros variados sem conexão com o código, Esse último por exemplo, ele diz que valor inválido para StopLoss. Mas o StopLoss está ValorMercado.Bid - 100 pontos.... então deveria passar. Vejam esse último erro por exemplo:

o código:

void Compra()
{

   if(CheckMoneyForTrade(_Symbol,1,ORDER_TYPE_BUY))
   {
      if(SemPosicao() && SemOrdem())
      {
         SLFinal=100;
         TPFinal=50;
         double price=simbolo.Bid();
         double stoploss=NormalizeDouble(simbolo.NormalizePrice(price - SLFinal),0);
         double takeprofit=NormalizeDouble(simbolo.NormalizePrice(price + TPFinal),0);
         negocio.Buy(Volume, NULL, price, stoploss, takeprofit, "Compra");
      }
   }
}

o erro na Validação do Market:



Obrigado,

 
Ruy Christian Hoffmann:

Olá pessoal,


Depois de dezenas de tentativas tentando colocar hoje um update do meu EA no Market do MT5 e dando erros variados, acho que está com algum probleminha. Colegas Moderadores poderiam ajudar e dar uma checadinha se está com algum problema o processo de Validação? Ou se alteraram alguma coisa?

Já tentei até com EA que foi aprovado no Market em fevereiro/2020 e desta vez não passou, botei umas linhas em branco e mudei a versão para ele entender como se fosse um "novo" EA mesmo assim ele dá uns erros que antes não dava.

Por fim ainda criei um "TesteHomologação" que não tem setup algum, ele apenas verifica se tem saldo na conta e abre um compra a mercado com 50 pontos de TP e 100 pontos de SL, sem filtro de papel, período ou outra coisa que estivesse fora das regras de validação, mesmo assim foi barrado com erros desconexos ao EA, 

Alguém mais está tendo problemas?

Vou postar apenas o último erro, mas cada tentativa dá erros variados sem conexão com o código, Esse último por exemplo, ele diz que valor inválido para StopLoss. Mas o StopLoss está ValorMercado.Bid - 100 pontos.... então deveria passar. Vejam esse último erro por exemplo:

o código:

o erro na Validação do Market:



Obrigado,

Olá Ruy,


Realmente o valor do Take esta incorreto, obeserve que ele está lançando 51.000000 e stop loss em -99,0000000.


aparentemente vc não esta considerando as casas decimais, eu faço a conversão para pontos e depois faço o calculo, essa forma funciona para qualquer mercado, seja indice, ações e forex, independente de quantas casas decimais tem.



double CSymbol::NormalizePrice(const double price) const
  {
     if(m_tick_size!=0)
      return(NormalizeDouble(MathRound(price/m_tick_size)*m_tick_size,m_digits));
//---
   return(round(NormalizeDouble(price,m_digits)));
  }

double CSymbol::PriceStep(void)
{
   double price = SymbolInfoDouble(m_symbol, SYMBOL_POINT);
   return price;
}

para usar faço assim:

double targetTake=WS.NormalizePrice(pos.EntryPrice()+WS.PriceStep()*GetObjetivo());
Onde o GetObjetivo() é um metodo que me retorna o valor do take e stop.

 
Jonathan Pereira:

Olá Ruy,


Realmente o valor do Take esta incorreto, obeserve que ele está lançando 51.000000 e stop loss em -99,0000000.


aparentemente vc não esta convertendo o valor em pontos, eu faço a conversão para ponto e depois faço o calculo, essa forma funciona para qualquer mercado, seja indice, ações e forex.


para usar faço assim:

Onde o GetObjetivo() é um metodo que me retorna o valor do take e stop.

Oi Jonathan, vou fazer aqui e testar agora e te falo, mas creio que não deve ser isso não, pois só esse EA ai ele já está na versão 1.9, ou seja, tiveram mais 8 versões passadas que já publiquei sem mexer uma vírgula nas instruções de compra/venda. Mas farei agora e já te falo.

Obrigado.

 

Jonathan,

Fiz, parou de dar o erro no stop mas está dando outro erro, diz que não tem operação, também que está fora do range..... O bicho tá sem setup algum, entra e vai direto para compra, só verifica se tem saldo e se já tem uma posição aberta, nada mais. Deve estar com algum problema lá na Validação, sei não o que está acontecendo. Algum Moderador poderia dar uma checada para nós né.

 
Outra coisa Jonathan, se puder mostra os valores do "/m_tick_size)*m_tick_size,m_digits))" para eu verificar se eu entendi certo a divisão depois a multiplicação. Vai que errei nesse cálculo.
 
Ruy Christian Hoffmann:
Outra coisa Jonathan, se puder mostra os valores do "/m_tick_size)*m_tick_size,m_digits))" para eu verificar se eu entendi certo a divisão depois a multiplicação. Vai que errei nesse cálculo.
   //declaração em private na classe CSymbol
   double            m_tick_size;     // symbol tick size
   int               m_digits;        // symbol digits


// icializo no construtor da classe
CSymbol::CSymbol(void) : m_digits(0.0), m_tick_size(0.0)
{
   m_symbol = ::Symbol();
   m_period = ::Period();
   InitSeries(Symbol(), ::Period());
}

//+------------------------------------------------------------------+
//| Refresh cached data                                              |
//+------------------------------------------------------------------+
bool CSymbol::Refresh(void)
  {
   long tmp=0;
//---
   if(!SymbolInfoDouble(m_symbol,SYMBOL_TRADE_TICK_SIZE,m_tick_size))
      return(false);
    if(!SymbolInfoInteger(m_symbol,SYMBOL_DIGITS,tmp))
      return(false);
   m_digits=(int)tmp;
//--- succeed
   return(true);
  }



o que tem na linha 469?

 
Jonathan Pereira:



o que tem na linha 469?

469 seria onde antes tinha meu setup, mas apaguei tudo antes de compilar e enviar, deixei ele apenas para entrar Comprado que você viu lá acima. Vou até colar o código todo aqui, já que não tem setup algum, veja só:



Vou até colar o código todo, pois sai apagando tudo, apaguei a estratégia (meus setups), breakeven, stopmovel, etc etc etc... deixei apenas o básico.

//+------------------------------------------------------------------+
//|                                           Ruy Christian Hoffmann |
//|                   Copyright 2020, Http://www.empireinvest.com.br |
//|                                       cursos@empireinvest.com.br |
//+------------------------------------------------------------------+
#property copyright "Ruy Christian Hoffmann"
#property link      "http//www.empireinvest.com.br"
#property version   "1.9"
#property description "EmpireInvestBot 700"
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+

#include <Trade/Trade.mqh>
#include <Trade/SymbolInfo.mqh>

//+------------------------------------------------------------------+
//|                                                Lib CisNewBar.mqh |
//|                                            Copyright 2010, Lizar |
//|                                               Lizar-2010@mail.ru |
//|                                              Revision 2010.09.27 |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Class CisNewBar.                                                 |
//| Appointment: Class with methods of detecting new bars            |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CisNewBar
{
protected:
   datetime          m_lastbar_time;   // Time of opening last bar

   string            m_symbol;         // Symbol name
   ENUM_TIMEFRAMES   m_period;         // Chart period

   uint              m_retcode;        // Result code of detecting new bar
   int               m_new_bars;       // Number of new bars
   string            m_comment;        // Comment of execution

public:
   void              CisNewBar();      // CisNewBar constructor
   //--- Methods of access to protected data:
   uint              GetRetCode() const      {return(m_retcode);     }  // Result code of detecting new bar
   datetime          GetLastBarTime() const  {return(m_lastbar_time);}  // Time of opening new bar
   int               GetNewBars() const      {return(m_new_bars);    }  // Number of new bars
   string            GetComment() const      {return(m_comment);     }  // Comment of execution
   string            GetSymbol() const       {return(m_symbol);      }  // Symbol name
   ENUM_TIMEFRAMES   GetPeriod() const       {return(m_period);      }  // Chart period
   //--- Methods of initializing protected data:
   void              SetLastBarTime(datetime lastbar_time) {m_lastbar_time=lastbar_time;                            }
   void              SetSymbol(string symbol)             {m_symbol=(symbol==NULL || symbol=="")?Symbol():symbol;  }
   void              SetPeriod(ENUM_TIMEFRAMES period)    {m_period=(period==PERIOD_CURRENT)?Period():period;      }
   //--- Methods of detecting new bars:
   bool              isNewBar(datetime new_Time);                       // First type of request for new bar
   int               isNewBar();                                        // Second type of request for new bar
};

CisNewBar current_chart; // instance of the CisNewBar class: current chart

int VLimitador = 40; //Usado como algum Limitador ou Incrementador no decorrer do código
int VLimitador2 = 10; //Usado como algum Limitador ou Incrementador no decorrer do código
double SL = 100.0; //Stop Loss. OBS: É dividido por 2 quando atinge o "Descendo" (BarrasInvertidasLimite)
double TP = 30.0; //Take Profit
double SLFinal=SL;
double TPFinal=TP;
input double Volume = 1; //Volume;
string inicio = "9:13"; //Horário de Início (entrada)
string termino = "16:31"; //Horário de término (entradas)
string fechamento = "17:40"; //Horário fechamento (stop final)
int VMin = 1; //Minutos para evitar duplicidade no mesmo minuto;
int VBreakEven = 110; //BreakEven = ponto zero
int VBreakEvenIncremento=35; //Incremento da posição do BreakEven;
int VPBlow=0;
int VPBhigh=0;
int VPBclose=0; //VPB = Variável Primeira Barra
int VPBopen=0;
int VB1close=0;
int VB0open=0;
int VPrice=0;
int VTopo=0;
int VFundo=0;
int VSM= 95; //Stop Móvel = ponto zero
int VSMI=10; //Incremento da posição do Stop Movel;
int VBreakEvenAtivo=0;  //0=não 1=sim
int VCompraOk=0;
int VVendaOk=0;

CTrade negocio;
CSymbolInfo simbolo;

MqlDateTime horario_inicio, horario_termino, horario_fechamento, horario_atual;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnInit()
{
//---

   //Print("Este Robô abre novas Ordens entre 9:08h até 16:31h");
   //Print("Você configurou para utilizar essa quantidade de Contratos: ",Volume);

   /*
   // INI: CÓDIGO DE PROTEÇÃO - Ruy Hoffmann - 15-11-2019
      bool     prototipo=false;               // true só roda em demo, false conta real
      long     account=2001330980;           // Account login Bruno - EmpireGames
      long     periodo_licenca=31;           // Qtd dias licença

      datetime dt_expiracao=__DATE__+PeriodSeconds(PERIOD_D1)*periodo_licenca;                   // Data de expiração

      ENUM_ACCOUNT_TRADE_MODE tradeMode=(ENUM_ACCOUNT_TRADE_MODE)AccountInfoInteger(ACCOUNT_TRADE_MODE);

      if(prototipo)
        {
         if(tradeMode==ACCOUNT_TRADE_MODE_REAL)
           {
            Alert(__FUNCTION__,": Licença somente para conta DEMO");
            return(INIT_FAILED);
           }
         dt_expiracao=__DATE__+PeriodSeconds(PERIOD_D1)*31; // Expira 31 dias após a compilação (Vcto: 30/12/2019)
         if(TimeCurrent()>dt_expiracao)
           {
            Alert(__FUNCTION__,": licença DEMO expirada");
            return(INIT_FAILED);
           }
        }

      if(!prototipo)
        {
         if(AccountInfoInteger(ACCOUNT_LOGIN)!=account)
           {
            Alert(__FUNCTION__,": Login não autorizado");
            return(INIT_FAILED);
           }
         if(TimeCurrent()>dt_expiracao)
           {
            Alert(__FUNCTION__,": Licença expirada");
            return(INIT_FAILED);
           }
        }
   //FIM: CÓDIGO DE PROTEÇÃO - Ruy Hoffmann - 15-11-2019
   */

//INI: Botão "ENCERRAR ROBÔ" - Ruy Hoffmann 21-11-2019 - Etapa 1 de 4
   ObjectCreate(0,"CloseButton",OBJ_BUTTON,0,0,0);
   ObjectSetInteger(0,"CloseButton",OBJPROP_XDISTANCE,25);
   ObjectSetInteger(0,"CloseButton",OBJPROP_YDISTANCE,100);
   ObjectSetInteger(0,"CloseButton",OBJPROP_XSIZE,150);
   ObjectSetInteger(0,"CloseButton",OBJPROP_YSIZE,50);

   ObjectSetString(0,"CloseButton",OBJPROP_TEXT,"STOP EIBot 700");

   ObjectSetInteger(0,"CloseButton",OBJPROP_COLOR, White);
   ObjectSetInteger(0,"CloseButton",OBJPROP_BGCOLOR, Red);
   ObjectSetInteger(0,"CloseButton",OBJPROP_BORDER_COLOR,Red);
   ObjectSetInteger(0,"CloseButton",OBJPROP_BORDER_TYPE,BORDER_FLAT);
   ObjectSetInteger(0,"CloseButton",OBJPROP_BACK,false);
   ObjectSetInteger(0,"CloseButton",OBJPROP_HIDDEN,true);
   ObjectSetInteger(0,"CloseButton",OBJPROP_STATE,false);
   ObjectSetInteger(0,"CloseButton",OBJPROP_FONTSIZE,12);
//FIM: Botão "ENCERRAR ROBÔ" - Ruy Hoffmann 21-11-2019 - Etapa 1 de 4

   if(!simbolo.Name(_Symbol))
   {
      printf("Ativo Inválido!");
      return INIT_FAILED;
   }

   //if(Period()!=6)
   //{
   //   Print("Este Robô só funciona em 6 minutos (M6) do Indice WINxxx");
   //   return INIT_FAILED;
   //}

   TimeToStruct(StringToTime(inicio), horario_inicio); //StringToTime passa o texto hora para "datetime". E o
//StringToStruct passa o "datetime" para MqlDateTime
//associando a variária horario_inicio já definida anteriormente.
   TimeToStruct(StringToTime(termino), horario_termino);
   TimeToStruct(StringToTime(fechamento), horario_fechamento);

   if(horario_inicio.hour>horario_termino.hour || (horario_inicio.hour==horario_termino.hour && horario_inicio.min>horario_termino.min))
   {
      printf("Horários inválidos");
      return INIT_FAILED;
   }

   if(horario_termino.hour>horario_fechamento.hour || (horario_termino.hour==horario_fechamento.hour && horario_termino.min>horario_fechamento.min))
   {
      printf("Horários inválidos");
      return INIT_FAILED;
   }


//---
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//---
   printf("Deinit reason: %d", reason);

//INI: Botão "ENCERRAR ROBÔ" - Ruy Hoffmann 21-11-2019 - Etapa 2 de 4
   ObjectDelete(0,"CloseButton");
//FIM: Botão "ENCERRAR ROBÔ" - Ruy Hoffmann 21-11-2019 - Etapa 2 de 4

}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
//INI: Barra-em-Barra
   int period_seconds=PeriodSeconds(_Period);                     // Number of seconds in current chart period
   datetime new_time=TimeCurrent()/period_seconds*period_seconds; // Time of bar opening on current chart
   if(current_chart.isNewBar(new_time))               // When new bar appears - launch the NewBar event handler
   {
      if(!simbolo.RefreshRates())
         return;
      
      if(SemPosicao() && !SemOrdem())
         PendingOrderDelete(); 

      if(HorarioFechamento())
      {
         if(!SemPosicao())
         {
            Fechar();
            VMin=horario_atual.min;
         }
      }
      //      PendingOrderDelete();

      if(HorarioEntrada() && !HorarioFechamento())
      {
         if(SemPosicao())
         {
            int resultado_cruzamento=Cruzamento();
            if(resultado_cruzamento==1)
            {
               Compra();
               VMin=horario_atual.min;
            }
            //if(resultado_cruzamento==-1)
            //{
            //   Venda();
            //   VMin=horario_atual.min;
            //}
         }
      }

      if(HorarioFechamento())
      {
         if(!SemPosicao())
         {
            Fechar();
            VMin=horario_atual.min;
         }
      }

   }
//FIM: Barra-em-Barra

}

//INI: Botão "ENCERRAR ROBÔ" - Ruy Hoffmann 21-11-2019 - Etapa 3 de 4
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
{
   if(sparam== "CloseButton")
   {
      CloseAllOpenPositions();
      ObjectSetInteger(0,"CloseButton",OBJPROP_STATE,false);
      ExpertRemove();
   }
}
//FIM: Botão "ENCERRAR ROBÔ" - Ruy Hoffmann 21-11-2019 - Etapa 3 de 4


//INI: CRIAÇÃO DAS FUNÇÕES:
//INI: Botão "ENCERRAR ROBÔ" - Ruy Hoffmann 21-11-2019 - Etapa 4 de 4
void CloseAllOpenPositions()
{
   int i=PositionsTotal()-1;
   while(i>=0)
   {
      if(negocio.PositionClose(PositionGetSymbol(i)))
         i--;
   }
}
//FIM: Botão "ENCERRAR ROBÔ" - Ruy Hoffmann 21-11-2019 - Etapa 4 de 4



//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool HorarioEntrada()
{
   datetime tm=(datetime)SymbolInfoInteger(_Symbol,SYMBOL_TIME);
   TimeToStruct(tm,horario_atual); //Define a varíavel horário_atual para o horário atual do sistema em formato datetime

   if(horario_atual.hour>horario_inicio.hour && horario_atual.hour<horario_termino.hour)
      return true;

   if(horario_atual.hour==horario_inicio.hour && horario_atual.min>=horario_inicio.min)
      return true;

   if(horario_atual.hour==horario_termino.hour && horario_atual.min<=horario_termino.min && horario_atual.min!=0)
      return true;

   return false;
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool HorarioFechamento()
{
   datetime tm=(datetime)SymbolInfoInteger(_Symbol,SYMBOL_TIME);
   TimeToStruct(tm,horario_atual); //Define a varíavel horário_atual para o horário atual do sistema em formato datetime

   if(horario_atual.hour>horario_fechamento.hour)
      return true;

   if(horario_atual.hour==horario_fechamento.hour && horario_atual.min>=horario_fechamento.min)
      return true;

   return false;
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Compra()
{

   if(CheckMoneyForTrade(_Symbol,1,ORDER_TYPE_BUY))
   {
      if(SemPosicao() && SemOrdem())
      {
         SLFinal=1;
         TPFinal=1;
         double price=simbolo.Bid();
         double stoploss=NormalizeDouble(simbolo.NormalizePrice(price - SLFinal),0);
         double takeprofit=NormalizeDouble(simbolo.NormalizePrice(price + TPFinal),0);
         negocio.Buy(Volume, NULL, price, stoploss, takeprofit, "Compra");
      }
   }
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//void Venda()
//{
//
//   if(CheckMoneyForTrade(_Symbol,1,ORDER_TYPE_SELL))
//   {
//      if(SemPosicao() && SemOrdem())
//      {
//
//         double price=simbolo.Ask();
////         double price=VPrice;
//         double stoploss=NormalizeDouble(simbolo.NormalizePrice(price + SLFinal),0);
//         double takeprofit = NormalizeDouble(simbolo.NormalizePrice(price - TPFinal),0);
//         negocio.Sell(Volume, NULL, price, stoploss, takeprofit, "Venda");
//      }
//   }
//}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Fechar()
{
   if(!PositionSelect(_Symbol))
      return;

   long tipo = PositionGetInteger(POSITION_TYPE);
   if(tipo == POSITION_TYPE_BUY)
      negocio.Sell(Volume, NULL, 0, 0, 0, "Fechamento Cruzamento");
   else
      negocio.Buy(Volume,NULL, 0, 0, 0, "Fechamento Cruzamento");

   PendingOrderDelete();

//     Alert("O Servidor acusa 17:43h. O Robô foi desligado");
//     ExpertRemove();
}


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool SemPosicao()
{
   return !PositionSelect(_Symbol); //Retorna Verdadeiro se não houver posição em Aberto
}


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool SemOrdem()
{
   if(OrdersTotal()>0)
      return false;
   else
      return true;
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PendingOrderDelete()
{
   int o_total=OrdersTotal();
   for(int j=o_total-1; j>=0; j--)
   {
      ulong o_ticket = OrderGetTicket(j);
      if(o_ticket != 0)
      {
         // delete the pending order
         negocio.OrderDelete(o_ticket);
         Print("Pending order deleted sucessfully!");
      }
   }
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

//FIM: CRIAÇÃO DAS FUNÇÕES:


//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Cruzamento()
{
  
   string VVerify="Neutra";
 
 
            VVerify="Abaixo";
      

   //SINAL DE COMPRA
   if(VVerify=="Acima")
      return 1;

      
   return 0;
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CheckMoneyForTrade(string symb,double lots,ENUM_ORDER_TYPE type)
  {
//--- obtemos o preço de abertura
   MqlTick mqltick;
   SymbolInfoTick(symb,mqltick);
   double price=mqltick.ask;
   if(type==ORDER_TYPE_SELL)
      price=mqltick.bid;
//--- valores da margem necessária e livre
   double margin,free_margin=AccountInfoDouble(ACCOUNT_MARGIN_FREE);
//--- chamamos a função de verificação
   if(!OrderCalcMargin(type,symb,lots,price,margin))
   {
      //--- algo deu errado, informamos e retornamos false
      Print("Error in ",__FUNCTION__," code=",GetLastError());
      return(false);
   }


//--- se não houver fundos suficientes para realizar a operação

      if(margin>free_margin)
        {

         //--- informamos sobre o erro e retornamos false
         Print("Not enough money for ",EnumToString(type)," ",lots," ",symb," Error code=",GetLastError());
         return(false);
        }

//--- a verificação foi realizada com sucesso
   return(true);
}


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+


//+------------------------------------------------------------------+
//| CisNewBar constructor.                                           |
//| INPUT:  no.                                                      |
//| OUTPUT: no.                                                      |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
void CisNewBar::CisNewBar()
{
   m_retcode=0;         // Result code of detecting new bar
   m_lastbar_time=0;    // Time of opening last bar
   m_new_bars=0;        // Number of new bars
   m_comment="";        // Comment of execution
   m_symbol=Symbol();   // Symbol name, by default - symbol of current chart
   m_period=Period();   // Chart period, by default - period of current chart
}

//+------------------------------------------------------------------+
//| First type of request for new bar                     |
//| INPUT:  newbar_time - time of opening (hypothetically) new bar|
//| OUTPUT: true   - if new bar(s) has(ve) appeared                  |
//|         false  - if there is no new bar or in case of error      |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
bool CisNewBar::isNewBar(datetime newbar_time)
{
//--- Initialization of protected variables
   m_new_bars = 0;      // Number of new bars
   m_retcode  = 0;      // Result code of detecting new bar: 0 - no error
   m_comment  =__FUNCTION__+" Successful check for new bar";
//---

//--- Just to be sure, check: is the time of (hypothetically) new bar m_newbar_time less than time of last bar m_lastbar_time?
   if(m_lastbar_time>newbar_time)
   {
      // If new bar is older than last bar, print error message
      m_comment=__FUNCTION__+" Synchronization error: time of previous bar "+TimeToString(m_lastbar_time)+
                ", time of new bar request "+TimeToString(newbar_time);
      m_retcode=-1;     // Result code of detecting new bar: return -1 - synchronization error
      return(false);
   }
//---

//--- if it's the first call
   if(m_lastbar_time==0)
   {
      m_lastbar_time=newbar_time; //--- set time of last bar and exit
      m_comment   =__FUNCTION__+" Initialization of lastbar_time = "+TimeToString(m_lastbar_time);
      return(false);
   }
//---

//--- Check for new bar:
   if(m_lastbar_time<newbar_time)
   {
      m_new_bars=1;               // Number of new bars
      m_lastbar_time=newbar_time; // remember time of last bar
      return(true);
   }
//---

//--- if we've reached this line, then the bar is not new; return false
   return(false);
}

//+------------------------------------------------------------------+
//| Second type of request for new bar                     |
//| INPUT:  no.                                                      |
//| OUTPUT: m_new_bars - Number of new bars                          |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
int CisNewBar::isNewBar()
{
   datetime newbar_time;
   datetime lastbar_time=m_lastbar_time;

//--- Request time of opening last bar:
   ResetLastError(); // Set value of predefined variable _LastError as 0.
   if(!SeriesInfoInteger(m_symbol,m_period,SERIES_LASTBAR_DATE,newbar_time))
   {
      // If request has failed, print error message:
      m_retcode=GetLastError();  // Result code of detecting new bar: write value of variable _LastError
      m_comment=__FUNCTION__+" Error when getting time of last bar opening: "+IntegerToString(m_retcode);
      return(0);
   }
//---

//---Next use first type of request for new bar, to complete analysis:
   if(!isNewBar(newbar_time))
      return(0);

//---Correct number of new bars:
   m_new_bars=Bars(m_symbol,m_period,lastbar_time,newbar_time)-1;

//--- If we've reached this line - then there is(are) new bar(s), return their number:
   return(m_new_bars);
}
EmpireInvest
  • Ruy Christian Hoffmann
  • www.empireinvest.com.br
EmpireInvest - Automação o futuro do investidor
 

Esse bicho tá querendo me deixar doido... onde ele tá tentando fazer um SELL se eu desativei todas as VENDAS?????



ele está criando um SELL para teste, mas fora do bloco     if(CheckMoneyForTrade(_Symbol,1,ORDER_TYPE_SELL)), pois eh onde eu faço a checagem do saldo. E dentro dele só deixei o BUY ativo! kkkk esse cabra vai me deixar doido!

Preciso descobrir onde ele tá testando esse SELL para eu poder colocar dentro do bloco CheckMoneyForTrade.

 
Ruy Christian Hoffmann:

Esse bicho tá querendo me deixar doido... onde ele tá tentando fazer um SELL se eu desativei todas as VENDAS?????



ele está criando um SELL para teste, mas fora do bloco     if(CheckMoneyForTrade(_Symbol,1,ORDER_TYPE_SELL)), pois eh onde eu faço a checagem do saldo. E dentro dele só deixei o BUY ativo! kkkk esse cabra vai me deixar doido!

Preciso descobrir onde ele tá testando esse SELL para eu poder colocar dentro do bloco CheckMoneyForTrade.

Ruy, rodei o codigo aqui aparentemente tudo ok, mas diante desse erro ai acima, eu colocaria um lote de 0.01. Mas isso é pura "tentativa e erro"


outra ideia é, coloque um método de compra e venda, acho que a ideia dessa validação é estressar alguns pontos como checagem de margem e consumo de memoria.

Mas realmente bem estranho, pois eu rodei em back test aqui o codigo em EURUSD M1 como esta na imagem e não abre ordem.

 
Jonathan Pereira:

Ruy, rodei o codigo aqui aparentemente tudo ok, mas diante desse erro ai acima, eu colocaria um lote de 0.01. Mas isso é pura "tentativa e erro"


outra ideia é, coloque um método de compra e venda, acho que a ideia dessa validação é estressar alguns pontos como checagem de margem e consumo de memoria.

Mas realmente bem estranho, pois eu rodei em back test aqui o codigo em EURUSD M1 como esta na imagem e não abre ordem.

Jonathan, acho que estamos quase chegando lá.

Eu fiz o seguinte, tirei o evento "barra em barra", apenas desativei essas linhas abaixo e dai passou... mas mesmo assim tenho que achar uma solução no meu EA que tem o Setup.

Mas uma coisa já evoluiu, que foi saber que ele não está conseguindo fazer todas as validações dentro do meu evento de barra-a-barra (IsNewBar).

Agora preciso achar uma solução de liberar o Validador de fazer seus  testes mas sem tirar meu barra-a-barra.

Eu teria uma saída mas não é a correta e que não quero utilizar a princípio. Se eu colocar um if no OnTick() direcionando para um evento de compra/venda com stop de 1 ponto e tp de 1 ponto, ele passa na Validação e não vai executar essa ordem em mercado brasileiro porque está inferior ao limite mínimo (25 pontos). Mas isso seria ruim, capenga um baita remendo coisa feia, vai ficar gerando ordem cancelada no mercado brasileiro, reportando erro no Diário, enfim, não é a saída viável. Mas para testes eu fiz e deu certo. Com isso consegui isolar que o problema está exatamente no bloco IsNewBar que é onde tem meus Setups e finaliza na Compra ou Venda.

O que mais me intriga é que isolei a venda, estão todas as linhas em comentários desativadas, para estreitar a depuração, mas mesmo assim você viu na imagem acima que ele abre um teste de sell? interessante! onde esse cabra faz isso que não sei. Se soubesse seria muito mais simples de achar o problema.

 

Olá,

já que você está trabalhando com FOREX,  vou dar meu pitaco, faz a mesma alteração para venda.

OBS:

Faz uso da classe CSymbolInfo,

O preço na ordem funciona para ordens a mercado e ordens imediata e neste caso o requote tem que ser testado.

Digitei direto então deve ter algum erro de sintaxe.


if(CheckMoneyForTrade(_Symbol,1,ORDER_TYPE_BUY))
   {
      if(SemPosicao() && SemOrdem())
      {
         SLFinal= (inpStopLoss * _Point);       //  inpStopLoss  ==>  input double inpStopLoss=50;  // Stop loss in points
         TPFinal= (inpTakeProfit * _Point);     //   .................

         double price=cSymbol.Ask();
	 
         double stoploss=(inpStopLoss<cSymbol.StopsLevel()) ? cSymbol.NormalizePrice(price-cSymbol.StopsLevel()) :  cSymbol.NormalizePrice(price-SLFinal);
         double takeprofit=(inpTakeProfit < cSymbol.StopsLevel())? cSymbol.NormalizePrice(price+cSymbol.StopsLevel()) : cSymbol.NormalizePrice(price+TPFinal);

         negocio.Buy(Volume, _Symbol, price, stoploss, takeprofit, "Compra");
      }
   }
Razão: