ForumKategorien

Fragen von Anfängern MQL5 MT5 MetaTrader 5 - Seite 1113

Neuer Kommentar

Grüße. Ich habe mir das kompetente Video "From MQL4 to MQL5 - how to rewrite EAs for Metatrader 5" angesehen.
Vielen Dank an den Autor. Ich habe beschlossen, es selbst zu versuchen. Ich beschloss, es selbst zu versuchen. Die Idee ist die folgende:
1. Ich setze dtriger = 1 in den Eingaben - Kaufen öffnet.
2. Ich setze dtriger = -1 - Verkaufen öffnet.
3. Ich setze dtriger = 0 - alle offenen sind geschlossen.
Ich habe in den FAQ gelesen, dass es im MT5 nicht möglich ist, entgegengesetzte Positionen zu halten,
und ich habe sie.
Frage: Wie kann ich die Schließung einer offenen Position korrekt vorschreiben?
Die Frage ist: Wie registriert man korrekt die Schließung einer bestehenden Position bei der Eröffnung einer umgekehrten Position?
Vielen Dank!

#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());
   }
 } 
 
//+------------------------------------------------------------------+
procom:

Grüße. Ich habe mir den hilfreichen Clip "From MQL4 to MQL5 - how to rewrite EAs for Metatrader 5" angesehen.
Ich möchte den Autor beglückwünschen. Ich habe beschlossen, es selbst zu versuchen. Ich habe es geschrieben. Meine Idee ist die folgende:
1. ich setze dtriger = 1 - eröffnet Kaufen.
2. Ich setze dtriger = -1 - Verkaufen öffnet.
3. Ich setze dtriger = 0 - alle offenen sind geschlossen.
Ich habe in den FAQ gelesen, dass es im MT5 nicht möglich ist, entgegengesetzte Positionen zu halten,
und ich habe sie.
Frage: Wie kann man die Schließung einer bestehenden Position korrekt vorschreiben?
Die Frage ist: Wie registriert man korrekt die Schließung einer bestehenden Position bei der Eröffnung einer umgekehrten Position?
Vielen Dank!

Sie müssen beim Lesen des Merkblatts sehr unaufmerksam gewesen sein.

Bezug:Allgemeine Grundsätze - Handelsgeschäfte.

Fazit: MetaTrader 5 verfügt sowohl überNetting- als auch Hedging-Systeme.

Общие принципы - Торговые операции - MetaTrader 5
Общие принципы - Торговые операции - MetaTrader 5
  • www.metatrader5.com
Перед тем как приступить к изучению торговых функций платформы, необходимо создать четкое представление об основных терминах: ордер, сделка и позиция. — это распоряжение брокерской компании купить или продать финансовый инструмент. Различают два основных типа ордеров: рыночный и отложенный. Помимо них существуют специальные ордера Тейк Профит...

Ich würde Ihre Aufgabe anders formulieren:

1. dtriger = 1 - Buy öffnet.
2. dtriger = -1 - Sell öffnet.
3. dtriger = 0 - alle offenen sind geschlossen.

Der Expert Advisor sollte Folgendes tun:

  • wenn Sie BUY eröffnen müssen, sollten Sie zuerst SELL schließen (geben Sie den Befehl, SELL-Positionen zu schließen - es spielt keine Rolle, ob sie vorhanden sind oder nicht)
  • Wenn Sie SELL eröffnen wollen, müssen Sie zuerst BUY schließen (ein Befehl zum Schließen von BUY-Positionen wird ausgegeben, unabhängig davon, ob sie vorhanden sind oder nicht)
  • wenn der Kunde alle Positionen schließen muss - dann schließen Sie einfach alle Positionen (unabhängig davon, ob sie KAUFEN oder VERKAUFEN)

Für die Umsetzung sind zwei Algorithmen erforderlich (die magische Zahl trägt auch dazu bei) - sie kann deaktiviert werden.

//+------------------------------------------------------------------+
//| 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
  }


Die allgemeine Idee ist, eine Schleife um alle Positionen vonPositionsTotal()-1 bis 0 zu ziehen. Es geht von PositionsTotal()-1 bis 0, nicht von Null bis PositionsTotal()-1. Dies ist wichtig.

Und noch ein Hinweis: Im MetaTrader 5 ist ein Auftrag ein ENTFERNTER AUFTRAG. Daher ist es sehr empfehlenswert, das Wort "Bestellung" in dieser Anfangsphase gar nicht erst in den Mund zu nehmen, um keine Verwirrung in Ihrem Kopf zu stiften.
Vladimir Karputov:
Und noch ein Hinweis: Im MetaTrader 5 ist ein Auftrag ein ENTFERNTER AUFTRAG. Daher ist es sehr empfehlenswert, dass Sie sich das Wort "Bestellung" am Anfang gar nicht merken, um keine Verwirrung in Ihrem Kopf zu stiften.

Es gibt auch Marktaufträge Kaufen und Verkaufen, sowie CloseBy-Aufträge.

Vielen Dank, genau wie die Musik.

procom:

Vielen Dank, genau wie die Musik.

Wenn Sie eine Erklärung zu meinen Codes benötigen, fragen Sie bitte.

Nun, wenn Sie so freundlich wären, dann mehr.
Ich habe die Eingaben gemacht und einen Pre-Close vorgeschrieben, aber wieder hängen die Aufträge dort und dort. 

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

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    +++++
         }
      }
   }
procom:

Nun, wenn Sie so freundlich wären, dann mehr.
Ich habe die Einträge eingefügt und einen Pre-Close vorgeschrieben, aber auch hier gibt es hier und da Hanging Orders.

Die Schließ- und Öffnungsvorgänge müssen voneinander getrennt werden, d. h. diese Vorgänge dürfen nicht in einem Heap durchgeführt werden.
Ein Beispielplan: OnTick() überprüft zunächst drei Flags: ExtNeedCloseBuy, ExtNeedCloseSell und ExtNeedCloseAll.
Und erst dann prüfen wir zwei Flaggen: ExtNeedOpenBuy und ExtNeedOpenSell.
Auf diese Weise wird alles in einer strikten Reihenfolge ablaufen.
Und ja, es gibt keine Aufträge: Es gibt offene Positionen.
procom:

Vielen Dank, genau wie die Notizen.

Was ist das Signal zum Öffnen? Denn der Code ist nicht vollständig - nur die Schließung von Positionen, aber ich muss auch Positionen öffnen...


Handelsbefehl.mq5
#Eigenschaft Version "1.000"

Bislang werden nur drei Aktionen durchgeführt:

  • Alle Käufe schließen
  • Alle Verkäufe schließen
  • Alle Käufe und Verkäufe schließen
Take Profit, Stop Loss und Trailing sind bereits integriert. Das Einzige, was fehlt, ist die Beschreibung von Signalen zur Eröffnung von Positionen.
Совершение сделок - Торговые операции - MetaTrader 5
Совершение сделок - Торговые операции - MetaTrader 5
  • www.metatrader5.com
Торговая деятельность в платформе связана с формированием и отсылкой рыночных и отложенных ордеров для исполнения брокером, а также с управлением текущими позициями путем их модификации или закрытия. Платформа позволяет удобно просматривать торговую историю на счете, настраивать оповещения о событиях на рынке и многое другое. Открытие позиций...
Dateien:
Trade_command.mq5  103 kb
1...110611071108110911101111111211131114111511161117111811191120...1504
Neuer Kommentar