Ordem / Posição - Dobrada FOK/FILLING

 

Boa Tarde Pessoal, Tudo bem ?

Estou com o mesmo problema de varios, estava utilizando "ORDER_FILLING_RETURN" e meu programa enviava ordem de compra/venda em partes, porem na hora de fechar as posições ele acabava enviando ordens também, segue foto

Historico


Atualmente voltei para FOK ( que nunca tive problemas ), segue a programação ( Por favor, se tiver algo errado ou como melhor avisem, agradeço desde já )

Porem gostaria de utilizar a "ORDER_FILLING_RETURN" da forma correta, que não aconteça de enviar ordens "duplicadas eu acho"

Poderiam me ajudar a converter a programação abaixo que está em FOK para "ORDER_FILLING_RETURN" de forma correta ?

void CompraAMercado() // 
  {
   MqlTradeRequest   requisicao;    // requisição
   MqlTradeResult    resposta;      // resposta
   ZeroMemory(requisicao);
   ZeroMemory(resposta);
   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        = SymbolInfoDouble(Symbol(),SYMBOL_ASK);        // Preço para a compra
   requisicao.sl           = tick.last-SL;                                 // Preço Stop Loss
   requisicao.tp           = tick.last+TP;                                 // Alvo de Ganho - Take Profit
   requisicao.deviation    = 10;                                           // Desvio Permitido do preço
   requisicao.type         = ORDER_TYPE_BUY;                               // Tipo da Ordem
   requisicao.type_filling = ORDER_FILLING_FOK;                            // Tipo deo Preenchimento da ordem
   
   int ticket=OrderSend(requisicao,resposta);
   if(ticket<0)
     {
       Print("Erro ao enviar Ordem Compra. Erro = ", GetLastError());
     }
   else
      Print("Ordem de Compra executada com sucesso!");
     }
  
void VendaAMercado()
  {
   MqlTradeRequest   requisicao;    // requisição
   MqlTradeResult    resposta;      // resposta
   ZeroMemory(requisicao);
   ZeroMemory(resposta);
   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        = SymbolInfoDouble(Symbol(),SYMBOL_BID);        // Preço para Venda
   requisicao.sl           = tick.last+SL;                                 // Preço Stop Loss
   requisicao.tp           = tick.last-TP;                                 // Alvo de Ganho - Take Profit
   requisicao.deviation    = 10;                                           // Desvio Permitido do preço
   requisicao.type         = ORDER_TYPE_SELL;                              // Tipo da Ordem
   requisicao.type_filling = ORDER_FILLING_FOK;                            // Tipo deo Preenchimento da ordem
   
   int ticket=OrderSend(requisicao,resposta);
   if(ticket<0)
     {
       Print("Erro ao enviar Ordem Compra. Erro = ", GetLastError());
     }
   else
      Print("Ordem de Compra executada com sucesso!");
     }
 
void FechaCompra()
   {
      MqlTradeRequest   requisicao;    // requisição
      MqlTradeResult    resposta;      // resposta
      ZeroMemory(requisicao);
      ZeroMemory(resposta);
      requisicao.action       = TRADE_ACTION_DEAL;
      requisicao.magic        = magic_number;
      requisicao.symbol       = _Symbol;
      requisicao.volume       = num_lots; 
      requisicao.price        = 0; 
      requisicao.deviation    = 10;                                            
      requisicao.type         = ORDER_TYPE_SELL;
      requisicao.type_filling = ORDER_FILLING_FOK;
         
   int ticket=OrderSend(requisicao,resposta);
   if(ticket<0)
     {
       Print("Erro ao enviar Ordem Compra. Erro = ", GetLastError());
     }
   else
      Print("Ordem de Compra executada com sucesso!");
     }

void FechaVenda()
   {   
      MqlTradeRequest   requisicao;    // requisição
      MqlTradeResult    resposta;      // resposta
      ZeroMemory(requisicao);
      ZeroMemory(resposta);
      requisicao.action       = TRADE_ACTION_DEAL;
      requisicao.magic        = magic_number;
      requisicao.symbol       = _Symbol;
      requisicao.volume       = num_lots; 
      requisicao.price        = 0;
      requisicao.deviation    = 10;                                            
      requisicao.type         = ORDER_TYPE_BUY;
      requisicao.type_filling = ORDER_FILLING_FOK;
   
   int ticket=OrderSend(requisicao,resposta);
   if(ticket<0)
     {
       Print("Erro ao enviar Ordem Compra. Erro = ", GetLastError());
     }
   else
      Print("Ordem de Compra executada com sucesso!");
     }
 
