MetaTrader 5 herunterladen

Komfortables Scalping

10 März 2016, 14:01
Eryomin Sergey
0
531

Einführung

Dieser Artikel beschreibt einen Algorithmus zum Öffnen von Ordern, der es ermöglicht Scalping komfortabler auszuführen. Allerdings kann dieser Algorithmus auch für andere Handelsansätze angewandt werden. Tatsächlich bietet der Artikel ein Verfahren, das einem bei einem derart schnellen Trading hilft.

Im Allgemeinen wird Scalping als eine sehr nervöse Art des Trading betrachtet. Hier ist die Notwendigkeit sehr wichtig, jedes Mal Lot, TakeProfit und StopLosse Ebenen anzugeben, wodurch man von dem Chart abgelenkt wird.

Dieser Artikel ist die Fortsetzung von "Wettmodelle als Mittel zur Entwicklung von "Marktintuition"". Ich empfehle ihn zu lesen, bevor Sie anfangen diesen Artikel zu studieren.

Ich möchte Sie daran erinnern, was Scapling ist. Scalping ist eine Methode des schnellen Trading. In der Regel ist der Gewinn bei einem solchen Trading auf 1-10 Pips (Punkte) festgelegt. Scalping ist bekannt für seine Komplexität, Nervosität und höhere erforderliche Aufmerksamkeit. Manche denke, es ist nicht sicher, manche betrachten es als die vollkommene Überlegenheit. Was mich betrifft, ich werde diese Art des Trading nicht einschätzen - es wird breit diskutiert und jeder hat seine eigene Meinung.



Konzept

Wahrscheinlich jeder Trader hat irgendwann versucht eine Scalping-Strategie zu verwenden. Für einige Trader ist es die bequemste Art zu handeln, für andere - genau das Gegenteil. Einige betrachten Scapling als das interessanteste Trading andere - als eine bloße Zeitverschwendung. Allerdings kann jeder die Notwendigkeit einer erhöhten Aufmerksamkeit auf den Markt und offene Positionen bemerken.

Viele Trader lehnen Scalping einfach deswegen ab, weil es viel Anstrengung und Nerven erfordert. Jedoch, es gibt eine Methode um einem Scalper zu helfen.

Nehmen wir an, ein Trader möchte Scalping mit einer festen Lot-Größe und TakeProfit in jedem Trade verwenden. Es ist offensichtlich sinnvoll, die Notwendigkeit diese Parameter jedes Mal anzugeben zu beseitigen, weil es zusätzliche Zeit benötigt und die Aufmerksamkeit eines Traders von einem Chart wegzieht.

Das bedeutet, wir benötigen ein Werkzeug, das eine Position mit einer festen Lot-Größe und TP/SL Ebenen auf den Befehl des Traders hin öffnet. Die Bedingung des Tool sollte möglichst einfach sein, darüber hinaus sollte es einen Trader minimal von einem Chart ablenken.

Ein solches Werkzeug kann einfach mit MQL4 Mitteln umgesetzt werden.



Umsetzung

Als Grundlage werden wir ein in dem Artikel "Wettmodelle als Mittel zur Entwicklung von "Marktintuition"" beschriebenes Spiel nehmen. Wir werden ein Werkzeug erstellen, das helfen wird das Spiel zu spielen und gleichzeitig zu traden.

Kurze Beschreibung des Spiels. Zwei Pfeile sind auf ein Chart gezeichnet - hoch und runter. Ein Trader löscht einen unnötigen Pfeil, macht somit eine Auswahl, die seine Meinung bezeichnet - ob ein Finanzinstrument steigt oder fällt. Zu Anfang einer neuen Kerze prüft der EA ob die Prognose des Traders richtig oder falsch ist. Die Richtigkeit der Prognose beeinflusst den Spielstand. Darüber hinaus kann der Trader seine Auswahl in einem begrenzten Zeitraum treffen, der geändert werden kann (der Trader entscheidet, ob er es einstellt oder nicht).

Für die Umsetzung zeichnen wir zwei weitere Pfeile einen Balken vor dem aktuellen. Der aktuelle Balken wird dennoch für die Wetten verwendet. Das Löschen eines Pfeils auf dem vorherigen Balken wird ein Signal für den EA sein, eine Position in die benötigte Richtung zu öffnen. darüber hinaus wird der begrenzte Zeitraum zur Auswahl einer Handelsrichtung für das Trading deaktiviert. Es werden die folgenden änderbaren Parameter verfügbar sein: TakeProfit und StopLoss Ebnen, Lot-Größe, akzeptabler Slippage und die Magic Number. Außerdem kann das Trading über eine externe bool-Variable deaktiviert werden, womit der EA nur für Wetten verwendet wird.

