erro INVALIDE PRICE como resolver WIN$N

felipe ramos 2022.02.06 04:37

ESTOU QUERENDO UTILIZAR ESSA FUNCAO DE GRAFICO DE RENKO NO EA , COLOQUEI MAIS ESTA DANDO ESSE ERRO

SIMBOLO WIN$N

//+------------------------------------------------------------------+
//|               T                                       ProjectName |
//|          cruzamento das media normal  Copyright 2020, CompanyName |
//|      novamente                                 http://www.companyname.net |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
#include <RenkoCharts.mqh>

CTrade trade;
RenkoCharts *RenkoOffline;

#property copyright "lipe Ramos - BotTeste"
#property link "BotTeste.com.br"
#property version "1.00"
#property description "Última atualização em 22/Junho/2021"
#property description " "
#property description "Este expert é constituído sem o uso de bibliotecas padrões do meta trader"
#property description "Todos os recursos são adaptados para uma melhor perfomance"
#property description "Este modelo funciona tanto para contas HEDGINGS quanto para NETTINGS"
#property description "Entradas e saídas são sempre utilizando ordens limitadas para garantir melhor preço na B3"
#property description "Se existir distância mínima para ordem pendente esta é ajustada automaticamente"
#property description "Em contas HEDGINGS a saída é fechada utilizando a posição inversa"
//____________________________________________________________________________
//---Enumerador para o tipo de  validade da ordem
//____________________________________________________________________________
//____________________________________________________________________________
//========================================================================
enum e_time
  {
   es_gtc = ORDER_TIME_GTC, // Até cancelar
   es_day = ORDER_TIME_DAY // Hoje
  };
//____________________________________________________________________________
//____________________________________________________________________________
//---Enumerador para o tipo de true e false para sim e não
//____________________________________________________________________________
//____________________________________________________________________________
//========================================================================
enum e_sn
  {
   nao = 0, // Não
   sim = 1 // Sim
  };
//____________________________________________________________________________
//____________________________________________________________________________
//---Enumerador para o tipo de  preenchimento
//____________________________________________________________________________
//____________________________________________________________________________
//========================================================================
enum e_filling
  {
   es_fok = ORDER_FILLING_FOK, // Fok
   es_ioc = ORDER_FILLING_IOC, // Ioc
   es_return = ORDER_FILLING_RETURN // Return
  };

//____________________________________________________________________________
//____________________________________________________________________________
//========================================================================
//---ESTRUTURA PARA ARMAZENAR OS DADOS DAS POSIçõES ABERTAS
//____________________________________________________________________________
//____________________________________________________________________________
struct s_posicoes
  {
   double            volume; // Lot
   double            lucro; // Lucro real da posição aberta, referente ao verdadeiro preço de saída
   datetime          abertura; // Horário que se inicio a posição
   ulong             ticket_compra; // Bilhete da posição se for de compra
   ulong             ticket_venda; // Bilhete da posição de venda se existir ambas simultanemanetes, são fechadas entre si
  };
//____________________________________________________________________________
//____________________________________________________________________________
//========================================================================
//---ESTRUTURA PARA ARMAZENAR OS DADOS DAS ORDENS PENDENTES
//____________________________________________________________________________
//____________________________________________________________________________
struct s_ordens
  {
   ulong             compra_limit; // Número que corresponderá a uma ordem de compra pendente
   ulong             venda_limit; // Para venda pendente (ordem limitada)
  };

//____________________________________________________________________________
//____________________________________________________________________________
input group              "[● Configurações -  CONFIGURAÇÃO INICIAL ●]"
sinput string                    in_nome =      " BOT TESTE"; // Nome do expert
sinput ulong                     magicNum = 123456;//Magic Number
sinput ulong                     desvPts = 0;//Desvio em Pontos
sinput e_filling                 preenchimento = es_return; // Tipo de preenchimento
input ENUM_TIMEFRAMES            in_timeframe = PERIOD_CURRENT; // Tempo gráfico do EA

