Metatrader Forum | Forex Expert-Advisor | Broker & Forex Tools  
Zurück   Metatrader Forum | Forex Expert-Advisor | Broker & Forex Tools > Metatrader 4 > Programmierung MQL4

Programmierung MQL4 Hier gehts rund ums Programmieren in MQL4.

Login
Benutzername:
Kennwort:


Statistik
Themen: 4340
Beiträge: 39881
Benutzer: 6.672
Aktive Benutzer: 195
Links: 80
Wir begrüßen unseren neuesten Benutzer: Rupp
Mit 1.311 Benutzern waren die meisten Benutzer gleichzeitig online (16.09.19 um 01:18).
Neue Benutzer:
vor 2 Tagen
- Rupp
vor 4 Tagen
- walkn
vor einer Woche
- hakanhukum...
vor einer Woche
- Marco_FX
vor einer Woche
- Manoo

Onlineuser
'Wer ist online' anzeigen Benutzer: 2
Gäste: 164
Gesamt: 166
Team: 0
Team:  
Benutzer:  Domke01, traderdoc
Freunde anzeigen

Empfehlungen

Antwort
 
Themen-Optionen Thema durchsuchen Ansicht
  #1 (permalink)  
Alt vor 2 Wochen
Neues Mitglied
 
Registriert seit: Nov 2019
Beiträge: 5
edition87 befindet sich auf einem aufstrebenden Ast
Lightbulb Eine Art Martingale Strategie? Hilfe!

Hallo erst einmal an alle!

ich bin noch sehr neu in dem Thema MQL4 Programmiersprache, aber konnte schon erste Erfolge verzeichnen.
nur komm ich jetzt leider iwie nicht mehr weiter

Mein EA öffnet zu jeder neuen H1 Kerze (Zeitraum ist einstellbar) eine Sell-Order mit einem einstellbaren SL und TP.

Wenn die Sell-Order weder in den SL, noch in den TP wandert, wird sie nach einer Stunde wieder geschlossen.

Wurde die letzte Order nach einer Stunde geschlossen oder ist in den SL gelaufen, Sollen bei der nächsten H1 Kerze 4 identische Sell-Orders ausgelöst.
D.h. gleicher TP, gleicher SL etc.
Sind die 4 Sell-Orders wieder wieder nach einer Stunde geschlossen worden oder in den SL gelaufen, sollen bei der nächsten H1 Kerze 8 Sell Orders geöffnet werden, etc.

-> Da liegt leider auch mein Problem! Mein EA öffnet nicht bei der nächsten H1 Kerze die 4 Orders, sondern sofort nachdem die vorherige Sell-Order denn SL bzw. den TP erreicht hat.
auch der SL, TP wird nur bei der ersten der 4 Orders angepasst.

Hoffentlich konnte ich es verständlich rüber bringen
und vielleicht hat jemand einen Denkanstoß für mich.

Einen Schönen Abend noch
Mit Zitat antworten
  #2 (permalink)  
Alt vor 2 Wochen
Mitglied
 
Registriert seit: Sep 2018
Beiträge: 139
Max2018 befindet sich auf einem aufstrebenden Ast
Standard

mmmh scheint der ganze EA irgendwie nicht richtig aufgesetzt zu sein (Eine Meinung eines Mittelanfängers wie mir )
Mit Zitat antworten
  #3 (permalink)  
Alt vor 2 Wochen
Elite Mitglied
 
Registriert seit: Sep 2015
Beiträge: 829
MA-EA befindet sich auf einem aufstrebenden Ast
Standard

Lad mal hoch.

Aber Martin Gale ist - na ja. Eine richtige schlechte Zeit und man macht mehr Verluste als man je wieder rein holen kann...

Vielleicht könnte man woanders mal nen Diskussion über MG starten.
Mit Zitat antworten
  #4 (permalink)  
Alt vor 2 Wochen
Neues Mitglied
 
Registriert seit: Nov 2019
Beiträge: 5
edition87 befindet sich auf einem aufstrebenden Ast
Standard

Zitat:
Zitat von Max2018 Beitrag anzeigen
mmmh scheint der ganze EA irgendwie nicht richtig aufgesetzt zu sein (Eine Meinung eines Mittelanfängers wie mir )
#
Will ich definitiv nicht abstreiten. Wie bereits erwähnt, bin ich noch nicht sehr lange in der Materie und auf jeden Fall noch in der Lernphase - aber wer ist das nicht.

