Erro 4756

Tomas.lima 2023.10.02 15:45

Boa tarde, tudo bem? estou enfrentando um erro no meu robô e não consigo identificar o problema, aguém pode me ajudar por favor? segue o código:

//+------------------------------------------------------------------+
//|                                                          TCC.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+

#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"

enum ESTRATEGIA_ENTRADA
  {
   MM_E_BB_E_IFR, // Todos
   MM_E_BB, //Médias Móvies e Bandas de Bollinger
   MM_E_IFR,    // Médias mais IFR
   BB_E_IFR,   // Bandas de Bollinger e IFR
   APENAS_MM,  // Apenas Médias Móveis
   APENAS_BB,  // Apenas Bandas de Bolliger
   APENAS_IFR, // Apenas IFR
  };
//---

// Variáveis Input
sinput string s0; //-----------Estratégia de Entrada-------------
input ESTRATEGIA_ENTRADA   estrategia      = APENAS_MM;     // Estratégia de Entrada Trader

sinput string s1; //-----------Médias Móveis-------------
input int mm_rapida_periodo                = 12;            // Periodo Média Rápida
input int mm_lenta_periodo                 = 32;            // Periodo Média Lenta
input ENUM_TIMEFRAMES mm_tempo_grafico     = PERIOD_CURRENT;// Tempo Gráfico
input ENUM_MA_METHOD  mm_metodo            = MODE_EMA;      // Método 
input ENUM_APPLIED_PRICE  mm_preco         = PRICE_CLOSE;   // Preço Aplicado

sinput string s2; //-----------Bandas de Bollinger-------------
input int bb_periodo                       = 20;             // período da média da linha
input double bb_deviatation                = 2;             // Numero de desvios padrão
input int bb_shift                         = 0;             // Deslocamento horizontal do indicador 
input ENUM_TIMEFRAMES bb_tempo_grafico     = PERIOD_CURRENT;// Tempo Gráfico 
input ENUM_APPLIED_PRICE  bb_preco         = PRICE_CLOSE;   // Preço Aplicado

sinput string s3; //-----------IFR-------------
input int ifr_periodo                      = 14;             // Período IFR
input ENUM_TIMEFRAMES ifr_tempo_grafico    = PERIOD_CURRENT;// Tempo Gráfico  
input ENUM_APPLIED_PRICE ifr_preco         = PRICE_CLOSE;   // Preço Aplicado

input int ifr_sobrecompra                  = 70;            // Nível de Sobrecompra
input int ifr_sobrevenda                   = 30;            // Nível de Sobrevenda

sinput string s4; //---------------------------
input int num_lots                         = 100;           // Número de Lotes
input double TK                            = 60;            // Take Profit
input double SL                            = 30;            // Stop Loss


sinput string s5; //---------------------------
input string hora_limite_fecha_op          = "17:40";       // Horário Limite Fechar Posição

 
//---
//+------------------------------------------------------------------+
//|  Variáveis para os indicadores                                   |
//+------------------------------------------------------------------+
//--- Médias Móveis
// RÁPIDA - menor período
int mm_rapida_Handle;      // Handle controlador da média móvel rápida
double mm_rapida_Buffer[]; // Buffer para armazenamento dos dados das médias

// LENTA - maior período
int mm_lenta_Handle;      // Handle controlador da média móvel lenta
double mm_lenta_Buffer[]; // Buffer para armazenamento dos dados das médias

//--- IFR
int ifr_Handle;           // Handle controlador para o IFR
double ifr_Buffer[];      // Buffer para armazenamento dos dados do IFR

//--- BANDA DE BOLLINGER
int bb_Handle;      // Handle controlador da bandas de bollinger
double         bb_UpperBuffer[];
double         bb_LowerBuffer[];

//+------------------------------------------------------------------+
//| Variáveis para as funçoes                                        |
//+------------------------------------------------------------------+

int magic_number = 123456;   // Nº mágico do robô