Ferner wird beim Öffnen einer Position ein 'buy' oder 'sell' benannter Pfeil auf ein Chart gezeichnet, abhängig von einer zu diesem Zeitpunkt offenen Position. Dies wird gemacht, um das Öffnen neuer Positionen durch den EA auf dieser Kerze zu vermeiden. Dieser Pfeil wird 300 Punkte von dem Balken entfernt gezeichnet, so dass der Benutzer ihn wahrscheinlich nicht bemerkt.

Der EA selbst wird in zwei Blöcke unterteilt - das Spiel und das Öffnen von Positionen. Somit kann ein Leser sehen, was dem Code hinzugefügt wurde.

Also, wir haben den folgenden Programm-Code:

//+------------------------------------------------------------------+
//|                                                       trener.mq4 |
//|                                       Copyright © 2008, FXRaider |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2008, FXRaider"
extern int gap=2;
extern bool Trading=true;
extern int TP=2;
extern int SL=20;
extern double Lots=0.02;
extern int slippage=1;
extern int MagicNumber=777;
extern int time_limit=30;
int start()
  {
//----
//#################################################################################
//####################################### GAME ####################################
//------------------------------
string solution="none"; 
int point, 
    point_neg, 
    point_pos;
//------------------------------    
//+---------------------------------------------------------------+
//|                      "up" choice searching                    | 
 if(
    ObjectGet("up", OBJPROP_PRICE1)==Open[1]+gap*Point
    &&iBarShift(NULL,0,ObjectGet("up",OBJPROP_TIME1))==1
    &&ObjectFind("down") != 0
    &&ObjectFind("up") == 0
    )
    {
     solution="up";
    }
//|                      "up" choice searching                    |  
//+---------------------------------------------------------------+
  
//+---------------------------------------------------------------+
//|                      "down" choice searching                  |     
 if(
    ObjectGet("down", OBJPROP_PRICE1)==Open[1]-gap*Point
    &&iBarShift(NULL,0,ObjectGet("down",OBJPROP_TIME1))==1    
    &&ObjectFind("up") != 0
    &&ObjectFind("down") == 0
    )
    {
     solution="down";
    }
//|                      "down" choice searching                  |       
//+---------------------------------------------------------------+    
 
//+---------------------------------------------------------------+
//|             counting points at a positive answer              |
    if((solution=="up"&&Open[1]<Close[1])
      ||(solution=="down"&&Open[1]>Close[1]))
    {
     point=1;
     point_pos=1;
     point_neg=0;     
    }  
//|             counting points at a positive answer              |   
//+---------------------------------------------------------------+
 
//+---------------------------------------------------------------+
//|             counting points at a negative answer              |    
    if((solution=="up"&&Open[1]>Close[1])
      ||(solution=="down"&&Open[1]<Close[1]))
    {
     point=-1;
     point_pos=0;
     point_neg=1;     
    } 
//|             counting points at a negative answer              |
//+---------------------------------------------------------------+
 
//+----------------------------------------------------------------------------------+
//|                              working with an external file                       |       
      int handle; 
      double points,     //total score
             points_pos, //score of positive answers
             points_neg; //score of negative answers 
       handle=FileOpen("trener_"+Symbol()+"_"+Period()+".csv",
                       FILE_CSV|FILE_WRITE|FILE_READ,";");
       if(handle>0) //if there is a file, read it
       { 
        points=NormalizeDouble(StrToDouble(FileReadString(handle)),Digits); 
        points_pos=NormalizeDouble(StrToDouble(FileReadString(handle)),Digits); 
        points_neg=NormalizeDouble(StrToDouble(FileReadString(handle)),Digits);       
        FileClose(handle);
       } 
       
    if(solution!="none") //if a choice has been made made 
    {        
      handle=FileOpen("trener_"+Symbol()+"_"+Period()+".csv",
                      FILE_CSV|FILE_WRITE|FILE_READ,";");
      FileWrite(handle ,points+point);         //write the total score
      FileWrite(handle ,points_pos+point_pos); //write the score of positive answers
      FileWrite(handle ,points_neg+point_neg); //write the score of negative answers                    
      FileClose(handle); 
    } 
//|                              working with an external file                       | 
//+----------------------------------------------------------------------------------+    
 
//+------------------------------------------------------------------------------------+
//|                                 working with objects                               |   
  if(iBarShift(NULL,0,ObjectGet("down",OBJPROP_TIME1))>0
     ||ObjectGet("down",OBJPROP_PRICE1)!=Open[0]-gap*Point) 
    {
     ObjectDelete("down"); 
    }  
 if(iBarShift(NULL,0,ObjectGet("up",OBJPROP_TIME1))>0
    ||ObjectGet("up",OBJPROP_PRICE1)!=Open[0]+gap*Point)            
    { 
     ObjectDelete("up"); 
    } 
   
  int sec_lim;  
  if(!time_limit)
  {
   sec_lim=0; 
  }
  else
  {
   sec_lim=TimeCurrent()-time_limit;
  }
  if(sec_lim>ObjectGet("up",OBJPROP_TIME1)
     &&sec_lim>ObjectGet("down",OBJPROP_TIME1) 
     &&ObjectFind("down") == 0&&ObjectFind("up") == 0
     &&iBarShift(NULL,0,ObjectGet("down",OBJPROP_TIME1))==0
     &&iBarShift(NULL,0,ObjectGet("up",OBJPROP_TIME1))==0)            
    { 
     ObjectDelete("up"); 
     ObjectDelete("down");      
    } 
  
   if((ObjectFind("down") != 0&&ObjectFind("up") != 0) //if no object
      &&sec_lim<Time[0])
   {
     ObjectCreate("down", OBJ_ARROW, 0, Time[0], Open[0]-gap*Point); //draw a down arrow
     ObjectSet("down", OBJPROP_STYLE, STYLE_DOT);
     ObjectSet("down", OBJPROP_ARROWCODE, SYMBOL_ARROWDOWN);
     ObjectSet("down", OBJPROP_COLOR, Red);
 
     ObjectCreate("up", OBJ_ARROW, 0, Time[0], Open[0]+gap*Point); //draw an up arrow
     ObjectSet("up", OBJPROP_STYLE, STYLE_DOT);
     ObjectSet("up", OBJPROP_ARROWCODE, SYMBOL_ARROWUP);
     ObjectSet("up", OBJPROP_COLOR, Blue);
    }      
//|                                 working with objects                               |   
//+------------------------------------------------------------------------------------+
//####################################### GAME ####################################
//#################################################################################
 
 
//#################################################################################
//#################################### TRADING ####################################
//+------------------------------------------------------------------------------------+  
//|                                working with objects I                              | 
  if(iBarShift(NULL,0,ObjectGet("down_1",OBJPROP_TIME1))>1
  ||ObjectGet("down_1",OBJPROP_PRICE1)!=Open[0]-gap*Point
  ||!Trading)  
  {
   ObjectDelete("down_1"); 
  }  
  
  if(iBarShift(NULL,0,ObjectGet("up_1",OBJPROP_TIME1))>1
  ||ObjectGet("up_1",OBJPROP_PRICE1)!=Open[0]+gap*Point
  ||!Trading)  
  { 
   ObjectDelete("up_1"); 
  } 
  
  if(iBarShift(NULL,0,ObjectGet("sell",OBJPROP_TIME1))>0
  ||ObjectGet("sell",OBJPROP_PRICE1)!=Open[0]-300*Point
  ||!Trading) 
  {
   ObjectDelete("sell"); 
  }
  if(iBarShift(NULL,0,ObjectGet("buy",OBJPROP_TIME1))>0
  ||ObjectGet("buy",OBJPROP_PRICE1)!=Open[0]+300*Point 
  ||!Trading)
  
  {
   ObjectDelete("buy"); 
  } 
  
   if(ObjectFind("down_1") != 0&&ObjectFind("up_1") != 0 && Trading)
   {
     ObjectCreate("down_1", OBJ_ARROW, 0, Time[1], Open[0]-gap*Point);
     ObjectSet("down_1", OBJPROP_STYLE, STYLE_DOT);
     ObjectSet("down_1", OBJPROP_ARROWCODE, SYMBOL_ARROWDOWN);
     ObjectSet("down_1", OBJPROP_COLOR, Red);
 
     ObjectCreate("up_1", OBJ_ARROW, 0, Time[1], Open[0]+gap*Point);
     ObjectSet("up_1", OBJPROP_STYLE, STYLE_DOT);
     ObjectSet("up_1", OBJPROP_ARROWCODE, SYMBOL_ARROWUP);
     ObjectSet("up_1", OBJPROP_COLOR, Blue);
    }  
//|                                working with objects I                              |    
//+------------------------------------------------------------------------------------+     
 if(Trading)
 {
//+----------------------------------------------------------------------------------------------+
//|                              searching open orders for a security                            |
    int pos_sell=0, bar_op_buy, bar_op_sell;
  for (int i_op_sell=OrdersTotal()-1; i_op_sell>=0; i_op_sell--) 
  { 
   if (!OrderSelect(i_op_sell,SELECT_BY_POS,MODE_TRADES)) break; 
   if (Symbol()==OrderSymbol()
   &&(OrderType()==OP_SELLSTOP||OrderType()==OP_SELL)
   &&(OrderMagicNumber()==MagicNumber)
   &&iBarShift(NULL,0,OrderOpenTime())==0)
   {
    pos_sell=1; break;   
   } 
  }
    
    int pos_buy=0;
  for (int i_op_buy=OrdersTotal()-1; i_op_buy>=0; i_op_buy--) 
  { 
   if (!OrderSelect(i_op_buy,SELECT_BY_POS,MODE_TRADES)) break; 
   if (Symbol()==OrderSymbol()
   &&(OrderType()==OP_BUYSTOP||OrderType()==OP_BUY)
   &&(OrderMagicNumber()==MagicNumber)
   &&iBarShift(NULL,0,OrderOpenTime())==0)
   {
    pos_buy=1; break;   
   } 
  }    
//|                              searching open orders for a security                            |
//+----------------------------------------------------------------------------------------------+ 
 
//+------------------------------------------------------------------------------------+  
//|                                working with objects II                             |   
 if(pos_buy==1)
 {   
      ObjectCreate("buy", OBJ_ARROW, 0, Time[0], Open[0]+300*Point);
      ObjectSet("buy", OBJPROP_STYLE, STYLE_DOT);
      ObjectSet("buy", OBJPROP_ARROWCODE, SYMBOL_ARROWUP);
      ObjectSet("buy", OBJPROP_COLOR, Red);
 }
 
 if(pos_sell==1)
 {
      ObjectCreate("sell", OBJ_ARROW, 0, Time[0], Open[0]-300*Point);
      ObjectSet("sell", OBJPROP_STYLE, STYLE_DOT);
      ObjectSet("sell", OBJPROP_ARROWCODE, SYMBOL_ARROWDOWN);
      ObjectSet("sell", OBJPROP_COLOR, Red);    
 }
//|                                working with objects II                             |   
//+------------------------------------------------------------------------------------+ 
  
//+------------------------------------------------------------------------------------+ 
//|                                   opening trades                                   |
double sl_buy, sl_sell;
 if(!SL)
 { 
  sl_buy=0;
  sl_sell=0;
 }
 else
 {
  sl_buy=Ask-SL*Point;
  sl_sell=Bid+SL*Point;
 }
  if(
     ObjectGet("up_1", OBJPROP_PRICE1)==Open[0]+gap*Point
     &&iBarShift(NULL,0,ObjectGet("up_1",OBJPROP_TIME1))==1
     &&ObjectFind("down_1") != 0
     &&ObjectFind("up_1") == 0
     &&!pos_buy
     &&ObjectFind("buy") != 0    
     )
     {
      OrderSend(Symbol(),OP_BUY, Lots,Ask,slippage,sl_buy,Ask+TP*Point,"trener",MagicNumber,0,Blue);            
     }
  if(
     ObjectGet("down_1", OBJPROP_PRICE1)==Open[0]-gap*Point
     &&iBarShift(NULL,0,ObjectGet("down_1",OBJPROP_TIME1))==1
     &&ObjectFind("up_1") != 0
     &&ObjectFind("down_1") == 0
     &&!pos_sell
     &&ObjectFind("sell") != 0
     )
     {
      OrderSend(Symbol(),OP_SELL, Lots,Bid,slippage,sl_sell,Bid-TP*Point,"trener",MagicNumber,0,Red);  
     }
//|                                   opening trades                                   |  
//+------------------------------------------------------------------------------------+   
 }
//#################################### TRADING ####################################
//#################################################################################
 
Comment("Score: ", points," (",points_pos,"/",points_neg,   //displaying score
        ") | Time: ", Hour(),":", Minute(),":", Seconds()); //displaying time (for convenience)
     
   return(0);
  }