//____________________________________________________________________________
input group              "[● LOTES /TAKE /STOPS ●]"
sinput int                       lote = 1;//Volume
input double                     stopLoss = 20;//Stop Loss
input double                     takeProfit = 0;//Take Profit
//____________________________________________________________________________
//____________________________________________________________________________
input group              "[● REGRAS DE HORÁRIOS ●]"
input e_sn                       in_hab_hora = true; // Habilitar verificação de horários
input string                     in_iniciar = "09:00"; // Horário de iniciar (novas posições)
input string                     in_parar = "17:00"; // Horário de parar (novas posições)
input e_sn                       in_hab_zerar = true; // Habilitar zeragem compulsória
input string                     in_zerar = "17:33"; // Horário de zeragem (compulsória)
//____________________________________________________________________________
//____________________________________________________________________________
input group              "[● ADICIONAL ●]"
input e_sn                       in_barra_atual = true; // Impedir novas entradas na mesma barra
input e_sn                       saidaOperacao = true; // saida das operaçoes
sinput e_time                    in_validade = es_day; // Validade da ordem
input e_sn                       in_cancel_sinal = true; // Atualizar pendente a cada sinal
sinput double                    in_spread = 0; // Spread máximo (ticks)(0=off)
sinput e_sn                      in_hab_painel = true; // Habilitar painel gráfico
sinput e_sn                      in_hab_indicadores = true; // Inserir indicadores
//____________________________________________________________________________

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
input string            RenkoSymbol    = "WIN$N";                   // Symbol (Default = current)
input ENUM_RENKO_TYPE   RenkoType      = RENKO_TYPE_TICKS;     // Modelo
input double            RenkoSize      = 20;                   // Tamanho do tijolo(Ticks, Pips or Points)
input bool              RenkoWicks     = true;                 // Mostrar mechas
input bool              RenkoTime      = true;                 // Tempo aberto do tijolo
input bool              RenkoAsymetricReversal = false;        // Reversões Assimétricas
input ENUM_RENKO_WINDOW RenkoWindow    = RENKO_CURRENT_WINDOW; // Modo de gráfico
input int               RenkoTimer     = 300;                 // Temporizador em milissegundos (0 = Off)
input bool              RenkoBook      = true;                 // Assista ao livro do mercado

//____________________________________________________________________________
//____________________________________________________________________________
double                        PRC=0;//Preço normalizado
double                        STL=0;//StopLoss normalizado
double                        TKP=0;//TakeProfit normalizado
bool                             buy = true;
bool                             sell = true;

//____________________________________________________________________________
//____________________________________________________________________________
string original_symbol;
string custom_symbol;
bool _DebugMode = (MQL5InfoInteger(MQL5_TESTER) || MQL5InfoInteger(MQL5_DEBUG) || MQL5InfoInteger(MQL5_DEBUGGING) || MQL5InfoInteger(MQL5_OPTIMIZATION) || MQL5InfoInteger(MQL5_VISUAL_MODE) || MQL5InfoInteger(MQL5_PROFILER));


MqlTick                          ultimoTick;
MqlRates                         rates[];
MqlDateTime                      hora_iniciar, hora_parar, hora_zerar, hora_atual; // Estruturas de horários
//========================================================================
//========================================================================
//---INIÇIAÇAO DO ROBO
//========================================================================
//========================================================================
int OnInit()
  {
   ResetLastError();
   Comment("");
   ChartSetSymbolPeriod(0,_Symbol,in_timeframe); // Força que o tempo gráfico da janela do robô fique no escolhido

   if(!MarketBookAdd(_Symbol))
      return(INIT_FAILED);

//Check Symbol
   original_symbol = StringAt(_Symbol, "_");
   if(RenkoSymbol != "")
      original_symbol = RenkoSymbol;
//Check Period
   if(RenkoWindow == RENKO_CURRENT_WINDOW && ChartPeriod(0) != PERIOD_M1)
     {
      Print("Renko must be M1 period!", __FILE__, MB_OK);
      ChartSetSymbolPeriod(0, original_symbol, PERIOD_M1);
      return(INIT_SUCCEEDED);
     }
//Setup Renko
   if(RenkoOffline == NULL)
      if((RenkoOffline = new RenkoCharts()) == NULL)
        {
         MessageBox("Renko create class error. Check error log!", __FILE__, MB_OK);
         return(INIT_FAILED);
        }
   if(!RenkoOffline.Setup(original_symbol, RenkoType, RenkoSize, RenkoWicks, RenkoTime, RenkoAsymetricReversal))
     {
      MessageBox("Renko setup error. Check error log!", __FILE__, MB_OK);
      return(INIT_FAILED);
     }
//Create Custom Symbol
   RenkoOffline.CreateCustomSymbol();
   RenkoOffline.ClearCustomSymbol();
   custom_symbol = RenkoOffline.GetSymbolName();
//Load History
   RenkoOffline.UpdateRates();
   RenkoOffline.ReplaceCustomSymbol();
//Start
   if(_DebugMode)
      RenkoOffline.Start(RENKO_CURRENT_WINDOW, RenkoTimer, RenkoBook);
   else
      RenkoOffline.Start(RenkoWindow, RenkoTimer, RenkoBook);
//Refresh
   RenkoOffline.Refresh();

   if(! ArraySetAsSeries(rates, true))
     {
      Print("PROBLEMA NO ARRAY rates ");
      return(INIT_FAILED);
     }

//____________________________________________________________________________
//____________________________________________________________________________

   trade.SetDeviationInPoints(desvPts);
   trade.SetExpertMagicNumber(magicNum);
//========================================================================
//========================================================================
//== Passando a referência de horário para o padrão correto
//========================================================================
//========================================================================
   TimeToStruct(StringToTime(in_iniciar),hora_iniciar);
   TimeToStruct(StringToTime(in_parar),hora_parar);
   TimeToStruct(StringToTime(in_zerar),hora_zerar);
//========================================================================
//========================================================================
//== Verifica se o horário de ínicio realmente antecede o horário máximo de abertura de posição
//========================================================================
//========================================================================
   if(hora_iniciar.hour > hora_parar.hour || (hora_iniciar.hour == hora_parar.hour && hora_iniciar.min >= hora_parar.min))
     {
      printf("[%s] Configuração de horários de entrada e parada inválidos",in_nome);
      return INIT_FAILED;
     }



   printf("[%s] ***** Expert Iniciado com sucesso",in_nome);
   printf("[%s] ***** Horários: Local %s Corretora %s",
          in_nome,TimeToString(TimeLocal(),TIME_SECONDS),TimeToString(TimeCurrent(),TIME_SECONDS));
   ChartRedraw();

   return(INIT_SUCCEEDED);
  }