MqlRates velas[];            // Variável para armazenar velas
MqlTick tick;                // variável para armazenar ticks 

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   mm_rapida_Handle = iMA(_Symbol,mm_tempo_grafico,mm_rapida_periodo,0,mm_metodo,mm_preco);
   mm_lenta_Handle  = iMA(_Symbol,mm_tempo_grafico,mm_lenta_periodo,0,mm_metodo,mm_preco);
   
   bb_Handle  = iBands(_Symbol,bb_tempo_grafico,20,0,2.00,bb_preco);
   
   ifr_Handle = iRSI(_Symbol,ifr_tempo_grafico,ifr_periodo,ifr_preco);
   
   if(mm_rapida_Handle<0 || mm_lenta_Handle<0 || bb_Handle<0 || ifr_Handle<0)
     {
      Alert("Erro ao tentar criar Handles para o indicador - erro: ",GetLastError(),"!");
      return(-1);
     }
   
   CopyRates(_Symbol,_Period,0,4,velas);
   ArraySetAsSeries(velas,true);
   
   // Para adicionar no gráfico o indicador:
   ChartIndicatorAdd(0,0,mm_rapida_Handle); 
   ChartIndicatorAdd(0,0,mm_lenta_Handle);
   ChartIndicatorAdd(0,0,bb_Handle);
   ChartIndicatorAdd(0,1,ifr_Handle);
   //---
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   IndicatorRelease(mm_rapida_Handle);
   IndicatorRelease(mm_lenta_Handle);
   IndicatorRelease(bb_Handle);
   IndicatorRelease(ifr_Handle);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   //desenhaLinhaVertical("L1",tick.time,clrRed);
   // Copiar um vetor de dados tamanho três para o vetor mm_Buffer
    CopyBuffer(mm_rapida_Handle,0,0,4,mm_rapida_Buffer);
    CopyBuffer(mm_lenta_Handle,0,0,4,mm_lenta_Buffer);
    
    CopyBuffer(bb_Handle,1,0,4,bb_UpperBuffer); 
    CopyBuffer(bb_Handle,2,0,4,bb_LowerBuffer);
    
    CopyBuffer(ifr_Handle,0,0,4,ifr_Buffer);
    
    //---
    
    double close_atual = iClose(_Symbol,_Period,0);
    double close_anterior = iClose(_Symbol,_Period,1);
    
    //--- Alimentar Buffers das Velas com dados:
    CopyRates(_Symbol,_Period,0,4,velas);
    ArraySetAsSeries(velas,true);
    
    // Ordenar o vetor de dados:
    ArraySetAsSeries(mm_rapida_Buffer,true);
    ArraySetAsSeries(mm_lenta_Buffer,true);
    ArraySetAsSeries(bb_UpperBuffer,true);
    ArraySetAsSeries(bb_LowerBuffer,true);
    ArraySetAsSeries(ifr_Buffer,true);
    //---
    
    // Alimentar com dados variável de tick
    SymbolInfoTick(_Symbol,tick);
   
    // LOGICA PARA ATIVAR COMPRA 
    bool compra_mm_cros = mm_rapida_Buffer[0] > mm_lenta_Buffer[0] &&
                          mm_rapida_Buffer[2] < mm_lenta_Buffer[2] ;
                          
    bool compra_bb = close_anterior >= bb_LowerBuffer[1] && close_atual < bb_LowerBuffer[0] ;
                                             
    bool compra_ifr = ifr_Buffer[0] <= ifr_sobrevenda;
    
    // LÓGICA PARA ATIVAR VENDA
    bool venda_mm_cros = mm_lenta_Buffer[0] > mm_rapida_Buffer[0] &&
                         mm_lenta_Buffer[2] < mm_rapida_Buffer[2];
                       
    bool venda_bb = close_anterior <= bb_UpperBuffer[1] && close_atual > bb_UpperBuffer[0] ; 
    
    bool venda_ifr = ifr_Buffer[0] >= ifr_sobrecompra;
   
   //---
    bool Comprar = false; // Pode comprar?
    bool Vender  = false; // Pode vender?
    
    if(estrategia == MM_E_BB_E_IFR)
      {
       Comprar = compra_mm_cros && compra_bb && compra_ifr;
       
       Vender  = venda_mm_cros && venda_bb && venda_ifr;
       
      }
    else if(estrategia == MM_E_BB)
     {
       Comprar = compra_mm_cros && compra_bb;
       
       Vender  = venda_mm_cros && venda_bb;
     }
     else if(estrategia == MM_E_IFR)
     {
       Comprar = compra_mm_cros && compra_ifr;
       
       Vender  = venda_mm_cros && venda_ifr;
     }
     else if(estrategia == BB_E_IFR)
     {
       Comprar = compra_bb && compra_ifr;
       
       Vender  = venda_bb && venda_ifr;
     }
     else if(estrategia == APENAS_MM)
     {
       Comprar = compra_mm_cros;
       
       Vender  = venda_mm_cros;
     }
     else if(estrategia == APENAS_BB)
     {
       Comprar = compra_bb;
       
       Vender  = venda_bb;
     }
    else
      {
       Comprar = compra_ifr;
       
       Vender  = venda_ifr;
      } 
   
   //---
   // retorna true se tivermos uma nova vela
    bool temosNovaVela = TemosNovaVela(); 
    
    // Toda vez que existir uma nova vela entrar nesse 'if'
    if(temosNovaVela)
      {
       
       // Condição de Compra:
       if(Comprar && PositionSelect(_Symbol)==false)
         {
          desenhaLinhaVertical("Compra",velas[1].time,clrBlue);
          CompraAMercado();
         }
       
       // Condição de Venda:
       if(Vender && PositionSelect(_Symbol)==false)
         {
          desenhaLinhaVertical("Venda",velas[1].time,clrRed);
          VendaAMercado();
         } 
         
      }
    
    //---
     if(TimeToString(TimeCurrent(),TIME_MINUTES) == hora_limite_fecha_op && PositionSelect(_Symbol)==true)
        {
            Print("-----> Fim do Tempo Operacional: encerrar posições abertas!");
             
            if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
               {
                  FechaCompra();
               }
            else if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
               {
                  FechaVenda();
               }
        }  
   
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| FUNÇÕES PARA AUXILIAR NA VISUALIZAÇÃO DA ESTRATÉGIA              |
//+------------------------------------------------------------------+

