Está dando o erro 4753 / 10030

 


#property copyright "Copyright 2020, Michel Ross"
#property link      "https://www.mql5.com"
#property version   "1.00"

#include <Trade\Trade.mqh>
          CTrade negocio;
          
#include <Trade\SymbolInfo.mqh>
          CSymbolInfo simbolo;
                    
         
//+------------------------------------------------------------------+
//|                    Parametros de Enrtada                         |
//+------------------------------------------------------------------+

input string Titulo_1 ="";                                      //--- Parametros de Contratos
input double LotedeEntrada = 0.01;                              //--- Valor do Lote de Entrada
input double TakeProfit = 50.0;                                 //--- Stop Gain da Operação
input double StopLoss = 40.0;                                   //--- Stop Loss da Operação
input double Break_Even = 25;                                   //---Sistema de BreakEven                                

//--------------------------------

input string Titulo_2 ="";                                     //--- Parametros de Porcentagem 
input int PorcentagemDeGain = 0;                               //--- Porcentagem diária Gain 
input int PorcentagemDeLoss = 0;                               //--- Porcentagem diária Loss

//--------------------------------

double Lote_inicial = LotedeEntrada;
input int Lote_multiplicador = 2;                             //--- Caso a operação termine negativa, vai dobrar o lote para recuperar a perda e ainda obter lucro
input int Lote_maximo = 10;
double GL_lote_atual;


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

int   gl_ordens = 0;                                   //--- Essa Váriável vai ser usada para definir compra, venda ou nãop fazer nada
ulong magicNum = 1212;                                 //--- Magic number é tipo um código pra esse rôbo em especifico, para n ter problema em usar mais de um ao mesmo tempo
bool  gl_openPosition = false;                         //--- Tenho posição aberta ou não ?
long  gl_positonType = -1;                             //--- Estou compradou ou vendido ?
long  gl_positonType1 = -1;

//+------------------------------------------------------------------+
//|                       Dando valor e Estilo das Médias            |
//+------------------------------------------------------------------+

input string Titulo_3 ="";                                //--- Parametros da Média móvel Rápida
input int                ma_Fast = 8;                     //--- Período da média móvel Rápida 
input  ENUM_MA_METHOD ma_Fast_method = MODE_SMA;          //--- Metodo da média móvel Rápida
//-------------------------------

input string Titulo_4 ="";                               //--- Parametros da Média móvel Lenta
input int                ma_Slow = 20;                   //--- Período da média móvel Lenta
input  ENUM_MA_METHOD ma_Slow_method = MODE_SMA;         //--- Metodo da média móvel Lenta

//+------------------------------------------------------------------+
//|                            Data e Hora                           |
//+------------------------------------------------------------------+
input string Titulo_5 ="";                               //--- Parametros de Horário
input int hAbertura = 9;
input int mAbertura = 00;
input int hFechamento = 17;
input int mFechamento = 30;

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

int      iMA_fast_handle = INVALID_HANDLE;
int      iMA_slow_handle = INVALID_HANDLE;

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

double   iMA_fast_buffer[];
double   iMA_slow_buffer[];

//+------------------------------------------------------------------+
//|                    Gestão de elementos Gráficos                  |
//+------------------------------------------------------------------+

bool     GLinitHandle1 = false;
bool     GLinitHandle2 = false;

bool     GLgrafico_1 = false;
bool     GLgrafico_2 = false; 