//+------------------------------------------------------------------+
//| Timer Event                                                      |
//+------------------------------------------------------------------+
void OnTimer()
  {
   if(RenkoTimer>0)
      if(!MQL5InfoInteger(MQL5_TESTER) && !MQL5InfoInteger(MQL5_OPTIMIZATION))
         OnTick();
  }
//+------------------------------------------------------------------+
//========================================================================
//========================================================================
//== DESATIVAR O ROBO
//========================================================================
//========================================================================
void OnDeinit(const int motivo)
  {
   if(RenkoOffline!=NULL)
     {
      RenkoOffline.Stop();
      delete RenkoOffline;
      RenkoOffline=NULL;
     }
   ResetLastError();


   Comment("");

   ObjectsDeleteAll(0,"painel_",0,-1); // Remove o painel do gráfico, se existir

   printf("[%s] ***** Horários: Local %s Corretora %s",
          in_nome,TimeToString(TimeLocal(),TIME_SECONDS),TimeToString(TimeCurrent(),TIME_SECONDS));
   printf("[%s] ***** Expert desligado pelo motivo %d",in_nome,motivo);
   ArrayFree(rates);
   ZeroMemory(rates);                     // A liberação de memória dos indicadores pode ser mais lenta que na inicialização
// Se o EA for inserido enquanto ainda está o no porcesso de liberar mémoria, parte dos dados dos indicadores pode ser perdido
   Sleep(1000); // Por isso é necessário aguardar a remoção completa

  }


//+------------------------------------------------------------------+
//| Book Event                                                       |
//+------------------------------------------------------------------+
void OnBookEvent(const string& symbol)
  {
   if(RenkoBook)
      OnTick();
  }
//========================================================================
//========================================================================
//==EVENTO FUNÇAO TICK
//========================================================================
//========================================================================
void OnTick()
  {
   ResetLastError();




   if(!IsStopped())
      if(RenkoOffline!=NULL)
         RenkoOffline.Refresh();


//____________________________________________________________________________
//____________________________________________________________________________
   if(!SymbolInfoTick(Symbol(),ultimoTick))
     {
      Alert("Erro ao obter informações de Preços: ", GetLastError());
      return;
     }

   if(CopyRates(_Symbol, _Period, 0,100, rates)<0)
     {
      Alert("Erro ao obter as informações de MqlRates: ", GetLastError());
      return;
     }



   if(buy
      &&rates[1].close>rates[1].open


     )
     {

      if(comprar(stopLoss, takeProfit))
        {
         Print("Ordem de Compra - sem falha. ResultRetcode: ", trade.ResultRetcode(),
               ", RetcodeDescription: ", trade.ResultRetcodeDescription());
         buy=false;
         sell = true;



        }
      else
        {
         Print("Ordem de Compra - com falha. ResultRetcode: ", trade.ResultRetcode(),
               ", RetcodeDescription: ", trade.ResultRetcodeDescription());

        }

     }
   else
     {
      //____________________________________________________________________________
      //____________________________________________________________________________
      //
      if(sell
         &&rates[1].close<rates[1].open


        )
        {

         if(vender(stopLoss, takeProfit))

           {
            Print("Ordem de Venda - sem falha. ResultRetcode: ", trade.ResultRetcode(),
                  ", RetcodeDescription: ", trade.ResultRetcodeDescription());
            sell = false;
            buy=true;


           }
         else
           {
            Print("Ordem de Venda - com falha. ResultRetcode: ", trade.ResultRetcode(),
                  ", RetcodeDescription: ", trade.ResultRetcodeDescription());

           }

        }

     }

  }