void desenhaLinhaVertical(string nome, datetime dt, color cor = clrBlueViolet)
   {
      ObjectDelete(0,nome);
      ObjectCreate(0,nome,OBJ_VLINE,0,dt,0);
      ObjectSetInteger(0,nome,OBJPROP_COLOR,cor);
   } 
//---

//+------------------------------------------------------------------+
//| FUNÇÕES PARA ENVIO DE ORDENS                                     |
//+------------------------------------------------------------------+

// COMPRA A MERCADO
void CompraAMercado() // bser na documentação ordem das variaveis!!!
  {
   MqlTradeRequest   requisicao;    // requisição
   MqlTradeResult    resposta;      // resposta
   
   ZeroMemory(requisicao);
   ZeroMemory(resposta);
   
   //--- Cacacterísticas da ordem de Compra
   requisicao.action       = TRADE_ACTION_DEAL;                            // Executa ordem a mercado
   requisicao.magic        = magic_number;                                 // Nº mágico da ordem
   requisicao.symbol       = _Symbol;                                      // Simbolo do ativo
   requisicao.volume       = num_lots;                                     // Nº de Lotes
   requisicao.price        = NormalizeDouble(tick.ask,_Digits);            // Preço para a compra
   requisicao.sl           = NormalizeDouble(tick.ask - SL*_Point,_Digits);// Preço Stop Loss
   requisicao.tp           = NormalizeDouble(tick.ask + TK*_Point,_Digits);// Alvo de Ganho - Take Profit
   requisicao.deviation    = 0;                                            // Desvio Permitido do preço
   requisicao.type         = ORDER_TYPE_BUY;                               // Tipo da Ordem
   requisicao.type_filling = ORDER_FILLING_FOK;                            // Tipo deo Preenchimento da ordem
   
   //---
   OrderSend(requisicao,resposta);
   //---
   if(resposta.retcode == 10008 || resposta.retcode == 10009)
     {
      Print("Ordem de Compra executada com sucesso!");
     }
   else
     {
       Print("Erro ao enviar Ordem Compra. Erro = ", GetLastError());
       printf(_ReturnedString);
       ResetLastError();
     }
  }