MicheliBarcello:

Boa Tarde Pessoal, Tudo bem ?

Estou com o mesmo problema de varios, estava utilizando "ORDER_FILLING_RETURN" e meu programa enviava ordem de compra/venda em partes, porem na hora de fechar as posições ele acabava enviando ordens também, segue foto


Atualmente voltei para FOK ( que nunca tive problemas ), segue a programação ( Por favor, se tiver algo errado ou como melhor avisem, agradeço desde já )

Porem gostaria de utilizar a "ORDER_FILLING_RETURN" da forma correta, que não aconteça de enviar ordens "duplicadas eu acho"

Poderiam me ajudar a converter a programação abaixo que está em FOK para "ORDER_FILLING_RETURN" de forma correta ?

O SELL "dobrado" não tem nada a ver com tipo de preenchimento, aconteceu 4 segundos depois do primeiro SELL e na minha opinião é erro de lógica.

Se puder anexa o arquivo log do dia 08/04, fica na pasta [ raiz da instância ]\\logs ,  sugiro editar o log para mascarar seu nº de login.

 

Muito Obrigada por me responder, segue abaixo o arquivo log solicitado e segue o meu programa completo.

Agradeço desde já a sua ajudar por solucionar meus problemas.


Log:

MK 0 11:06:58.877 Trades '0000000000': exchange buy 5.00 WINJ20 at market sl: 75400 tp: 77400

QE 0 11:06:58.957 Trades '0000000000': accepted exchange buy 5.00 WINJ20 at market sl: 75400 tp: 77400

DL 0 11:06:58.959 Trades '0000000000': exchange buy 5.00 WINJ20 at market sl: 75400 tp: 77400 placed for execution (Order received. Sending to OMS.)

EH 0 11:06:58.960 Trades '0000000000': order #278706535 buy 5.00 / 5.00 WINJ20 at market done in 88.789 ms

NR 0 11:06:58.960 Trades '0000000000': deal #142889298 buy 2.00 WINJ20 at 76410 done (based on order #278706535)

CP 0 11:06:58.964 Trades '0000000000': deal #142889300 buy 1.00 WINJ20 at 76410 done (based on order #278706535)

HN 0 11:06:58.964 Trades '0000000000': deal #142889302 buy 2.00 WINJ20 at 76410 done (based on order #278706535)

DQ 0 11:14:00.921 Trades '0000000000': exchange sell 5.00 WINJ20 at market

PH 0 11:14:01.529 Trades '0000000000': accepted exchange sell 5.00 WINJ20 at market

MQ 0 11:14:01.530 Trades '0000000000': exchange sell 5.00 WINJ20 at market placed for execution (Order received. Sending to OMS.)

KR 0 11:14:03.734 Trades '0000000000': order #278735104 sell 5.00 / 5.00 WINJ20 at market done in 2814.391 ms

FS 0 11:14:03.735 Trades '0000000000': exchange sell 5.00 WINJ20 at market

QF 0 11:14:04.839 Trades '0000000000': deal #142893892 sell 5.00 WINJ20 at 76650 done (based on order #278735104)

QI 0 11:14:11.642 Trades '0000000000': accepted exchange sell 5.00 WINJ20 at market

LR 0 11:14:11.642 Trades '0000000000': exchange sell 5.00 WINJ20 at market placed for execution (Order received. Sending to OMS.)

QQ 0 11:14:11.777 Trades '0000000000': order #278736000 sell 5.00 / 5.00 WINJ20 at market done in 8046.633 ms

CO 0 11:14:11.778 Trades '0000000000': deal #142893995 sell 5.00 WINJ20 at 76645 done (based on order #278736000)

MF 0 11:53:11.061 Trades '0000000000': exchange buy 5.00 WINJ20 at market, close #278736000 sell 5.00 WINJ20 76645

GE 0 11:53:11.088 Trades '0000000000': accepted exchange buy 5.00 WINJ20 at market, close #278736000 sell 5.00 WINJ20 76645