//+------------------------------------------------------------------+
//| Envio de compra limitada |
//+------------------------------------------------------------------+
bool comprar(const double stop, const double take)
  {
// Austando na entrada o preço de acordo com o stoplevel mínimo permitido
   double price = check_stoplevel(SymbolInfoDouble(_Symbol,SYMBOL_ASK),ORDER_TYPE_BUY);
   double sl =(stop > 0.0) ? normalizar1(price-(stopLoss*_Point)) : 0.00; // Stoploss
   double tp =(take > 0.0) ? normalizar1(price+(takeProfit*_Point)) : 0.00; // Takeprofit

// Envio sempre de ordem pendente
   return realizar_negocio(TRADE_ACTION_PENDING,ORDER_TYPE_BUY_LIMIT,0,lote,price,sl,tp);
  }
//+------------------------------------------------------------------+
//| Envio de venda limitada |
//+------------------------------------------------------------------+
bool vender(const double stop, const double take)
  {
   double price = check_stoplevel(SymbolInfoDouble(_Symbol,SYMBOL_BID),ORDER_TYPE_SELL);
   double sl = (stop > 0.0) ? normalizar1(price+(stopLoss*_Point)) : 0.00;
   double tp = (take > 0.0) ? normalizar1(price-(takeProfit*_Point)) : 0.00;

   return realizar_negocio(TRADE_ACTION_PENDING,ORDER_TYPE_SELL_LIMIT,0,lote,price,sl,tp);
  }

//========================================================================
//========================================================================
//==FUNÇAO Realizando as transações |
//========================================================================
//========================================================================
bool realizar_negocio(const ENUM_TRADE_REQUEST_ACTIONS acao,
                      const ENUM_ORDER_TYPE tipo,
                      const ulong ticket=0.0,
                      const double volume=0.0,
                      const double price=0.0,
                      const double stoploss=500,
                      const double takeprofit=500,
                      const ulong ticket_by=0.0)
  {
   MqlTradeRequest request; // Estrutura da ordem a ser enviada
   MqlTradeResult result; // Resultados de verificação
   MqlTradeCheckResult check_result; // Dados de verificação

// Zerando residuos da solicitação anterior
   ZeroMemory(request);
   ZeroMemory(result);
   ZeroMemory(check_result);

   request.magic = magicNum;
   request.symbol = _Symbol;
   request.comment = "["+in_nome+"]";

   request.type_time = (ENUM_ORDER_TYPE_TIME)in_validade; // Tipo de validade da ordem, obrigatório em algumas corretoras
   request.type_filling = (ENUM_ORDER_TYPE_FILLING)preenchimento; // Tipo de preenchimento, de acordo com o tipo de mercado

   request.price = normalizar1(price);
   request.volume = NormalizeDouble(volume,2);
   request.action = acao;
   request.type = tipo;
   request.sl = normalizar1(stoploss);
   request.tp = normalizar1(takeprofit);
   request.position = ticket;
   request.position_by = ticket_by;
   request.order = ticket;

// Checando a ordem e seus resultados antes do envio da mesma
   if(!OrderCheck(request,check_result))
     {
      printf("[%s] Erro %d na checagem da ordem. Código %d (%s)",in_nome,GetLastError(),check_result.retcode,check_result.comment);
      return false;
     }
   else
      printf("[%s] Checagem de ordem bem sucedida. Enviando ordem...",in_nome);

// Se bem sucessedida a verificação a ordem é enviada
   if(!OrderSend(request,result))
     {
      // Mensagem exibida em caso de falha no envio da ordem
      printf("[%s] Erro %d no envio da ordem. Código %d (%s)",in_nome,GetLastError(),result.retcode,result.comment);
      return false;
     }
   else
      printf("[%s] Sucesso no negócio [%d]. Código %d (%s)",in_nome,result.order,result.retcode,result.comment);

   return true;
  }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double normalizar1(const double price)
  {
// Função que garante que o preço fique com valores aceitos para o ativo
   double tamanho = SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE);
   int digitos = (int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);
   double ajuste = (tamanho > 0 && price > 0) ? ((MathRound(price/tamanho))*tamanho) : 0.00;

   if(price > 0)
      if(ajuste < tamanho)
         ajuste = tamanho;