// VENDA A MERCADO
void VendaAMercado()
  {
   MqlTradeRequest   requisicao;    // requisição
   MqlTradeResult    resposta;      // resposta
   
   ZeroMemory(requisicao);
   ZeroMemory(resposta);
   
   //--- Cacacterísticas da ordem de Venda
   requisicao.action       = TRADE_ACTION_DEAL;                            // Executa ordem a mercado
   requisicao.magic        = magic_number;                                 // Nº mágico da ordem
   requisicao.symbol       = _Symbol;                                      // Simbolo do ativo
   requisicao.volume       = num_lots;                                     // Nº de Lotes
   requisicao.price        = NormalizeDouble(tick.bid,_Digits);            // Preço para Venda
   requisicao.sl           = NormalizeDouble(tick.bid + SL*_Point,_Digits);// Preço Stop Loss
   requisicao.tp           = NormalizeDouble(tick.bid - TK*_Point,_Digits);// Alvo de Ganho - Take Profit
   requisicao.deviation    = 0;                                            // Desvio Permitido do preço
   requisicao.type         = ORDER_TYPE_SELL;                              // Tipo da Ordem
   requisicao.type_filling = ORDER_FILLING_FOK;                            // Tipo deo Preenchimento da ordem
   //---
   OrderSend(requisicao,resposta);
   //---
     if(resposta.retcode == 10008 || resposta.retcode == 10009)
       {
        Print("Ordem de Venda executada com sucesso!");
       }
     else
       {
        Print("Erro ao enviar Ordem Venda. Erro = ", GetLastError());
        ResetLastError();
       } 
 }
//---
//---
void FechaCompra()
   {
      MqlTradeRequest   requisicao;    // requisição
      MqlTradeResult    resposta;      // resposta
      
      ZeroMemory(requisicao);
      ZeroMemory(resposta);
      
      //--- Cacacterísticas da ordem de Venda
      requisicao.action       = TRADE_ACTION_DEAL;
      requisicao.magic        = magic_number;
      requisicao.symbol       = _Symbol;
      requisicao.volume       = num_lots; 
      requisicao.price        = 0; 
      requisicao.type         = ORDER_TYPE_SELL;
      requisicao.type_filling = ORDER_FILLING_RETURN;
      
      //---
      OrderSend(requisicao,resposta);
      //---
        if(resposta.retcode == 10008 || resposta.retcode == 10009)
          {
           Print("Ordem de Venda executada com sucesso!");
          }
        else
          {
           Print("Erro ao enviar Ordem Venda. Erro = ", GetLastError());
           ResetLastError();
          }
   }

void FechaVenda()
   {   
      MqlTradeRequest   requisicao;    // requisição
      MqlTradeResult    resposta;      // resposta
      
      ZeroMemory(requisicao);
      ZeroMemory(resposta);
      
      //--- Cacacterísticas da ordem de Compra
      requisicao.action       = TRADE_ACTION_DEAL;
      requisicao.magic        = magic_number;
      requisicao.symbol       = _Symbol;
      requisicao.volume       = num_lots; 
      requisicao.price        = 0; 
      requisicao.type         = ORDER_TYPE_BUY;
      requisicao.type_filling = ORDER_FILLING_RETURN;
      
      //---
      OrderSend(requisicao,resposta);
   
      //---
        if(resposta.retcode == 10008 || resposta.retcode == 10009)
          {
           Print("Ordem de Compra executada com sucesso!");
          }
        else
          {
           Print("Erro ao enviar Ordem Compra. Erro = ", GetLastError());
           ResetLastError();
          }
   }