//+------------------------------------------------------------------+

Der Code enthält alle notwendigen Kommentare.

Nachdem der Expert Advisor dem Chart hinzugefügt wurde, erhalten wir das Folgende:

Hier sind die beiden letzten Pfeile für das Spiel gedacht, die zwei Pfeile vor ihnen werden zum Öffnen von Positionen verwendet.

Das Löschen eines Pfeils auf der vorherigen Kerze wird die Ausführung der Funktion OrderSend() verursachen und eine entsprechende Position wird geöffnet:

Hier ist die Tabelle der geänderten Eingabeparameter:

Die "gap" Variable ist verantwortlich für die Anzahl an Punkten gleich zu dem Abstand zwischen einem Pfeil und dem Eröffnungskurs einer Kerze. Die Variable "Trading" bezeichnet die Trading-Funktion, "TP" - TakeProfit in Punkten, "SL" - StopLoss in Punkten. Die "Lots" Variable ist verantwortlich für das Volumen geöffneter Positionen, "slippage" bezeichnet den zulässigen Slippage in Punkten, den wir bereit sin zu akzeptieren. "MagicNumber" gibt die Magic Number an, die durch den EA an geöffnete Positionen zugewiesen wird (notwendig für den EA um seine "eigenen" Ordern zu verfolgen). Die "time_limit" Variable bestimmt die Anzahl an Sekunden, innerhalb derer der Benutzer eine Auswahl treffen muss. Ist "0" angegeben, ist die Zeit nicht begrenzt, das heißt, die Auswahl kann während des gesamten Zeitraums getroffen werden, in dem die Kerze sich bildet.



Fazit

Als Ergebnis haben wir die Sicherheit für ein komfortables Trading mit Ordern mit Standard-Parametern (TP, SL, Slippage, Lot-Größe). Dieses Werkzeug kann in jedem Trading nützlich sein. Es ist jedoch am leistungsfähigsten, wenn eine große Anzahl an Positionen in einem kurzen Zeitraum geöffnet wird.

Mit diesem Programm muss ein Trader nicht jedes Mal die Parameter einer geöffneten Order festlegen. Somit ist das Maximum seiner Aufmerksamkeit auf das Chart konzentriert. Dies kann zweifellos dazu beitragen die Effektivität des Trading zu erhöhen.

Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/1509

Beigefügte Dateien |
trener.mq4 (11.66 KB)
MetaTrader 4 für eine Zeitbasierte Muster Analyse verwenden MetaTrader 4 für eine Zeitbasierte Muster Analyse verwenden

Zeitbasierte Musteranalyse kann im Devisenmarkt verwendet werden, um eine bessere Zeit für den Einstieg in einen Trade zu bestimmen, oder eine Zeit, in der Trading insgesamt vermieden werden sollte. Hier verwenden wir MetaTraer 4 zum analysieren historischer Marktdaten und erzeugen Optimierungsergebnisse, die nützlich für den Einsatz in mechanischen Handelssystemen sein können

Trendlinien Indikator unter Berücksichtigung von T. Demarks Ansatz Trendlinien Indikator unter Berücksichtigung von T. Demarks Ansatz

Der Indikator zeigt Trendlinien, welche die jüngsten Ereignisse am Markt anzeigen. Der Indikator wurde unter Berücksichtigung der Empfehlungen und dem Ansatz von Thomas Demark bezüglich der technischen Analyse entwickelt. Der Indikator zeigt beides, sowohl die letzte Trendrichtung, als auch die nächste-zur-letzten entgegengesetzten Richtung des Trends.

MetaEditor: Vorlagen als Verlässlicher Punkt MetaEditor: Vorlagen als Verlässlicher Punkt

Es könnte eine Neuigkeit für unsere Leser sein, dass alle Vorbereitungen zum Schreiben eines EA einmal ausgeführt werden und dann fortlaufend verwendet werden.

Trend-Jagd Trend-Jagd

Der Artikel beschreibt einen Algorithmus der Volumenerhöhung eines Gewinn-Trades. Seine Umsetzung mit MQL4 Mitteln wird in dem Artikel beschrieben.