Hier mal der Code:

Code:
extern int MagicNummer = 12345;
extern int StartHour = 10;
extern int EndHour = 12;
extern double HandelsLots= 0.1, SL_Punkte = 2.5, TP_Punkte = 0.0;

datetime NeueKerze;
bool NeuePeriodeBegonnen, ZeitfensterOffen, ZeitfensterGeschlossen, LongSignal, LastTradeLose;
int CurrentTime, Ticket, ShortOrder;

int openbuy = 0;
int opensell = 0;


//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
   {
      //Überprüfen ob neue Kerze vorliegt:
         if(NeueKerze != Time[0])
            {
               NeuePeriodeBegonnen = true; 
               NeueKerze = Time[0];
               Print("Neue Kerze Vorhanden");
            }
               else NeuePeriodeBegonnen = false;
               Print("Keine Neue Kerze Vorhanden");
               
      //Überprüfen ob wir uns im Zeitfenster befinden:
         CurrentTime = TimeHour(TimeCurrent());
            {
               if((CurrentTime >= StartHour) && (CurrentTime < EndHour))
                  {  
                     ZeitfensterOffen = true; 
                     Print("Zeitfenster geöffnet");
                  }
                     else ZeitfensterOffen = false;
                     Print("Zeitfenster geschlossen");
            }      
       
      //Bedingungen prüfen und Short-Order platzieren:
         if((NeuePeriodeBegonnen == true) && (ZeitfensterOffen == true))
            {
               ShortOrder=OrderSend(Symbol(),OP_SELL,HandelsLots,Bid,100,0.0,0.0,"Trade offen",MagicNummer,0,Blue);
            }  
            
      //SL Short Deals setzen:
         if(OrderSelect(ShortOrder,SELECT_BY_TICKET)==true)
            {
               if(OrderCloseTime()==0 && OrderStopLoss()==0)
                  {
                     double StoppLoss = NormalizeDouble(OrderOpenPrice()+(SL_Punkte/10000),Digits);
                     bool OrderAngepasst = OrderModify(OrderTicket(),OrderOpenPrice(),StoppLoss,OrderTakeProfit(),0,Yellow);          
                  }
            }
                              
      //TP Short Deals setzen:
         if(OrderSelect(ShortOrder,SELECT_BY_TICKET)==true)
            {
               if(OrderCloseTime()==0 && OrderTakeProfit()==0)
                  {
                     double TakeProfit = NormalizeDouble(OrderOpenPrice()-(TP_Punkte/10000),Digits);
                     bool OrderAngepasst = OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),TakeProfit,0,Orange);
                  }
            }
         
      //Neuer Befehl Order max. 1 Stunde geöffnet lassen!
         for(int i = OrdersTotal() - 1; i >= 0; i--)                            
         if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
            {
               if((OrderOpenTime()+3600) < TimeCurrent())
                  { 
                     if (OrderType() == OP_SELL)          
                        {
                           bool Closed = OrderClose(OrderTicket() ,OrderLots(), Bid, 10, Red);  
                           opensell = 0;         
                        }              
                  }
            }
       
   //Wenn letzter Trade nicht in den TP gelaufen ist, beim nächsten Trade 4 Positionen eröffnen
      for (int i = 0; i < 1; i++)                         
         if(OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
            {
               if(OrderProfit()<0.0)
               {
                  ShortOrder=OrderSend(Symbol(),OP_SELL,HandelsLots,Bid,100,0.0,0.0,"Trade offen",MagicNummer,0,Blue);
                  ShortOrder=OrderSend(Symbol(),OP_SELL,HandelsLots,Bid,100,0.0,0.0,"Trade offen",MagicNummer,0,Blue); 
               }              
            }       


      //Ticketnummern nach Closing auf 0 zurücksetzen:
         if(OrderSelect(ShortOrder,SELECT_BY_TICKET)==true)
            {
               if(OrderTicket()>0 && OrderCloseTime()>0) ShortOrder=0;
            }       
   }
Ich bin für jeden Kommentar, von totaler Schrott bis hin zu erste erkennbare Ansätze, dankbar.
Mit Zitat antworten
  #5 (permalink)  
Alt vor 2 Wochen
Elite Mitglied
 
Registriert seit: Sep 2015
Beiträge: 829
MA-EA befindet sich auf einem aufstrebenden Ast
Standard

Wenn bloß zu jeder neuen Stunde geöffnet werden soll, reichts eigentlich Hour() zu speichern.

Ich versteh nicht, wie Du den SL und TP berechnest. Letzterer steht übrigens auf 0.

Wenn Du viele Orders auf ein mal öffnen willst, könntest Du das vielleicht mit ner for Schleife machen.

Aber zur eigentlichen Frage: Wo und wann aktualisierst Du dieses Zeit-Speicher-Array? Ich seh zwar, dass das Ding abgefragt wird, aber der alte Wert wird anscheinend nie durch die neue Stunde ersetzt.
Mit Zitat antworten
  #6 (permalink)  
Alt vor 2 Wochen
Mitglied
 
Registriert seit: Apr 2018
Beiträge: 73
daybyter befindet sich auf einem aufstrebenden Ast
Standard

Die letzte for Schleife zum Eröffnen der 4 Orders läuft von 0 bis 0 ?
Mit Zitat antworten
  #7 (permalink)  
Alt vor 2 Wochen
Neues Mitglied
 
Registriert seit: Nov 2019
Beiträge: 5
edition87 befindet sich auf einem aufstrebenden Ast
Standard

Zitat:
Zitat von MA-EA Beitrag anzeigen
Wenn bloß zu jeder neuen Stunde geöffnet werden soll, reichts eigentlich Hour() zu speichern.
Ja das würde natürlich auch funktionieren und der Code wäre etwas einfacher.

Zitat:
Zitat von MA-EA Beitrag anzeigen
Ich versteh nicht, wie Du den SL und TP berechnest. Letzterer steht übrigens auf 0.
Hier wird der SL und TP gesetzt. Externe Variable.

Code:
 //SL Short Deals setzen:
         if(OrderSelect(ShortOrder,SELECT_BY_TICKET)==true)
            {
               if(OrderCloseTime()==0 && OrderStopLoss()==0)
                  {
                     double StoppLoss = NormalizeDouble(OrderOpenPrice()+(SL_Punkte/10000),Digits);
                     bool OrderAngepasst = OrderModify(OrderTicket(),OrderOpenPrice(),StoppLoss,OrderTakeProfit(),0,Yellow);          
                  }
            }
                              
      //TP Short Deals setzen:
         if(OrderSelect(ShortOrder,SELECT_BY_TICKET)==true)
            {
               if(OrderCloseTime()==0 && OrderTakeProfit()==0)
                  {
                     double TakeProfit = NormalizeDouble(OrderOpenPrice()-(TP_Punkte/10000),Digits);
                     bool OrderAngepasst = OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),TakeProfit,0,Orange);
                  }
            }

Zitat:
Zitat von MA-EA Beitrag anzeigen
Wenn Du viele Orders auf ein mal öffnen willst, könntest Du das vielleicht mit ner for Schleife machen.
Muss ich dann immer abfragen, ob gerade eine Order geöffnet wurde? und wenn ja soll er noch weitere öffnen?

Zitat:
Zitat von MA-EA Beitrag anzeigen
Aber zur eigentlichen Frage: Wo und wann aktualisierst Du dieses Zeit-Speicher-Array? Ich seh zwar, dass das Ding abgefragt wird, aber der alte Wert wird anscheinend nie durch die neue Stunde ersetzt.
Ich hab ein Array? Sorry für die blöde Frage. Da weiß ich dann wohl selbst nicht was ich da für einen Code geschrieben habe.
Was ist denn ein Zeit-Speicher-Array und wo frage ich den ab?
Mit Zitat antworten
  #8 (permalink)  
Alt vor 2 Wochen
Neues Mitglied
 
Registriert seit: Nov 2019
Beiträge: 5
edition87 befindet sich auf einem aufstrebenden Ast
Standard

Zitat:
Zitat von daybyter Beitrag anzeigen
Die letzte for Schleife zum Eröffnen der 4 Orders läuft von 0 bis 0 ?
Wirklich? Dann liegt es daran dass er die letzten geschlossenen Orders nicht richtig zählt.

Code:
for (int i = 0; i < 1; i++)
int i = 0 besagt doch, dass er bei der letzten Order Anfangen soll zu zählen, oder?

i<1 die Bedeutung habe ich noch nicht ganz kapiert

i++ bedeutet er soll vorwärts zählen? Richtig? Dann ist da der Fehler, denn es müsste lauten, i--, oder? Wenn er bei der letzten Order anfängt vorwärts zu zählen, kommt ja logischerweise nichts mehr.
Mit Zitat antworten
  #9 (permalink)  
Alt vor 2 Wochen
Elite Mitglied
 
Registriert seit: Sep 2015
Beiträge: 829
MA-EA befindet sich auf einem aufstrebenden Ast
Standard

SL und TP kann man auf jeden Fall in einem Rutsch nach reichen. Da braucht man nicht 2x OrderSelect() machen.

++ einen int-Wert um 1 erhöhen

-- einen int-Wert um 1 senken


Leider hab ich diese Schleifen nie kapiert. Aber man könnte in den GV festlegen lassen, wie viele Orders auf einmal offen sein sollen. Z.B.

Code:
extern int Max_Offene_Orders = 4;
Dann wie normal Orders zählen lassen. Wenns weniger als Max_Offene_Orders sind, in der Schleife ne Weitere öffnen lassen. i-- nicht vergessen.

Aber wie gesagt bin aus den Schleifen nie schlau geworden. Kann die mal Jemand ganz genau und leicht verständlich erklären?
Mit Zitat antworten
  #10 (permalink)  
Alt vor 2 Wochen
Neues Mitglied
 
Registriert seit: Nov 2019
Beiträge: 5
edition87 befindet sich auf einem aufstrebenden Ast
Standard

Danke für den Hinweis mit dem SL und TP. Da werd ich mich mal dran mach und versuchen wie ich das unter eine OrderSelect Abfrage bekomme

Ich glaube ich habe meine Strategie nicht ganz klar definiert.

Sagen wir mal, um 9 Uhr geht die erste Order in den Markt. Läuft sie in den TP, ist alles fein
Wenn nicht, dann läuft sie höchstwahrscheinlich in den SL oder sie wird eben nach einer Stunde wieder geschlossen. Ganz egal ob mit Gewinn oder Verlust.

Wenn die um 9 Uhr geöffnete Order nicht in den TP läuft, sollen um 10 Uhr 4 Orders mit der selben Lot-Size, dem gleichen TP uns SL ausgeführt werden.
Laufen diese 4 Orders wieder nicht in den TP, sollen um 11 Uhr 13 Orders gleichen Typs ausgeführt werden.
Laufen auch diese wieder nicht in den TP, sollen um 12 Uhr 40 Orders gleichen Typs ausgeführt werden. Usw., usw. ...
Bist halt wieder der TP erreicht. Dann beginnt das Spiel wieder von vorne.

Schematisch so dargestellt:

1 Trade (1 Order) - TakeProfit
2 Trade (1 Order) - TakeProfit
3 Trade (1 Order) - StoppLoss
4 Trade (4 Orders) - StoppLoss
5 Trade (13 Orders) - TakeProfit
6 Trade (1 Order) - ...


Wie gesagt, den ersten Teil konnte ich bereits umsetzten (wahrscheinlich eh das einfachste gewesen)

Aber ich denke, ich muss dann die Orders zählen lassen. Jedenfalls versuche ich dass (mit wenig Erfolg) gerade so umzusetzen.
Mit Zitat antworten
Antwort

Lesezeichen

Stichworte
martingale, orderselect


Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln
Es ist Ihnen nicht erlaubt, neue Themen zu verfassen.
Es ist Ihnen nicht erlaubt, auf Beiträge zu antworten.
Es ist Ihnen nicht erlaubt, Anhänge hochzuladen.
Es ist Ihnen nicht erlaubt, Ihre Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are aus
Pingbacks are aus
Refbacks are aus




Alle Zeitangaben in WEZ +1. Es ist jetzt 17:27 Uhr.


Der Wavesnode - Spam Firewall
-----------------------------------------------------------------------------------------------------------------------------
Powered by vBulletin® Version 3.8.5 (Deutsch)
Copyright ©2000 - 2019, Jelsoft Enterprises Ltd.
Powered by vBCMS® 2.7.0 ©2002 - 2019 vbdesigns.de
SEO by vBSEO 3.6.1
Copyright ©2009 - 2017 by Expert-Advisor.com - Das Metatrader Forum
MetaTrader bzw. MetaTrader 4 und MetaTrader 5 sind eingetragene Marken der MetaQuotes Software Corp.
-----------------------------------------------------------------------------------------------------------------------------