//---
//+------------------------------------------------------------------+
//| FUNÇÕES ÚTEIS                                                    |
//+------------------------------------------------------------------+
//--- Para Mudança de Candle
bool TemosNovaVela()
  {
//--- memoriza o tempo de abertura da ultima barra (vela) numa variável
   static datetime last_time=0;
//--- tempo atual
   datetime lastbar_time= (datetime) SeriesInfoInteger(Symbol(),Period(),SERIES_LASTBAR_DATE);

//--- se for a primeira chamada da função:
   if(last_time==0)
     {
      //--- atribuir valor temporal e sair
      last_time=lastbar_time;
      return(false);
     }

//--- se o tempo estiver diferente:
   if(last_time!=lastbar_time)
     {
      //--- memorizar esse tempo e retornar true
      last_time=lastbar_time;
      return(true);
     }
//--- se passarmos desta linha, então a barra não é nova; retornar false
   return(false);
  }

Discover new MetaTrader 5 opportunities with MQL5 community and services

2023.10.02
www.mql5.com

MQL5: language of trade strategies built-in the MetaTrader 5 Trading Platform, allows writing your own trading robots, technical indicators, scripts and libraries of functions

Fernando Carreiro 2023.10.02 15:48 #1

Por favor não criar tópicos aleatoriamente sem ter em conta a secção adequada. O seu tópico foi movido para a secção: Expert Advisors e Negociação Automatizada

Ricardo Rodrigues Lucca 2023.10.02 20:31 #2

Tomas.lima:

Boa tarde, tudo bem? estou enfrentando um erro no meu robô e não consigo identificar o problema, aguém pode me ajudar por favor? segue o código:

Serio mesmo que só vai dizer "Por favor me ajude, toma o código?" . Poderia por favor colocar então foto das mensagens do compilador ou do erro? Lembramos que se não sabe programar e esta usando o chatgpt o melhor é investir seu dinheiro comprando um EA na area de freelancer.

EDIT: Olhei a mensagem de codigo de erro informada no titulo, voce esta normalizando o preço de maneira errada. Vamos dizer por exemplo que opera o indice, _Digits vai ser zero e a normalização correta seria a cada 5 pts.

Perguntas de Iniciantes MQL4 Quaisquer perguntas de recém-chegados Ajuda na codificação

Tomas.lima 2023.10.02 21:41 #3

Ricardo Rodrigues Lucca #:

Peço desculpas, sou iniciante no mql5 e foi minha primeira interação no forum, vou me atentar mais a regra, muito obrigado pela resposta, entendi a direção a seguir mas não sei os ajustes necessários, pode me informar por favor somente no trecho de código como ficaria de forma correta? se puder explicar o err também ajudaria bastante na minha evolução muito obrigado!

Indicadores de múltiplos períodos Quaisquer perguntas de recém-chegados Perguntas de Iniciantes MQL5

Ricardo Rodrigues Lucca 2023.10.03 01:15 #4

Tomas.lima #:
Peço desculpas, sou iniciante no mql5 e foi minha primeira interação no forum, vou me atentar mais a regra, muito obrigado pela resposta, entendi a direção a seguir mas não sei os ajustes necessários, pode me informar por favor somente no trecho de código como ficaria de forma correta? se puder explicar o err também ajudaria bastante na minha evolução muito obrigado!

Pode substituir o NormalizeDouble usado dentro das que fazem a compra e venda por uma chamada a função abaixo:

double NormalizePrice(double price)
{
   double tick = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   double value = MathFloor(price / tick);
   return NormalizeDouble(value * tick, _Digits);
}

Resolvido o problema do invalid stop é possivel que vai dar rejeitado por conta do type_filling escolhido. O único que é garantido que não daria problema é o RETURN.

[ARQUIVO]Qualquer pergunta de novato, Campeonato de Otimização de Lição 13 - Seu

Novo comentário