// Ajustando como saída o preço corrigido ou aprovado
   return NormalizeDouble(ajuste,digitos);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double check_stoplevel(double price, const ENUM_ORDER_TYPE tipo)
  {
// Distância mínima permitida do preço para colocar ordens pendentes
   double stoplevel = SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*_Point;
   double referencia = 0.00; // Iniciando variavel

   switch(tipo)
     {
      case ORDER_TYPE_BUY_LIMIT:
         referencia = SymbolInfoDouble(_Symbol,SYMBOL_ASK)-stoplevel; // Referência para o stoplevel
         if(price > referencia)
            normalizar1(referencia); // Altera para o valor mínimo aceito se a ordem estiver fora do parâmetro
         break;
      case ORDER_TYPE_SELL_LIMIT:
         referencia = SymbolInfoDouble(_Symbol,SYMBOL_BID)+stoplevel;
         if(price < referencia)
            normalizar1(referencia);
         break;
      default:
         break;
     }

   return price;
  }
//+------------------------------------------------------------------+

felipe ramos 2022.02.06 04:40 #1

ESTOU UTILIZANDO ESSA BIBLIOTECA

Arquivos anexados:

renko.zip 10 kb

Rogerio Giannetti Torres 2022.02.06 12:30 #2

felipe ramos #:

Bom dia,

Felipe emitir a ordem limite no preço Ask, Bid vai dar preço inválido na maioria das vezes, coloque um TICK de espaço, pode ainda dar erro mas é menos frequente.

Metatrader no Brasil - Erro de preço inválido POR QUE OS COMERCIANTES

felipe ramos 2022.02.06 14:47 #3

Rogerio Giannetti Torres #:

Bom dia,

Felipe emitir a ordem limite no preço Ask, Bid vai dar preço inválido na maioria das vezes, coloque um TICK de espaço, pode ainda dar erro mas é menos frequente.

bom dia Rogerio , você por aqui kkkk, tu me ajudou muito em algumas situações que me impedia de avançar no meu projeto. Sou iniciante nessa área, mais estou gostando muito dessa área,

como faço isso? Preciso declarar uma variável com um valor estático? Estou na fase final do meu projeto, ai decidi colocar essa função de operar no renko. Quando da esses erros normalmente aparece essas bolinhas vermelhas no canto esquerdo ne ? mais quando da um erro e não aparece,

passa na função que da um print do erro mais não e acompanhado com essas bolinhas e um erro na questão de execução ou esta passando naquela função sem ter erro ?

[Erro em obter o Especialistas: FAT PANEL Projeto do assessor

felipe ramos 2022.02.06 21:32 #4

Rogerio Giannetti Torres #:

Bom dia,

Felipe emitir a ordem limite no preço Ask, Bid vai dar preço inválido na maioria das vezes, coloque um TICK de espaço, pode ainda dar erro mas é menos frequente.

//+------------------------------------------------------------------+
//| Envio de compra limitada |
//+------------------------------------------------------------------+
bool comprar(const double stop, const double take)
  {
// Austando na entrada o preço de acordo com o stoplevel mínimo permitido
   double price = check_stoplevel(SymbolInfoDouble(_Symbol,SYMBOL_ASK),ORDER_TYPE_BUY);
   double sl =(stop > 0.0) ? normalizar1(price-(stopLoss*_Point)) : 0.00; // Stoploss
   double tp =(take > 0.0) ? normalizar1(price+(takeProfit*_Point)) : 0.00; // Takeprofit

// Envio sempre de ordem pendente
   return realizar_negocio(TRADE_ACTION_PENDING,ORDER_TYPE_BUY_LIMIT,0,lote,price,sl,tp);
  }
//+------------------------------------------------------------------+
//| Envio de venda limitada |
//+------------------------------------------------------------------+
bool vender(const double stop, const double take)
  {
   double price = check_stoplevel(SymbolInfoDouble(_Symbol,SYMBOL_BID),ORDER_TYPE_SELL);
   double sl = (stop > 0.0) ? normalizar1(price+(stopLoss*_Point)) : 0.00;
   double tp = (take > 0.0) ? normalizar1(price-(takeProfit*_Point)) : 0.00;

   return realizar_negocio(TRADE_ACTION_PENDING,ORDER_TYPE_SELL_LIMIT,0,lote,price,sl,tp);
  }

parece que resolvi, não sei se estou viajando na maionese mais não esta dando mais o erro, na compra mudei para ask e na venda bid

Novo comentário