EH 0 11:53:11.119 Trades '0000000000': exchange buy 5.00 WINJ20 at market, close #278736000 sell 5.00 WINJ20 76645 placed for execution (Order received. Sending to OMS.)

JS 0 11:53:11.121 Trades '0000000000': order #279024270 buy 5.00 / 5.00 WINJ20 at market done in 59.892 ms

FL 0 11:53:11.121 Trades '0000000000': deal #142928521 buy 5.00 WINJ20 at 77190 done (based on order #279024270)


Programa:

#property copyright "Copyright 2019, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"

sinput string s0; //------ Parâmetro Basicos ------
input int num_lots                         = 1;                   // Número de Lotes
input string inicio                        ="08:00";              // Horario Inicio Operações
input string termino                       ="20:30";              // Horario Termino Operações
input string fechamento                    ="20:45";              // Horario Fechamento Ordens

input string s1; //------ Take Profit / Stop Loss ------
input double TP                             = 10000;              // Take Profit
input double SL                             = 10000;              // Stop Loss

//----- Handles e Buffer ----- 

int mm_50_Handle;             
double mm_50_Buffer[];         

int mm_200_Handle;      
double mm_200_Buffer[]; 

int mm_250_Handle;             
double mm_250_Buffer[];

int Esto_Handle;             
double Esto_Buffer[];


// ----- Variáveis para as funçoes -----
 
int magic_number = 01020304; // Nº mágico do robô
MqlRates velas[];            // Variável para armazenar velas
MqlTick tick;                // variável para armazenar ticks
MqlDateTime horario_inicio,horario_termino,horario_fechamento,horario_atual; // Variavel para armazenar horas

// -----  Variáveis para Controle  ----- 

int x=0;

// ----- Inicialização ----- 

int OnInit()
  {
   mm_50_Handle=iCustom(_Symbol,PERIOD_CURRENT,"MM50");
   mm_200_Handle=iCustom(_Symbol,PERIOD_CURRENT,"MM200");
   mm_250_Handle=iCustom(_Symbol,PERIOD_CURRENT,"MM250");
   Esto_Handle=iCustom(_Symbol,PERIOD_CURRENT,"Estocastico");
        
   TimeToStruct(StringToTime(inicio),horario_inicio);         
   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 ( "Parametos de horarios invalidos!" );
      return INIT_FAILED;
     }
   if(horario_termino.hour>horario_fechamento.hour || (horario_termino.hour==horario_fechamento.hour && horario_termino.min>horario_fechamento.min))
     {
      printf("Parametos de horarios invalidos!");
      return INIT_FAILED;
      }
      
   CopyRates(_Symbol,_Period,0,20,velas);
   ArraySetAsSeries(velas,true);
   
   ChartIndicatorAdd(0,0,mm_50_Handle);
   ChartIndicatorAdd(0,0,mm_200_Handle);
   ChartIndicatorAdd(0,0,mm_250_Handle);
   ChartIndicatorAdd(0,1,Esto_Handle);
   
   return(INIT_SUCCEEDED);
   
  }

// ----- Finalização -----

/*
void OnDeinit(const int reason)
  {
     IndicatorRelease(mm_50_Handle);
     IndicatorRelease(mm_200_Handle); 
     IndicatorRelease(mm_250_Handle); 
     IndicatorRelease(Esto_Handle);
  }
*/ 

// ---- Cada Tick ----
    
void OnTick()
  {
   CopyBuffer(mm_50_Handle,0,0,20,mm_50_Buffer);
   CopyBuffer(mm_200_Handle,0,0,20,mm_200_Buffer);
   CopyBuffer(mm_250_Handle,0,0,20,mm_250_Buffer);
   CopyBuffer(Esto_Handle,0,0,20,Esto_Buffer);
   CopyRates(_Symbol,_Period,0,20,velas);
   
   ArraySetAsSeries(mm_50_Buffer,true);
   ArraySetAsSeries(mm_200_Buffer,true);
   ArraySetAsSeries(mm_250_Buffer,true);
   ArraySetAsSeries(Esto_Buffer,true);
   ArraySetAsSeries(velas,true); 
   
   SymbolInfoTick(_Symbol,tick);

   bool temosNovaVela = TemosNovaVela();    
   if(temosNovaVela==true && PositionSelect(_Symbol)==false)
      {
        x=0;
      }   

   bool Comprar = false; 
   bool Vender  = false;   

   bool compra_estrategia =  mm_50_Buffer[1]   < mm_200_Buffer[1] && 
                             mm_200_Buffer[1]  < mm_250_Buffer[1];  
                                                                                                               
   bool  venda_estrategia =  mm_50_Buffer[1]  > mm_200_Buffer[1] && 
                             mm_200_Buffer[1]  > mm_250_Buffer[1];
                          
   Comprar = compra_estrategia;
   Vender  = venda_estrategia;
                               
   if(Comprar==true && PositionSelect(_Symbol)==false && HorarioEntrada()==true && x==0)
      {
        CompraAMercado();
      }
       
   if(Vender==true && PositionSelect(_Symbol)==false && HorarioEntrada()==true && x==0)
      {
        VendaAMercado();
      }
     
    if(PositionSelect(_Symbol)==true)
      {
         x=1;
         saida();
      }   
        
    if(HorarioFechamento())
        {
            x=0;
            if(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();
                  }
              }

        }
 }
 
// --- Complementos ---      
   
void CompraAMercado() 
  {
   MqlTradeRequest   requisicao;    // requisição
   MqlTradeResult    resposta;      // resposta
   ZeroMemory(requisicao);
   ZeroMemory(resposta);
   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        = SymbolInfoDouble(Symbol(),SYMBOL_ASK);        // Preço para a compra
   requisicao.sl           = tick.last-SL;                                 // Preço Stop Loss
   requisicao.tp           = tick.last+TP;                                 // Alvo de Ganho - Take Profit
   requisicao.deviation    = 10;                                           // Desvio Permitido do preço
   requisicao.type         = ORDER_TYPE_BUY;                               // Tipo da Ordem
   requisicao.type_filling = ORDER_FILLING_FOK;                            // Tipo deo Preenchimento da ordem
   
   int ticket=OrderSend(requisicao,resposta);
   if(ticket<0)
     {
       Print("Erro ao enviar Ordem Compra. Erro = ", GetLastError());
     }
   else
      Print("Ordem de Compra executada com sucesso!");
     }
  
void VendaAMercado()
  {
   MqlTradeRequest   requisicao;    // requisição
   MqlTradeResult    resposta;      // resposta
   ZeroMemory(requisicao);
   ZeroMemory(resposta);
   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        = SymbolInfoDouble(Symbol(),SYMBOL_BID);        // Preço para Venda
   requisicao.sl           = tick.last+SL;                                 // Preço Stop Loss
   requisicao.tp           = tick.last-TP;                                 // Alvo de Ganho - Take Profit
   requisicao.deviation    = 10;                                           // Desvio Permitido do preço
   requisicao.type         = ORDER_TYPE_SELL;                              // Tipo da Ordem
   requisicao.type_filling = ORDER_FILLING_FOK;                            // Tipo deo Preenchimento da ordem
   
   int ticket=OrderSend(requisicao,resposta);
   if(ticket<0)
     {
       Print("Erro ao enviar Ordem Compra. Erro = ", GetLastError());
     }
   else
      Print("Ordem de Compra executada com sucesso!");
     }
 
void FechaCompra()
   {
      MqlTradeRequest   requisicao;    // requisição
      MqlTradeResult    resposta;      // resposta
      ZeroMemory(requisicao);
      ZeroMemory(resposta);
      requisicao.action       = TRADE_ACTION_DEAL;
      requisicao.magic        = magic_number;
      requisicao.symbol       = _Symbol;
      requisicao.volume       = num_lots; 
      requisicao.price        = 0; 
      requisicao.deviation    = 10;                                            
      requisicao.type         = ORDER_TYPE_SELL;
      requisicao.type_filling = ORDER_FILLING_FOK;
         
   int ticket=OrderSend(requisicao,resposta);
   if(ticket<0)
     {
       Print("Erro ao enviar Ordem Compra. Erro = ", GetLastError());
     }
   else
      Print("Ordem de Compra executada com sucesso!");
     }

void FechaVenda()
   {   
      MqlTradeRequest   requisicao;    // requisição
      MqlTradeResult    resposta;      // resposta
      ZeroMemory(requisicao);
      ZeroMemory(resposta);
      requisicao.action       = TRADE_ACTION_DEAL;
      requisicao.magic        = magic_number;
      requisicao.symbol       = _Symbol;
      requisicao.volume       = num_lots; 
      requisicao.price        = 0;
      requisicao.deviation    = 10;                                            
      requisicao.type         = ORDER_TYPE_BUY;
      requisicao.type_filling = ORDER_FILLING_FOK;
   
   int ticket=OrderSend(requisicao,resposta);
   if(ticket<0)
     {
       Print("Erro ao enviar Ordem Compra. Erro = ", GetLastError());
     }
   else
      Print("Ordem de Compra executada com sucesso!");
     }

// --- Funções ---

bool HorarioEntrada()
      {
       TimeToStruct(TimeCurrent(),horario_atual);
      if(horario_atual.hour >= horario_inicio.hour && horario_atual.hour <= horario_termino.hour)
   {
      if(horario_atual.hour == horario_inicio.hour)
         if(horario_atual.min >= horario_inicio.min)
            return true;
         else
            return false;
      if(horario_atual.hour == horario_termino.hour)
         if(horario_atual.min <= horario_termino.min)
            return true;
         else
            return false;
      return true;
   }
   return false;
}

bool HorarioFechamento()
     {
      TimeToStruct(TimeCurrent(),horario_atual);
   if(horario_atual.hour >= horario_fechamento.hour)
   {
      if(horario_atual.hour == horario_fechamento.hour)
         if(horario_atual.min >= horario_fechamento.min)
            return true;
         else
            return false;
      return true;
   }
   return false;
}

bool TemosNovaVela()
  {
   static datetime last_time=0;
   datetime lastbar_time= (datetime) SeriesInfoInteger(Symbol(),Period(),SERIES_LASTBAR_DATE);
   if(last_time==0)
     {
      last_time=lastbar_time;
      return(false);
     }
   if(last_time!=lastbar_time)
     {
      last_time=lastbar_time;
      return(true);
     }
   return(false);
  }
  
void saida()
{
      for(int i = PositionsTotal()-1; i>=0; i--)
         {
            string symbol = PositionGetSymbol(i);
            if(symbol == _Symbol)
               {
                  ulong PositionTicket = PositionGetInteger(POSITION_TICKET);
                  double PrecoEntrada = PositionGetDouble(POSITION_PRICE_OPEN);
                  double TakeProfitCorrente = PositionGetDouble(POSITION_TP);
                  if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
                     {
                        if(  tick.last > mm_250_Buffer[1] )
                           {
                              FechaCompra();
                           }                           
                     }
                  if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
                     {
                        if( tick.last < mm_250_Buffer[1] )
                           {
                              FechaVenda();
                           }                           
                     }
               }
         }
}
 
MicheliBarcello:

Muito Obrigada por me responder, segue abaixo o arquivo log solicitado e segue o meu programa completo.

Agradeço desde já a sua ajudar por solucionar meus problemas.



DQ 0 11:14:00.921 Trades '0000000000': exchange sell 5.00 WINJ20 at market

PH 0 11:14:01.529 Trades '0000000000': accepted exchange sell 5.00 WINJ20 at market

MQ 0 11:14:01.530 Trades '0000000000': exchange sell 5.00 WINJ20 at market placed for execution (Order received. Sending to OMS.)

KR 0 11:14:03.734 Trades '0000000000': order #278735104 sell 5.00 / 5.00 WINJ20 at market done in 2814.391 ms

==> FS 0 11:14:03.735 Trades '0000000000': exchange sell 5.00 WINJ20 at market

QF 0 11:14:04.839 Trades '0000000000': deal #142893892 sell 5.00 WINJ20 at 76650 done (based on order #278735104)


Olá,

veja só: O DEAL é quem move a posição da janela de posições abertas para a janela histórico, entre o DONE e o DEAL da ordem #278735104  passaram 1.100 ms e o programa emitiu outro SELL para encerrar o BUY pois a posição estava aberta... Num EA é necessário verificar se o resultado da operação está de acordo com o esperado antes de prosseguir.

 
Rogerio Giannetti Torres:

Olá,

veja só: O DEAL é quem move a posição da janela de posições abertas para a janela histórico, entre o DONE e o DEAL da ordem #278735104  passaram 1.100 ms e o programa emitiu outro SELL para encerrar o BUY pois a posição estava aberta... Num EA é necessário verificar se o resultado da operação está de acordo com o esperado antes de prosseguir.

Lhe enviei uma mensagem no chat, agradeço desde já pelas suas respostas :)

 
Rogerio Giannetti Torres:

Olá,

veja só: O DEAL é quem move a posição da janela de posições abertas para a janela histórico, entre o DONE e o DEAL da ordem #278735104  passaram 1.100 ms e o programa emitiu outro SELL para encerrar o BUY pois a posição estava aberta... Num EA é necessário verificar se o resultado da operação está de acordo com o esperado antes de prosseguir.

Como faço para verificar se o resultado da operação está de acordo ?


No programa utilizamos PositionSelect(_Symbol)==false no caso da função que vende precisariamos utilizar uma para order, como OrderSelect(_Symbol)==false ?


Poderia me ajudar a corrigir meu programa para não fazer duplicadas ?


A função CTrade verifiquei que muitas pessoal utiliza, seria melhor utiliza-la ?


Muito Obrigada

 
MicheliBarcello:


Bom dia Micheli,

eu não testei o programa, somente adaptei para corrigir erros de compilaçao. Seguem minhas sugestões.

1) Você não testou o retorno de nenhuma das funções, como exemplo a carga dos handles dos indicadores, cuidado com isso, toda a chamada de função deve ser verificada.  A negligência costuma cobrar seu preço.


2) Você deve colocar o teste abaixo no programa, pois o EA não está apto para rodar em Hedging.

   if(!AccountInfoInteger(ACCOUNT_MARGIN_MODE) == ACCOUNT_MARGIN_MODE_RETAIL_NETTING)
     {
      Alert("Somente modo NETTING: ");
      return(INIT_FAILED);
     }


3) Eu tenho uma rotina padrão para verificar se a ordem foi enviada, aceita pela B3 e se foi executada corretamente, adaptei a função de compra do seu EA... faça o mesmo para a função de venda e na função de encerramento você tem que fazer pequena alteração no teste da execução.


void CompraAMercado()
  {
   MqlTradeRequest   requisicao;    // requisição
   MqlTradeResult    resposta;      // resposta
   ZeroMemory(requisicao);
   ZeroMemory(resposta);
   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        = SymbolInfoDouble(Symbol(), SYMBOL_ASK);       // Preço para a compra
   requisicao.sl           = tick.last - SL;                               // Preço Stop Loss
   requisicao.tp           = tick.last + TP;                               // Alvo de Ganho - Take Profit
   requisicao.deviation    = 10;                                           // Desvio Permitido do preço
   requisicao.type         = ORDER_TYPE_BUY;                               // Tipo da Ordem
   requisicao.type_filling = ORDER_FILLING_FOK;                            // Tipo de Preenchimento da ordem

   bool ret=OrderSend(requisicao, resposta);
   while(!DoVerificaExecucao(requisicao, resposta) && !IsStopped())
      Sleep(20);
   while(!PositionSelect(_Symbol)) // Aguarda DEAL
      Sleep(20);
   while((PositionGetDouble(POSITION_VOLUME)<num_lots)) Sleep(20); // Aguarda o preenchimento da ordem
   if(PositionGetDouble(POSITION_VOLUME)>num_lots) // Verifica se a posição foi aberta corretamente
   {
         string txt = MQLInfoString(MQL_PROGRAM_NAME) + " requer sua atenção, volume da posição aberta está a maior";
         SendNotification(txt);
         Alert(txt);
         ExpertRemove();
         }
  }
bool DoVerificaExecucao(MqlTradeRequest &requisicao, MqlTradeResult &resposta)
  {
   for(int i = OrdersTotal() - 1; i >= 0; i--)
     {
      if(OrderSelect(OrderGetTicket(i)))
         if(OrderGetString(ORDER_SYMBOL) == _Symbol
            && OrderGetInteger(ORDER_MAGIC) == magic_number
            && OrderGetInteger(ORDER_STATE) == ORDER_STATE_STARTED)
           {
            Sleep(100);
            return(false); // Ordem não verificada
           }
     }
   if(resposta.retcode != 10009 && resposta.retcode != 10008)
     {
      Print(__FUNCTION__ + ": Erro ao emitir ", EnumToString(requisicao.type), ": ", _LastError, " Erro: ", resposta.retcode);
      Sleep(100);
      if(PositionSelect(Symbol()))
        {
         string txt = MQLInfoString(MQL_PROGRAM_NAME) + " requer sua atenção, posição não deveria estar aberta";
         SendNotification(txt);
         Alert(txt);
         ExpertRemove();
        }
      return(true); // Ordem verficada
     }
   if(resposta.deal == 0 && resposta.order == 0)
      return (false); // Ordem não verificada
   Print("/n", MQLInfoString(MQL_PROGRAM_NAME), " ", _Symbol, " ", EnumToString((ENUM_ORDER_TYPE) requisicao.type),
         "Deal ticket: ", IntegerToString(resposta.deal), " Order ticket: ", IntegerToString(resposta.order));
   return(true); // Ordem verificada
 
Rogerio Giannetti Torres:



Bom Dia Rogério, Tudo bem ?

Primeiramente gostaria de lhe agradecer por estar me ajudando, poucos tem a humildade de ajudar apos saber como fazer, muito obrigada.

Fiz as alterações que solicitou só fiquei com duvida na terceira


A primeira e a segunda atualização:

( Dentro do OnInit )

   if(mm_50_Handle < 0 || mm_200_Handle < 0 || mm_250_Handle < 0 || Esto_Handle < 0)
     {
      printf("Parametos de Indicadores invalidos!");
      return INIT_FAILED;
      }

   if(!AccountInfoInteger(ACCOUNT_MARGIN_MODE) == ACCOUNT_MARGIN_MODE_RETAIL_NETTING)
     {
      Alert("Somente modo NETTING: ");
      return(INIT_FAILED);
     }


A terceira atualização, alterei as configuração porem não entendi o porque da sua função "DoVerificaExecucao" logo deixei apenas a função que da o tempo até comprar as unidades solicitadas e na de vender alterei para ">0", está correto dessa forma ?  :


void CompraAMercado() // bser na documentação ordem das variaveis!!!
  {
   MqlTradeRequest   requisicao;    // requisição
   MqlTradeResult    resposta;      // resposta
   ZeroMemory(requisicao);
   ZeroMemory(resposta);
   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        = SymbolInfoDouble(Symbol(),SYMBOL_ASK);        // Preço para a compra
   requisicao.type         = ORDER_TYPE_BUY;                               // Tipo da Ordem
   requisicao.type_filling = ORDER_FILLING_RETURN;                         // Tipo deo Preenchimento da ordem
   
   bool ret = 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();
     }
   while(!PositionSelect(_Symbol)) Sleep(20);
   while((PositionGetDouble(POSITION_VOLUME)<num_lots)) Sleep(20);
  }
  
void VendaAMercado()
  {
   MqlTradeRequest   requisicao;    // requisição
   MqlTradeResult    resposta;      // resposta
   ZeroMemory(requisicao);
   ZeroMemory(resposta);
   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        = SymbolInfoDouble(Symbol(),SYMBOL_BID);        // Preço para Venda
   requisicao.type         = ORDER_TYPE_SELL;                              // Tipo da Ordem
   requisicao.type_filling = ORDER_FILLING_RETURN;                         // Tipo deo Preenchimento da ordem
   
   bool ret = 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();
     }
   while(!PositionSelect(_Symbol)) Sleep(20);
   while((PositionGetDouble(POSITION_VOLUME)<num_lots)) Sleep(20);
  }
 
void FechaCompra()
   {
      MqlTradeRequest   requisicao;    // requisição
      MqlTradeResult    resposta;      // resposta
      ZeroMemory(requisicao);
      ZeroMemory(resposta);
      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;
         
   bool ret = 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();
     }
   while(PositionSelect(_Symbol)) Sleep(20);
   while((PositionGetDouble(POSITION_VOLUME)>0)) Sleep(20);
  }

void FechaVenda()
   {   
      MqlTradeRequest   requisicao;    // requisição
      MqlTradeResult    resposta;      // resposta
      ZeroMemory(requisicao);
      ZeroMemory(resposta);
      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;
   
   bool ret = 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();
     }
   while(PositionSelect(_Symbol)) Sleep(20);
   while((PositionGetDouble(POSITION_VOLUME)>0)) Sleep(20);
  }
Razão: