Perguntas de Iniciantes MQL5 MT5 MetaTrader 5 - página 1113

[procom]

Saudações. Assisti ao vídeo competente "From MQL4 to MQL5 - how to rewrite EAs for Metatrader 5".
Muito obrigado ao autor. Decidi experimentá-lo eu próprio. Decidi experimentá-lo eu próprio. A ideia é a seguinte:
1. Coloco dtriger = 1 nas entradas - A compra abre.
2. Coloco dtriger = -1 - A venda abre.
3. Eu configuro dtriger = 0 - todos os abertos são fechados.
Li nos manuais MT5 que não é possível manter posições opostas,
e eu tenho-as.
Pergunta: Como posso prescrever correctamente o encerramento de uma posição aberta
A questão é: Como registar correctamente o encerramento de uma posição existente ao abrir uma posição invertida?
Muito obrigado.

#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\OrderInfo.mqh>

CPositionInfo   o_position;
CTrade        o_trade;
CSymbolInfo        o_symbol;
COrderInfo         o_order;

input int          triger            = 0;
input double    StartLot             = 0.01;
input double    lpos_volume       = 1.0;
input int          Step         = 10;
input int          MagicNumber    = 12345;      //      Magic   nuaber
input int          Slippage          = 30;         //   slippage

int dtriger;
int dStep;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   dStep = Step ;
   dtriger = triger ;

   if (!o_symbol.Name(Symbol()))
     return(INIT_FAILED);
   
   RefreshRates();
   
   o_trade.SetExpertMagicNumber(MagicNumber) ;

   if (IsFillingTypeAllowed(o_symbol.Name(), SYMBOL_FILLING_FOK))
   { 
      o_trade.SetTypeFilling(ORDER_FILLING_FOK);
   }
   else if (IsFillingTypeAllowed(o_symbol.Name(), SYMBOL_FILLING_IOC))
   { 
      o_trade.SetTypeFilling(ORDER_FILLING_IOC);
   }
   else 
   {
      o_trade.SetTypeFilling(ORDER_FILLING_RETURN);
   }
      o_trade.SetDeviationInPoints(Slippage);
   
   if (o_symbol.Digits() == 3 || o_symbol.Digits() == 5 )
   {
      dStep = 10 ;
   }
   
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
      datetime              lpos_time          =        0;
      double                lpos_price_open    =        0.0;
      ENUM_POSITION_TYPE   lpos_type           =        -1;
      int                      pos_count               =        0;
      double                sum_profit         = 0;
 
   for (int i = PositionsTotal() - 1; i>=0; i--)
   {
      if (o_position.SelectByIndex(i))
      {
         if (o_position.Symbol() == o_symbol.Name() && o_position.Magic() == MagicNumber)
         {
            if (o_position.Time() > lpos_time)
            {  
               lpos_time       = o_position.Time();            //OrderOpenTime();
               lpos_price_open = o_position.PriceOpen();       //OrderOpenPrice();
               lpos_type       = o_position.PositionType() ;   //OrderTipe();
             }  
            
            pos_count++;
            sum_profit = sum_profit + o_position.Commission() + o_position.Swap() + o_position.Profit() ;
          }     
       }     
    }          

   // Считаем кол-во отложенных ордеров
  int stop_count=0;

   for (int i=OrdersTotal()-1; i >=0; i--) 
   {
      if (o_order.SelectByIndex(i)) 
      {
         if (o_order.Symbol() == o_symbol.Name() && o_order.Magic() == MagicNumber) 
           stop_count++;
      }
   }

   if (!RefreshRates())
     return ;
     
   if(dtriger == 0 )
   {
      CloseAll();
      return;               
   } 
   
  // + -----    Откраваем Первый ордер   ++++++++++
 if (pos_count == 0  && stop_count == 0    )
   {
      if ( dtriger == -1 &&  lpos_type != POSITION_TYPE_SELL)
      {
         o_trade.Sell(StartLot * lpos_volume , o_symbol.Name());  //   S E L L   11111
      }
      
      if ( dtriger == 1 &&  lpos_type != POSITION_TYPE_BUY )
      {
         o_trade.Buy(StartLot * lpos_volume , o_symbol.Name());   //   B U Y    11111
      }
   }
                          

// +  -----   Переворот    ++++++++++++++++++++++++++++   

if (pos_count>0)
   {
      if(lpos_type == POSITION_TYPE_BUY )
      {
         if ( dtriger == -1 )
         {
         o_trade.Sell(StartLot * lpos_volume , o_symbol.Name());   //   S E L L   +++++
         }
      }

      if (lpos_type==POSITION_TYPE_SELL )
      {
         if ( dtriger == 1 )
         {
         o_trade.Buy(StartLot * lpos_volume , o_symbol.Name());       //   B U Y    +++++
         }
      }
   }


   if(pos_count>0 && stop_count>0) 
     DeleteStopOrders() ;
  
} 
//-----------------------------------------------------------
bool RefreshRates()
{
   if (!o_symbol.RefreshRates())
     return(false) ;
     
    if (o_symbol.Ask() == 0 || o_symbol.Bid() == 0)
      return(false);
      
    return(true);
}  
//---  --------------------------------------------------------- 
 bool IsFillingTypeAllowed (string symbol, int fill_type)
{ 
   int filling = (int)SymbolInfoInteger(symbol, SYMBOL_FILLING_MODE); 
 
   return((filling && fill_type) == fill_type) ;
} 
 
 //  -------------------------------------------------- 
   void CloseAll()
{
   for (int index = PositionsTotal()-1; index >=0; index--)
   {
      if (o_position.SelectByIndex(index))
      {
         if (o_position.Symbol() == o_symbol.Name() && o_position.Magic() == MagicNumber)
         {
            o_trade.PositionClose(o_position.Ticket());
         }
      }  
    } 
 } 
  
 //----------------------------------------------------------- 
 // Delete all pending orders
 //-------------------------------------
 void DeleteStopOrders()
 {
    for (int i = OrdersTotal() - 1; i >= 0; i-- ) 
   {
      if (o_order.SelectByIndex(i))
         if(o_order.Symbol() == o_symbol.Name() && o_order.Magic() == MagicNumber)
            o_trade.OrderDelete(o_order.Ticket());
   }
 } 
 
//+------------------------------------------------------------------+

[Vladimir Karputov]

procom:

Saudações. Observei o útil clip "From MQL4 to MQL5 - how to rewrite EAs for Metatrader 5".
Gostaria de felicitar o autor. Decidi experimentá-lo eu próprio. Fui eu que o escrevi. A minha ideia é a seguinte:
1. eu configuro dtriger = 1 - abre Comprar.
2. Coloco dtriger = -1 - A venda abre.
3. Eu configuro dtriger = 0 - todos os abertos são fechados.
Li nos manuais MT5 que não é possível manter posições opostas,
e eu tenho-as.
Pergunta: Como posso prescrever correctamente o encerramento de uma posição aberta
A questão é: Como registar correctamente o encerramento de uma posição existente ao abrir uma posição invertida?
Muito obrigado.

Deve ter sido muito desatento ao ler a ficha informativa.

Referência:Princípios gerais - Operações comerciais.

Conclusão: MetaTrader 5 tem ambos ossistemas Netting e Hedging.

[Vladimir Karputov]

Formularia a sua tarefa de forma diferente:

1. dtriger = 1 - Compra abre.
2. dtriger = -1 - Venda abre.
3. dtriger = 0 - todos os abertos são fechados.

O Conselheiro Especialista deve fazer o seguinte:

• se precisar de abrir COMPRAR - deve primeiro fechar VENDA (emitir um comando para fechar posições de VENDA - não importa se elas estão lá ou não)
• se precisar de abrir VENDA - então primeiro precisa de fechar COMPRAR (será emitido um comando para fechar posições de COMPRAR, independentemente de estarem ou não lá)
• se o cliente precisar de fechar tudo - então basta fechar todas as posições (não importa se COMPRAR ou VENDER)

São necessários dois algoritmos para a implementação (o número mágico também contribui aqui) - pode ser desactivado.

//+------------------------------------------------------------------+
//| Close positions                                                  |
//+------------------------------------------------------------------+
void ClosePositions(const ENUM_POSITION_TYPE pos_type)
  {
   for(int i=PositionsTotal()-1;i>=0;i--) // returns the number of current positions
      if(m_position.SelectByIndex(i))     // selects the position by index for further access to its properties
         if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)
            if(m_position.PositionType()==pos_type) // gets the position type
               m_trade.PositionClose(m_position.Ticket()); // close a position by the specified symbol
  }

и

//+------------------------------------------------------------------+
//| Close all positions                                              |
//+------------------------------------------------------------------+
void CloseAllPositions(void)
  {
   for(int i=PositionsTotal()-1;i>=0;i--) // returns the number of current positions
      if(m_position.SelectByIndex(i))     // selects the position by index for further access to its properties
         if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)
            m_trade.PositionClose(m_position.Ticket()); // close a position by the specified symbol
  }

A ideia geral é fazer um loop em torno de todas as posições dePositionsTotal()-1 a 0. É de PositionsTotal()-1 a 0, não de zero a PositionsTotal()-1. Isto é importante.

[Vladimir Karputov]

Também uma palavra de conselho: ao trabalhar no MetaTrader 5, uma ordem é uma PEDIDO REMOVIDO. Por conseguinte, é altamente recomendável que não mencione sequer a palavra "ordem" nesta fase inicial, de modo a não criar confusão na sua mente.

[Artyom Trishkin]

Vladimir Karputov:
Também uma palavra de conselho: ao trabalhar no MetaTrader 5, uma ordem é uma PEDIDO REMOVIDO. Por conseguinte, é altamente recomendável que nem sequer se lembre da palavra "ordem" no início, de modo a não criar confusão na sua mente.

Há também ordens de mercado de Compra e Venda, bem como de FecharPor ordens.

[procom]

Muito obrigado, tal como a música.

[Vladimir Karputov]

procom:

Muito obrigado, tal como a música.

Se precisar de uma explicação dos meus códigos, por favor peça.

[procom]

Bem, se quiserem ser tão gentis, mais então.
Introduzi as entradas e prescrevi um pré-encerramento, mas mais uma vez as ordens estão penduradas ali e ali.

// +  -----   Переворот    ++++++++++++++++++++++++++++   

if (pos_count>0)
   {
      if(lpos_type == POSITION_TYPE_BUY )
      {
         if ( dtriger == -1 )
         {
         o_trade.PositionClose(o_symbol.Name());
         }
         {
         o_trade.Sell(StartLot * lpos_volume , o_symbol.Name());   //   S E L L   +++++
         }
      }

      if (lpos_type==POSITION_TYPE_SELL )
      {
         if ( dtriger == 1 )
         {
         o_trade.PositionClose(o_symbol.Name());
         }
         {
         o_trade.Buy(StartLot * lpos_volume , o_symbol.Name());       //   B U Y    +++++
         }
      }
   }

[Vladimir Karputov]

procom:

Bem, se quiserem ser tão gentis, mais então.
Inseri as entradas e prescrevi um pré-encerramento, mas mais uma vez há ordens de enforcamento aqui e ali.

As operações de fecho e abertura precisam de ser separadas, ou seja, não realizar estas operações numa pilha.

Um plano de amostra: OnTick() verifica primeiro três bandeiras: ExtNeedCloseBuy, ExtNeedCloseSell e ExtNeedCloseAll.

E só então verificamos duas bandeiras: ExtNeedOpenBuy e ExtNeedOpenSell.

Desta forma, tudo funcionará numa ordem rigorosa.

E sim, não há ordens: há posições em aberto.

[Vladimir Karputov]

procom:

Muito obrigado, tal como as notas.

Qual é o sinal para abrir? Porque o código não está completo - apenas posições de fecho, mas também preciso de abrir posições...

Comando comercial.mq5
#propriedade versão "1.000

Até agora, apenas realiza três acções:

• Fechar todas as compras
• Fechar todas as vendas
• Fechar todas as compras e vendas

O Take Profit, Stop Loss e Trailing já estão incorporados. A única coisa que falta é a descrição dos sinais para posições abertas.