//+------------------------------------------------------------------+
//|                                                                  |
//|                 Expert initialization function                   |
//|                                                                  |  
//+------------------------------------------------------------------+
int OnInit()
    {
     if(!simbolo.Name(_Symbol))
     {printf("Ativo Inválido");
     return INIT_FAILED; 
     }
     
     
    ENUM_ACCOUNT_MARGIN_MODE mode=(ENUM_ACCOUNT_MARGIN_MODE)AccountInfoInteger(ACCOUNT_MARGIN_MODE);   //--- Define que o rôbo só rode em conta "Edge"
    if(mode!=ACCOUNT_MARGIN_MODE_RETAIL_HEDGING)                                                       //--- Se for conta "Netting" não vai rodar
    {
    Print("Conta Netting não permitida.");
    ExpertRemove();
    }
     
     negocio.SetExpertMagicNumber(magicNum);   //--- especifica que esse robô é responsavel pelas operações em questão.
//+------------------------------------------------------------------+
//|           Análise de Váriaveis de parametros de Entrada          |    
//+------------------------------------------------------------------+
   
   if(LotedeEntrada >= 3.0)                                                             //--- Não vai permitir o robô operar com o lote muito grande
     {
     Print("Vai quebrar a conta, melhor parar por hoje.");
     return(INIT_FAILED);
     }
     
   if(TakeProfit <= 0)                                                                  //--- Não vai permitir o robô operar sem um Take Profit
     {
     Print("Esqueceu de por o Take meu querido.");
     return(INIT_FAILED);
     }
   
   if(StopLoss <= 0)                                                                    //--- Não vai permitir o robô operar sem um Stop Loss
     {
     Print("Cara vc não colocou o STOPLOSS, vai dar ruim, arruma lá.");
     return(INIT_FAILED);
     }

//+------------------------------------------------------------------+
//|               Análise de Variáveis das Médias Moveis             |
//+------------------------------------------------------------------+
  if(ma_Fast <= 0)
     {
     Print("O periodo da Média Movel Rápida não pode ser menor ou igual a Zero.");
     return(INIT_FAILED);
     }
  
  if(ma_Slow <= 0)
     {
     Print("O periodo da Média Movel Lenta não pode ser menor ou igual a Zero.");
     return(INIT_FAILED);
     }
   
   if(ma_Slow < ma_Fast)
     {
     Print("O periodo da Média Movel Lenta nunca pode ser menor que a Média Movel Rápida.");
     return(INIT_FAILED); 
     }
   
//+------------------------------------------------------------------+
//|                             Handles                              |
//+------------------------------------------------------------------+
     
   iMA_fast_handle = iMA(_Symbol,_Period,ma_Fast,0,ma_Fast_method,PRICE_CLOSE);
   
   if(iMA_fast_handle == INVALID_HANDLE)
     {
     Print("Deu ruim da hora de criar a média rápida =( .",GetLastError());
     return(INIT_FAILED);
     }
   else
     {
     GLinitHandle1 = true;
     }
   
//------   
   
   iMA_slow_handle = iMA(_Symbol,_Period,ma_Slow,0,ma_Slow_method,PRICE_CLOSE);
   
   if(iMA_slow_handle == INVALID_HANDLE)
     {
     Print("Deu ruim na hora de criar a média lenta =( .",GetLastError());
     return(INIT_FAILED);
     }
   else
     {
     GLinitHandle2 = true;
     }
  
//+------------------------------------------------------------------+
//|                 Colocando os indicadores no gráfico              |
//+------------------------------------------------------------------+
    
   if(!ChartIndicatorAdd(ChartID(),0,iMA_fast_handle))
     {
     Print("Erro na plotagem do indicador iMA_fast_handle no gráfico.");
     return(INIT_FAILED);
     }
   else
     {
     GLgrafico_1 = true;
     }
   
   if(!ChartIndicatorAdd(ChartID(),0,iMA_slow_handle))
     {
     Print("Erro na plotagem do indicador iMA_slow_handle no gráfico.");
     return(INIT_FAILED);
     }
   else
     {
     GLgrafico_2 = true;
     } 
   
    Print("O Rôbo foi inicializado boa sorte");
    
    GL_lote_atual = Lote_inicial; 
   
    return(INIT_SUCCEEDED);
    }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   
   ResetLastError();
   Comment("");
   
//+------------------------------------------------------------------+
//|                      Liberação dos Indicadores                   |
//+------------------------------------------------------------------+
   
   if(GLinitHandle1==true && !IndicatorRelease(iMA_fast_handle))
     Print("Erro na liberação do iMA_fast_handle. ",GetLastError()); 
 
   if(GLinitHandle2==true && !IndicatorRelease(iMA_slow_handle))
     Print("Erro na liberação do iMA_slow_handle. ",GetLastError()); 
    
//+------------------------------------------------------------------+
//|                      Array Free                                  |
//+------------------------------------------------------------------+
  
   ArrayFree(iMA_fast_buffer);                  //--- Libera um buffer de qualquer array dinâmico e define o tamanho da dimensão zero para 0.
   ArrayFree(iMA_slow_buffer);
     
//+------------------------------------------------------------------+
//|               Retirando os Indicadores do Gráfico                |
//+------------------------------------------------------------------+
  
    string iMA_fast_chart =ChartIndicatorName(0,0,0);
    if(GLgrafico_1 && !ChartIndicatorDelete(0,0,iMA_fast_chart))
     Print("Erro na hora de remover aiMA_fast_chart. ",GetLastError());
     
     string iMA_slow_chart =ChartIndicatorName(0,0,0);
     if(GLgrafico_2 && !ChartIndicatorDelete(0,0,iMA_slow_chart))
     Print("Erro na hora de remover aiMA_slow_chart. ",GetLastError());
  
  
     Print("Deinicialização executada.");
   
    }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
    {
    if(isNewBar())
    {
    semposicao();
    ResetLastError();
    MqlDateTime dt;
    TimeCurrent(dt); 
    
    Comment("[HORÁRIO ATUAL] ", dt.hour, ":", dt.min);
     
//+------------------------------------------------------------------+
//|    Lógica Da Estratégia                                          |
//+------------------------------------------------------------------+

     // Atualização dos dados do ativo
      if(!simbolo.RefreshRates())
      return;
   
      // EA em horário de entrada em novas operações
      if(HorarioEntrada())
      {
      // EA não está posicionado
      if(semposicao())
      {
      // Verificar estratégia e determinar compra ou venda
      int resultado_cruzamento = cruzamento();
         
      if(resultado_cruzamento != 0)
      {
      if(SaidaStopLoss())
      {
      GL_lote_atual *= Lote_multiplicador;
      if(GL_lote_atual > Lote_maximo)
      GL_lote_atual = Lote_maximo;
       }
      else
       {
      GL_lote_atual = Lote_inicial;
       }
       }
         
         // Estratégia indicou compra
      if(resultado_cruzamento == 1)
         compra();
         // Estratégia indicou venda
      if(resultado_cruzamento == -1)
         venda();
      }
        // EA está posicionado
      if(!semposicao())
      {
         break_even();
      }
   }
   
   // EA em horário de fechamento de posições abertas
   if(HorarioFechamento())
   {
      // EA está posicionado, fechar posição
      if(!semposicao())
         fechar();
   }
   
   // Checagem do BreakEven
   if(!semposicao())
      break_even();
   
   // Deleção da linha de BreakEven caso não estiver posicionado
   if(semposicao())
     ObjectDelete(0, "Break_even");
  
}
}

//----
bool semposicao()
{
  bool  resultado =! PositionSelect ( _Symbol );
  return  resultado ;
}
//-----   
void compra()
{
  double price = simbolo.Ask();
  double SL= (StopLoss * _Point);
  double TP = (TakeProfit * _Point);
  negocio.Buy(GL_lote_atual, _Symbol, price, price-SL, price+TP, "[COMPRA]");
  Print("Executada Ordem de Compra. ",GetLastError());
}
//-----
void venda()
{
 double price = simbolo.Bid();
 double SL = (StopLoss * _Point);
 double TP = (TakeProfit * _Point);
 negocio.Sell(GL_lote_atual, _Symbol, price, price+SL, price-TP, "[VENDA]");
 Print("Executada Ordem de Venda. ",GetLastError());
}
//-----
void fechar()                       //--- Fechamento de posições abertas próximas ao horário de fechamento
{ 
   MqlTradeRequest     request;
   MqlTradeResult      result;                             //--- Biblioteca CTrade
   MqlTradeCheckResult check_result;
  
   if(OrdersTotal() != 0)
    {
   for(int i=OrdersTotal()-1; i>=0; i--)
    {
   ulong ticket = OrderGetTicket(i);
   if(OrderGetString(ORDER_SYMBOL)==_Symbol)
    {
   ZeroMemory(request);
   ZeroMemory(result);
   ZeroMemory(check_result);
   request.action       =TRADE_ACTION_REMOVE;
   request.order        =ticket;
            
            //--- Checagem e envio de ordens
   ResetLastError();
   if(!OrderCheck(request, check_result))
    {
   PrintFormat("Erro em OrderCheck: %d", GetLastError());
   PrintFormat("Código de Retorno: %d", check_result.retcode);
   return;
    }
            
   if(!OrderSend(request, result))
    {
   PrintFormat("Erro em OrderSend: %d", GetLastError());
   PrintFormat("Código de Retorno: %d", result.retcode);
    }
   }
  }
 }
   
   // Verificação de posição aberta
   if(!PositionSelect(_Symbol))
      return;
      
   // Limpar informações das estruturas
   ZeroMemory(request);
   ZeroMemory(result);
   ZeroMemory(check_result);
   
   //--- Preenchimento da requisição
   request.action       = TRADE_ACTION_DEAL;
   request.magic        = magicNum;
   request.symbol       = _Symbol;
   request.volume       = PositionGetDouble(POSITION_VOLUME);
   request.type_filling = ORDER_FILLING_RETURN; 
   request.comment      = "Fechamento CruzamentoMediaEA";
      
   long tipo = PositionGetInteger(POSITION_TYPE); // Tipo da posição aberta
   
   // Vender em caso de posição comprada
   if(tipo == POSITION_TYPE_BUY)
      //negocio.Sell(Volume, NULL, 0, 0, 0, "Fechamento CruzamentoMediaEA");
   {
      request.price        =simbolo.Bid(); 
      request.type         =ORDER_TYPE_SELL;
   }
   // Comprar em caso de posição vendida
   else
      //negocio.Buy(Volume, NULL, 0, 0, 0, "Fechamento CruzamentoMediaEA");
   {
      request.price        =simbolo.Ask(); 
      request.type         =ORDER_TYPE_BUY;
   }
   
   //--- Checagem e envio de ordens
   ResetLastError();
   if(!OrderCheck(request, check_result))
   {
      PrintFormat("Erro em OrderCheck aqui: %d", GetLastError());
      PrintFormat("Código de Retorno ou aqui: %d", check_result.retcode);
      return;
   }
   
   if(!OrderSend(request, result))
   {
      PrintFormat("Erro em OrderSend Fechar posição: %d", GetLastError());
      PrintFormat("Código de Retorno Fechar posição: %d", result.retcode);
   }

}
//-----
int cruzamento()                       //--- Cruzamento das médias
{
 double mediacurta[], medialonga[];
 ArraySetAsSeries(mediacurta,true);
 ArraySetAsSeries(medialonga,true);
 CopyBuffer(iMA_slow_handle,0,0,2,mediacurta);
 CopyBuffer(iMA_fast_handle,0,0,2,medialonga);
 //---Compra
 if(mediacurta[1]<medialonga[1] && mediacurta[0]>medialonga[0])
 return 1;
 //---Venda
 if(mediacurta[1]>medialonga[1] && mediacurta[0]<medialonga[0])
 return -1;
 
 return 0;
}

//---------------    
 bool isNewBar()                   //--- Aqui definimos que uma nova operação só pode ser aberta em um novo candle
  {
//--- memorize the time of opening of the last bar in the static variable
   static datetime last_time=0;
//--- current time
   datetime lastbar_time = (datetime) SeriesInfoInteger(_Symbol,_Period,SERIES_LASTBAR_DATE);

//--- if it is the first call of the function
   if(last_time==0)
     {
      //--- set the time and exit
      last_time=lastbar_time;
      return(false);
     }

//--- if the time differs
   if(last_time!=lastbar_time)
     {
      //--- memorize the time and return true
      last_time=lastbar_time;
      return(true);
     }
//--- if we passed to this line, then the bar is not new; return false
   return(false);
  }


//---------------------------------------------------   
void break_even()                                         //--- Muda o stopploss depois de atingir tantos pontos a favor da operação para evitar sair no preju
{
 if(!PositionSelect(_Symbol))
   return;
   
 double preco_abertura = PositionGetDouble(POSITION_PRICE_OPEN);
 double delta = simbolo.Last() - preco_abertura;
 double sl = PositionGetDouble(POSITION_SL);
 
 if(sl == preco_abertura)
 {
  return;
 }
 
 if(delta >= Break_Even)
  {
   MqlTradeRequest     request;
   MqlTradeResult      result;                             //--- Biblioteca CTrade
   MqlTradeCheckResult check_result;
  
   ZeroMemory(request);                                    //--- Limpando os dados das váriaveis caso foram usadas em outros lugares
   ZeroMemory(result);                                     //--- Assim evita erros de outros dados
   ZeroMemory(check_result);
   
   request.action   = TRADE_ACTION_SLTP;                   //--- Tipo de operação da negocioação
   request.magic    = magicNum;                            //--- Número magico no rôbo
   request.symbol   = _Symbol;                             //--- Simbolo da negociação
   request.sl       = preco_abertura;                      //--- Nível do stoploss da ordem
   request.tp       = PositionGetDouble(POSITION_TP);      //--- Nìvel do takeprofit da ordem
   request.position = PositionGetInteger(POSITION_TICKET); //---Bilhete da posição
   if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)
   {
   delta *=-1;
   }
   ResetLastError();
   if(!OrderCheck(request, check_result))
   {
    PrintFormat("Erro em OrderCheck: %d", GetLastError());
    PrintFormat("Código de Retorno: %d", result.retcode);
   }
   if(!OrderSend(request, result))
   {
    PrintFormat("Erro em OrderCheck Break_even: %d", GetLastError());
    PrintFormat("Código de Retorno Break_even: %d", result.retcode);
   } 
   ObjectDelete(0, "Break_even");   
 } 
} 

//+------------------------------------------------------------------+
//| Checar se horário atual está dentro do horário de entradas       |
//+------------------------------------------------------------------+
bool HorarioEntrada()
{  
   MqlDateTime horario_atual, horario_inicio, horario_termino;
   
   ZeroMemory(horario_atual);
   ZeroMemory(horario_inicio);
   ZeroMemory(horario_termino);
   
   TimeToStruct(TimeCurrent(), horario_atual); // Obtenção do horário atual
   
   // Hora dentro do horário de entradas
   if(horario_atual.hour >= horario_inicio.hour && horario_atual.hour <= horario_termino.hour)
   {
   // Hora atual igual a de início
   if(horario_atual.hour == horario_inicio.hour)
   // Se minuto atual maior ou igual ao de início => está no horário de entradas
   if(horario_atual.min >= horario_inicio.min)
   return true;
   // Do contrário não está no horário de entradas
   else
   return false;
      
   // Hora atual igual a de término
   if(horario_atual.hour == horario_termino.hour)
   // Se minuto atual menor ou igual ao de término => está no horário de entradas
   if(horario_atual.min <= horario_termino.min)
   return true;
   // Do contrário não está no horário de entradas
   else
   return false;
      
   // Hora atual maior que a de início e menor que a de término
   return true;
   }
   
   // Hora fora do horário de entradas
   return false;
} 

//+------------------------------------------------------------------+
//| Checar se horário atual está dentro do horário de fechamento     |
//+------------------------------------------------------------------+
bool HorarioFechamento()
{
   MqlDateTime horario_atual, horario_inicio, horario_termino, horario_fechamento;
   
   ZeroMemory(horario_atual);
   ZeroMemory(horario_inicio);
   ZeroMemory(horario_termino);
   ZeroMemory(horario_fechamento);

   TimeToStruct(TimeCurrent(), horario_atual); // Obtenção do horário atual
   
   // Hora dentro do horário de fechamento
   if(horario_atual.hour >= horario_fechamento.hour)
   {
   // Hora atual igual a de fechamento
   if(horario_atual.hour == horario_fechamento.hour)
   // Se minuto atual maior ou igual ao de fechamento => está no horário de fechamento
   if(horario_atual.min >= horario_fechamento.min)
   return true;
   // Do contrário não está no horário de fechamento
   else
   return false;
      
   // Hora atual maior que a de fechamento
   return true;
   }
   
   // Hora fora do horário de fechamento
   return false;
}

bool SaidaStopLoss()
  {
   MqlDateTime inicio_struct;
   datetime fim = TimeCurrent(inicio_struct);
   inicio_struct.hour = 0;
   inicio_struct.min = 0;
   inicio_struct.sec = 0;
   
   if(!HistorySelect(StructToTime(inicio_struct), fim))
      return false;
      
   if(HistoryDealsTotal()==0)
      return false;
   
   for(int i=HistoryDealsTotal()-1; i>=0; i--)
   {
   ulong ticket = HistoryDealGetTicket(i);
      
   if(ticket > 0)
   {
   if(HistoryDealGetString(ticket, DEAL_SYMBOL) != _Symbol) 
   continue;
      
   string comment = HistoryDealGetString(ticket, DEAL_COMMENT);
   return StringFind(comment, "sl ")==0;
   }
   }
   
   return false;
   }
 
111018654:


Tá, você quer que nós reprogramemos o seu código, DE GRAÇA, e você sequer teve a decência de se apresentar... Seu login é apenas um monte de números...

É isso mesmo?

Você realmente espera uma resposta de seres humanos programadores aqui do Fórum??

:D

Razão: