Hallo liebe Forumsmitglieder,

 

seit Wochen plagt mich die Idee eines EA's der als eine Art Gridstrategie mit abgehedgter Martingalefunktion arbeiten soll.

Übrigens...wer meint, dass man Martingale mit Martingale zwangsläufig irgendwann verliert wird sicherlich recht haben...das denke ich auch, aber wenn man sich eine Schwäche vielleicht zu nutzen machen kann ist dies schon ein enormer Erfolg :)

 

Dies möchte ich gerne technisch umsetzen, aber die Kenntnisse dazu fehlen mir.

Natürlich muss ich gestehen, dass es mir schwer fällt eine gute Idee posten zu wollen und jeder andere kann davon profitieren, aber auf der anderen Seite bleibt mir nichts anderes übrig (sofern ich nicht Unmengen an Geld los werden will, etc um die Strategie programmieren zu lassen.

 

Gerne würde ich einfach kurz anreissen worum es bei diesem EA geht:

Es werden 2 Positionen eröffnet...sowohl long als auch short. TP und SL sind fixe Werte. Sollte der Kurs eine bestimmte Richtung einschlagen werden 2 neue Positionen eröffnet...Long und Short, aber mit einem LotsizeFaktor von x in "Trendrichtung" und der hälfte des Lots aus der Trendrichtung als Hedge.

Anders soll das System nicht laufen...natürlich gibt es hier noch ein paar andere Dingedie Berücksichtigt werden müssen, aber gerne würde ich hier jemanden finden, der ehrlich ist und auch Lust dazu hat das ganze anzugehen. Einen Teil der Programmierung habe ich bereits geleistet, aber das Herzstück fehlt...

 

Ich weiß, dass das beschriebene noch nicht ausreicht um wirklich eine Vorstellung meiner Idee haben zu können, aber bisher bin ich der festen Meinung, dass es sich hier um eine CashCow handeln kann...

 

Wer Interesse hat mehr zu erfahren und mir vll einen Einblick gewähren kann was er/sie bisher programmieren konnte darf mich gerne anschreiben.

 

Vielen Dank und Grüße

 

Marc

Hi,

ich schau mir gerade den Code durch und schreib einfach mit was mir auffällt/einfällt:

• Deine "running" Variable in der start() soll verhindern das start zweimal parallel ausgeführt wird oder? Das wird es bei MQL sowieso nicht. start() wird bei jedem tick ausgeführt sofern die vorherige Ausführung bereits beendet ist. Sprich es kann dir passieren das du ticks nicht mitbekommst wenn start() zu lange braucht, aber nicht das start() zweimal parallel läuft.
• deine OpenLong/Short dürfte dir Probleme machen: Wwenn du l_sl 0 übergibst (weil du vermutlich keinen SL haben willst), sendest du aber den SL am Bid mit. Sprich wenn die Order überhaupt rausgeht (und nicht wegen StopLevel einen Error kriegt) wird sie sofort wieder am SL geschlossen.
• dann kommt zu tragen das deine OpenLong/Short keinerlei Errorhandling hat. Schau einfach mal ins Kitchenframework bzw. die TB.
• du schließt die order nirgends. du gibst den TP beim initial mit, aber im SL Fall bzw. die Trend-Trades werden nie geschlossen oder?

zum funktionellen:

Du speicherst dir derzeit den startpunkt und rechnest jedesmal wo der nächste grideinstieg wäre. Damit hast du die von dir beschriebenen Schwierigkeiten. Aber der Startpunkt interessiert dich doch gar nicht oder? Du willst wissen wo du wieder rein musst. Es würde als reichen wenn du dir nach jedem Einstieg (Initial oder Trend) die 2 Level für den nächsten Einstieg speicherst. Wenn dann der LongLevel überschritten oder der ShortLevel unterschritten wird, steigst du ein und setzt die Level neu.

bzgl. Lot: Beim initialTrade setzt du einfach eine Variable Lot auf den Einstiegswert. Und vor jedem Trendeinstieg aktualisierst du diese Variable. Ich hab jetzt ehrlich gesagt deine Loterhöhung nit ganz im Kopf sonst würd ich dir ein codebeispiel geben.

hth

 

bzgl. korrektur: bei mir war davor der gesamte code mit

durchzogen. Die leerzeichen scheint der Editor rausgeworfen zu haben. ich probiers nochmal ;)

EDIT: jetzt sollts besser aussehen

Bei

void LongClose()

und

void ShortClose()

stimmen die Klammern nicht.

Bei den beide if abfragen fehlen jeweils 2 Klammer zu "))" //sollte also 3 Klammern sein am Ende der Zeile.

 

btw. Mit welchem Editor schreibst du eigentlich? Besonders das Highlighting und Klammerzugehörigkeiten vom mql Editor war überhaupt nicht gut (Stand vor 3 Jahren). Es fehlt einfach. Ansonsten auf dem ersten Blick sehr aufgeräumter gut strukturierter code.

 

 

 

EDIT: @"wer auch immer die Korrektur der Anzeige des Code im Beitrag #49 gemacht hat"

Code #49 vor der Korrektur im Thread waren zwar die <div> zu sehen jedoch stimmten die Abstände (im code). Die div konnte man innerhalb von 5 sek beheben.

Jetzt nach der Korrektur sehe ich zwar die div nicht jedoch stimmen die Abstände nicht mehr und ist nicht innerhalb von kurzer Zeit zu beheben -> somit für Leute die damit arbeiten/helfen wollen unmöglich gemacht worden.

 

Danke für den Hinweis,,,habe habe gestern gezählt und gezählt und es kam nichts bei herum...Habe die beiden Klammern nun am ende ergänzt.

 

Jetzt bekomme ich den Fehler:

'CountLong' - comparison expression expected.

Das gleiche ebenfalls für die CountShort...

 

Den Editor den ich nehme ist der Standardeditor aus dem Metatrader...wusste nicht, dass es noch mehr da gibt...habe nun mal SCITE herunter geladen. Gibt es noch welche die man empfehlen kann?

Jetzt bekomme ich den Fehler:

'CountLong' - comparison expression expected.

Das gleiche ebenfalls für die CountShort...

 

Das liegt daran das nicht am Ende 2 Klammern gehören. Beim Aufruf von CountLong fehlt die abschließende Klammer und dann eine am Ende des if.

Aber da du die Closefunktionen nicht aufrufst kannst du sie auch gleich ganz löschen ;)

Hi Mythos,

 

ich versuche mal auf das von Dir einzugehen sofern ich es denn verstanden habe...also:

Deine "running" Variable in der start() soll verhindern das start zweimal parallel ausgeführt wird oder? Das wird es bei MQL sowieso nicht. start() wird bei jedem tick ausgeführt sofern die vorherige Ausführung bereits beendet ist. Sprich es kann dir passieren das du ticks nicht mitbekommst wenn start() zu lange braucht, aber nicht das start() zweimal parallel läuft.

--> Ich würde einfach die Start soweit ändern, als dass ich Running gar nicht einfüge oder? Allerdings sollte zuerst die init() checken ob ich handeln darf oder nicht...wenn ja dann soll der in die start() springen um den eigentlichen EA laufen zu lassen

deine OpenLong/Short dürfte dir Probleme machen: Wwenn du l_sl 0 übergibst (weil du vermutlich keinen SL haben willst), sendest du aber den SL am Bid mit. Sprich wenn die Order überhaupt rausgeht (und nicht wegen StopLevel einen Error kriegt) wird sie sofort wieder am SL geschlossen.

--> Wenn ich den SL gar nicht haben will was machen ich denn da am besten? aus l_sl einfach 0 oder l_sl weg lassen? aber dann passt die Reihenfolge ja gar nicht mehr denke ich.

dann kommt zu tragen das deine OpenLong/Short keinerlei Errorhandling hat. Schau einfach mal ins Kitchenframework bzw. die TB.

--> Ich habe bisher noch nie mit Fehleranzeigen gearbeitet und habe wahrscheinlich noch große Probleme damit diese zu implementieren...das würde ich im Anschluss machen wenn das Teil läuft...aber gut wenn ich die Fehler nicht kenne und mich frage warum es nicht läuft habe ich auch nichts gewonnen.

du schließt die order nirgends. du gibst den TP beim initial mit, aber im SL Fall bzw. die Trend-Trades werden nie geschlossen oder?

--> Genau...also ich gebe den TP nur beim Initialtrade vor...wenn einer von den beiden geschlossen wird, dann sollen automatisch alle anderen Order geschlossen werden...siehe in der start() funktion unter dem running:

 
//---alle anderen Positionen werden zum Marktpreis geschlossen wenn der TP erreicht wurde
void LongClose()
{
   if (CountLong(m_Magicnumber_long >= 1 && m_Magicnumber_short == 0 && initialpositioniert == true && OrderSymbol() == Symbol() && OrderMagicNumber() == m_Magicnumber_long && (OrderType()==OP_BUY))) //Wenn m_Magicnumber_long größer/gleich 1 ist und m_Magicnumber_short gleich 0 ist und initialpositioniert den Wert true hat etc., dann...
    {
     OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), m_Slippage, Red); //...wird wenn es sich um OP_Buy Orders handelt alle offenen Long Positionen geschlossen
    }
}
void ShortClose()
{
   if (CountLong(m_Magicnumber_long == 0 && m_Magicnumber_short >= 1 && initialpositioniert == true && OrderSymbol() == Symbol() && OrderMagicNumber() == m_Magicnumber_short && (OrderType()==OP_SELL))) //Wenn m_Magicnumber_long gleich 0 ist und m_Magicnumber_short größer/gleich 1 und initialpositioniert den Wert wahr hat etc., dann...
   {
    OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), m_Slippage, Red); //...wird wenn es sich um OP_Sell Orders handelt alle offenen Short Positionen geschlossen
   }
}
Wenn ich also keine Short Positionen mehr im Markt (weil der TP erreicht wurde habe dann sollen alle Long Positionen geschlossen werden. Umgekehrt gilt dies für die LongPositionen...

zum funktionellen:

 

Du speicherst dir derzeit den startpunkt und rechnest jedesmal wo der nächste grideinstieg wäre. Damit hast du die von dir beschriebenen Schwierigkeiten. Aber der Startpunkt interessiert dich doch gar nicht oder? Du willst wissen wo du wieder rein musst. Es würde als reichen wenn du dir nach jedem Einstieg (Initial oder Trend) die 2 Level für den nächsten Einstieg speicherst. Wenn dann der LongLevel überschritten oder der ShortLevel unterschritten wird, steigst du ein und setzt die Level neu.

--> Es ist prinzipiell egal ob ich das so oder so rechne (denke ich). Im Endeffekt benötige ich 3 Werte..Initialwert und die dazugehörigen Ranges...Bei der Umkehr muss ich ja wieder über den Initialwert die Umkehrtrades machen...also ist der schon wichtig...

bzgl. Lot: Beim initialTrade setzt du einfach eine Variable Lot auf den Einstiegswert. Und vor jedem Trendeinstieg aktualisierst du diese Variable. Ich hab jetzt ehrlich gesagt deine Loterhöhung nit ganz im Kopf sonst würd ich dir ein codebeispiel geben.

--> Ein Beispiel wäre toll :) derzeit habe ich einen Lotfaktor von 0.75..1.5 hatte ich vorher mit den ganzen Hedgepositionen...aber die habe ich ja nun ausgespart...

 

Viele Grüße und Dankeschön

Bearbeitet 16. Dezember 201213 Jr. von Mythos
quote tags korrekt gesetzt. Bitte nie innerhalb des Zitats anworten!

Das liegt daran das nicht am Ende 2 Klammern gehören. Beim Aufruf von CountLong fehlt die abschließende Klammer und dann eine am Ende des if.

Aber da du die Closefunktionen nicht aufrufst kannst du sie auch gleich ganz löschen ;)

Jetzt bin ich verwirrt...also die beiden Klammern die ich ergänzt habe brauche ich also gar nicht...statt 3 Klammern gehört da also wieder eine hin?

Dann habe ich den gleichen Fehler wie vorher

Die OrderClosefunktion rufe ich doch über die if-Bedingung auf...ich gebe ja vor wann orderClose starten soll...

Jetzt bin ich verwirrt...also die beiden Klammern die ich ergänzt habe brauche ich also gar nicht...statt 3 Klammern gehört da also wieder eine hin?

Dann habe ich den gleichen Fehler wie vorher

Die OrderClosefunktion rufe ich doch über die if-Bedingung auf...ich gebe ja vor wann orderClose starten soll...

Jetzt habe ich es...

 

int start()
{
  if (running == false) 
   {
    running = true;
    cmd = "";
    if (BotDarfHandeln() == true) //Wenn der EA handeln darf, dann..
     {
     cmd = cmd + "\nDer Bot handelt"; //befindet dieser sich in seiner Handelszeit
      if (initialpositioniert == true && CountLong(m_Magicnumber_long) == 0 && CountShort(m_Magicnumber_short) == 0) //Wenn initialpositioniert den Wert wahr hat und CountLong gleich 0 ist und CountShort gleich 0, dann...
      {
       initialpositioniert = false; //setze initialpositioniert auf false
      }
      if (initialpositioniert == false) //Wenn initialpositioniert gleich false ist, dann
      {
       Initialpositionierung(); //springe zu Initialpositionierung
      }
      if (initialpositioniert == true && CountLong(m_Magicnumber_long) >=1 && CountShort(m_Magicnumber_short) >= 1) //Wenn initialpositioniert den Wert wahr hat und CountLong größer/gleich 1 und CountShort größer/gleich 1, dann...
      {
       Trendfolge_Trades(); //Springe zu Trendfolge_Trades
      }
      if (CountLong(m_Magicnumber_long) >= 1 && m_Magicnumber_short == 0 && initialpositioniert == true && OrderSymbol() == Symbol() && OrderMagicNumber() == m_Magicnumber_long && (OrderType()==OP_BUY)) //Wenn m_Magicnumber_long größer/gleich 1 ist und m_Magicnumber_short gleich 0 ist und initialpositioniert den Wert true hat etc., dann...
      {
       LongClose();
      }
      if (CountLong(m_Magicnumber_long) == 0 && m_Magicnumber_short >= 1 && initialpositioniert == true && OrderSymbol() == Symbol() && OrderMagicNumber() == m_Magicnumber_short && (OrderType()==OP_SELL)) //Wenn m_Magicnumber_long gleich 0 ist und m_Magicnumber_short größer/gleich 1 und initialpositioniert den Wert wahr hat etc., dann...
      {
       ShortClose();
      }
     }
   }
  Comment(cmd);
  running = false; //running bekommt den Wert false
  return(0); //Springe zum Anfang des EA's
}
//---alle anderen Positionen werden zum Marktpreis geschlossen wenn der TP erreicht wurde
void LongClose()
{
 OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), m_Slippage, Red); //...wird wenn es sich um OP_Buy Orders handelt alle offenen Long Positionen geschlossen
}
void ShortClose()
{
 OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_ASK), m_Slippage, Red); //...wird wenn es sich um OP_Sell Orders handelt alle offenen Short Positionen geschlossen
}

 

Der Aufruf erfolgt hier nun auch in der start()...

Jetzt bin ich verwirrt...also die beiden Klammern die ich ergänzt habe brauche ich also gar nicht...statt 3 Klammern gehört da also wieder eine hin?

Dein aktueller Code:

if (CountLong(m_Magicnumber_long >= 1 && m_Magicnumber_short == 0 && initialpositioniert == true && OrderSymbol() == Symbol() && OrderMagicNumber() == m_Magicnumber_long && (OrderType()==OP_BUY)

Hier hast du die Klammer auf nach if, dann den Aufruf von CountLong(... aber der Aufruf von CountLong hat keine schließende Klammer. Wenn du jetzt am Schluss 2 schließende Klammern einfügst übergibst du CountLong einen bool als Parameter. Deswegen fehlt einmal die schließende Klammer beim Funktionsaufruf und dann am Schluss der Zeile noch die schließende fürs if.

Die OrderClosefunktion rufe ich doch über die if-Bedingung auf...ich gebe ja vor wann orderClose starten soll...

Kann sein das ich es übersehen habe, aber wo genau rufst du LongClose bzw. ShortClose auf?

 

Edit: ok hast es selber gefunden ;)

Jetzt bekomme ich übrigens OrderSenderror 130...also etwas mit der Range des SL dabei...da muss ich jetzt mal ein wenig was anpassen und sicherlich auch mal langsam anfangen mit Getlasterror zu arbeiten... :(

 

Ich sehe es shcon kommen...am Ende funktioniert der EA nicht weil das in die Hose geht, aber immerhin bin ich dann ein wenig mächtiger was das codieren angeht^^

--> Ich würde einfach die Start soweit ändern, als dass ich Running gar nicht einfüge oder? Allerdings sollte zuerst die init() checken ob ich handeln darf oder nicht...wenn ja dann soll der in die start() springen um den eigentlichen EA laufen zu lassen

Bitte setz dich vorher nochmal mit dem Grundablauf eines EAs in MQL auseinander. init() wird genau einmal aufgerufen. start() bei jedem Tick.

--> Wenn ich den SL gar nicht haben will was machen ich denn da am besten? aus l_sl einfach 0 oder l_sl weg lassen? aber dann passt die Reihenfolge ja gar nicht mehr denke ich.

wenn du der OrderSend den SL-Parameter auf 0 setzt hat die Order keinen SL.

--> Ich habe bisher noch nie mit Fehleranzeigen gearbeitet und habe wahrscheinlich noch große Probleme damit diese zu implementieren...das würde ich im Anschluss machen wenn das Teil läuft...aber gut wenn ich die Fehler nicht kenne und mich frage warum es nicht läuft habe ich auch nichts gewonnen.

Deswegen ein letztes mal der Hinweis auf die TB und Kitchen, da ist genau für solche Fälle schon alles implementiert.

--> Genau...also ich gebe den TP nur beim Initialtrade vor...wenn einer von den beiden geschlossen wird, dann sollen automatisch alle anderen Order geschlossen werden...siehe in der start() funktion unter dem running:

hat sich erledigt, war vorher aber anders als von dir hier beschrieben.

--> Es ist prinzipiell egal ob ich das so oder so rechne (denke ich). Im Endeffekt benötige ich 3 Werte..Initialwert und die dazugehörigen Ranges...Bei der Umkehr muss ich ja wieder über den Initialwert die Umkehrtrades machen...also ist der schon wichtig...

Wie du es rechnest ist egal ja. Aber du hast nach der Lösung von einem anderen Problem gefragt das durch deine Art zu rechnen auftritt. Mein Tipp: lies meinen Post nochmal genau durch.

--> Ein Beispiel wäre toll :) derzeit habe ich einen Lotfaktor von 0.75..1.5 hatte ich vorher mit den ganzen Hedgepositionen...aber die habe ich ja nun ausgespart...

aufgrund von dieser Definition.... ein Beispiel... da du keine zentrale Lots-berechnung hast an den entsprechenden Stellen im Code einfügen...

double lots= 0;

void Initialpositionierung() 
{
 lots= m_Start_Lotsize;
...
 initLongTicket = OpenLong(lots,UseSlippage,0,UseTP_Initial,"Initial Long", m_Magicnumber_long); //dann bekommt initLongTicket den Wert OpenLong 
...
 initShortTicket = OpenShort(lots,UseSlippage,0,UseTP_Initial,"Initial Short", m_Magicnumber_short); //dann bekommt initShortTicket den Wert OpenShort
...
void Trendfolge_Trades() 
{
lots*= m_Lotsize_Faktor;
...
 trendLongTicket = OpenLong(lots,UseSlippage,0 ,0 ,"Trendfolge Long",0 );
...
trendShortTicket = OpenShort(lots,UseSlippage,0 ,0 ,"Trendfolge Short",0 );

btw.: Bitte antworte NIE innerhalb des Zitats auf einen anderen Posts. Sonst sieht es aus als hätte der andere das geschrieben und man kann nicht erkennen was neu ist. danke.

Jetzt bekomme ich übrigens OrderSenderror 130...also etwas mit der Range des SL dabei...da muss ich jetzt mal ein wenig was anpassen und sicherlich auch mal langsam anfangen mit Getlasterror zu arbeiten... :(

Hast du den Teil meines Posts wo ich dich genau auf dieses Problem hingewiesen habe überlesen oder ignoriert?

Hast du den Teil meines Posts wo ich dich genau auf dieses Problem hingewiesen habe überlesen oder ignoriert?

Ich abe es gelesen und nicht ignoriert :) nur habe ich noch nicht angefangen diese zu implementieren und das wird als nächster Schritt folgen...

Bearbeitet 17. Dezember 201213 Jr. von mast83

Ich glaube ich habe die Schwachstelle an diesem System nun entdeckt :(

 

Bisher habe ich immer eine Situation gepostet in der die Marktbedingungen davon ausgegangen sind, dass der Kurs wendet und dann 20 OPunkte rennt um letztendlich im Gewinn zu schließen...

Nun ist aber folgendes passiert...

Ich bin Eingestiegen long und short...habe den "Trend" gehandelt...dann die Umkehrung und dann wieder zurück und wieder die Umkehrung und erneut wieder zurück...

Am Ende hatte ich verloren...

Folgendermaßen sah das also aus:

 

 

Initial:
S 1,31486 Lot 0,01 Ausstieg 1,31708  GuV Pips -22,3 GuV Absolut -1,69
L 1,31503 Lot 0,01 Ausstieg 1,31707  GuV Pips +20,4 GuV Absolut 1,55
Level 1
L 1,31616 Lot 0,01 Ausstieg 1,31707  GuV Pips +9,1 GuV Absolut +0,69
Level 2
S 1,31489 Lot 0,02 Ausstieg 1,31721  GuV Pips -46,4 GuV Absolut -3,52
Level 3
L 1,31607 Lot 0,02 Ausstieg 1,31707  GuV Pips +20 GuV Absolut +1,52
Level 4
S 1,31486 Lot 0,03 Ausstieg 1,31725  GuV Pips -71,7 GuV Absolut -5,44
Level 5
L 1,31608 Lot 0,04 Ausstieg 1,31707  GuV Pips +39,6 GuV Absolut +3,01

 

 

Insgesamt verliere ich durch diese Konstellation also 51,3 Pips...oder 3,88€ heute :(

Also noch mal umschauen wie man das ändern kann^^

Weiterhin halte ich aber an diesem System fest bis es zu Ende programmiert wurde...Danach heißt es optimieren...

Ich glaube ich habe die Schwachstelle an diesem System nun entdeckt :(

 

Bisher habe ich immer eine Situation gepostet in der die Marktbedingungen davon ausgegangen sind, dass der Kurs wendet und dann 20 OPunkte rennt um letztendlich im Gewinn zu schließen...

Nun ist aber folgendes passiert...

[...]

Insgesamt verliere ich durch diese Konstellation also 51,3 Pips...oder 3,88€ heute :(

Also noch mal umschauen wie man das ändern kann^^

Weiterhin halte ich aber an diesem System fest bis es zu Ende programmiert wurde...Danach heißt es optimieren...

 

Das meinte ich mit den Seitwärtsphasen und dem "totdrehen" in einem vorigen Post.

Im nachhinein wäre es ganz einfach:

Die Range / Pipzahl auf die bereits vergangene Seitwärtsphase einpassen, bspw. auf 10 Pips und du hast einen Winner nach dem anderen ^^

 

btw.

Tage wie heute müssen wirklich nicht sein, wäre ich mal lieber im Bett geblieben als zu arbeiten....

Das sind halt Montage :-$

Ich werde schauen, dass die Drehungen nicht so oft passieren...mir schwirrt da schon was im Kopf herum...

Heute werde ich keine Trades ausprobieren. Es heißt erst mal weiter testen...evtl werde ich das ganze so umstricken, dass ich hier die Positionen mit TP schließe und dann dementsprechend je eine neue Position eröffne...wahrscheinlich würde ich so eine Konstellation dann nutzen um dort neue Einstiege zu wählen die dann laufen als wenn ich gar nicht drin wäre...

 

Bitte setz dich vorher nochmal mit dem Grundablauf eines EAs in MQL auseinander. init() wird genau einmal aufgerufen. start() bei jedem Tick.wenn du der OrderSend den SL-Parameter auf 0 setzt hat die Order keinen SL.Deswegen ein letztes mal der Hinweis auf die TB und Kitchen, da ist genau für solche Fälle schon alles implementiert.

hat sich erledigt, war vorher aber anders als von dir hier beschrieben.

Wie du es rechnest ist egal ja. Aber du hast nach der Lösung von einem anderen Problem gefragt das durch deine Art zu rechnen auftritt. Mein Tipp: lies meinen Post nochmal genau durch.

aufgrund von dieser Definition.... ein Beispiel... da du keine zentrale Lots-berechnung hast an den entsprechenden Stellen im Code einfügen...

double lots= 0;

void Initialpositionierung() 
{
 lots= m_Start_Lotsize;
...
 initLongTicket = OpenLong(lots,UseSlippage,0,UseTP_Initial,"Initial Long", m_Magicnumber_long); //dann bekommt initLongTicket den Wert OpenLong 
...
 initShortTicket = OpenShort(lots,UseSlippage,0,UseTP_Initial,"Initial Short", m_Magicnumber_short); //dann bekommt initShortTicket den Wert OpenShort
...
void Trendfolge_Trades() 
{
lots*= m_Lotsize_Faktor;
...
 trendLongTicket = OpenLong(lots,UseSlippage,0 ,0 ,"Trendfolge Long",0 );
...
trendShortTicket = OpenShort(lots,UseSlippage,0 ,0 ,"Trendfolge Short",0 );

btw.: Bitte antworte NIE innerhalb des Zitats auf einen anderen Posts. Sonst sieht es aus als hätte der andere das geschrieben und man kann nicht erkennen was neu ist. danke.

 

Wie kann ich denn in diesem Beispiel eine zentrale Lot-Berechnung starten ohne in die jeweilige Zeile rutschen zu müssen? Ich habe übrigens probiert mit errorcodes zu arbeiten, aber der error wird mir immer noch angezeigt...^^

Die Errorocodes werden im Journal ausgegeben , Siehe die entsprechende Registerkarte unten im Strattester . Die Vercodung findest Du hier . Den Link habe ich in meinem Favoriten abgelegt , zusammen mit einer Reihe anderer häufig genutzter MT4-Seiten ( u.a. dem Buch , den Farbcodes , den Wingdings usw usf ) KB

Wie kann ich denn in diesem Beispiel eine zentrale Lot-Berechnung starten ohne in die jeweilige Zeile rutschen zu müssen? Ich habe übrigens probiert mit errorcodes zu arbeiten, aber der error wird mir immer noch angezeigt...^^

 

Mein Beispiel wären Erweiterungen deines Codes. Zentrale Lotberechnung wäre, wenn du eine Funktion "calcLots(...)" hast die berechnet welche Lotsize für die konkrete nächste Order verwendet werden soll. Derzeit gibt es mehrere Stellen im Code die die Lotsize für die nächste Order berechnen. Dadurch kann man diese Berechnung nicht so leicht anpassen/erweitern.

 

Errorcodes auszulesen bringt nur etwas wenn man dann auch entsprechend darauf reagiert. In deinem Fall weißt du ja was falsch ist: Die Stoplevel sind zu eng. Wie schon gesagt liegt das daran das du versuchst den SL auf den Bid zu setzen. Das solltest du, wie schon gesagt, entsprechend ändern.

Hallo Zusammen,

 

ich hoffe Ihr habt die Weihnachtstage gut überstanden :)

 

Die letzten Tage habe ich versucht weiter am EA zu basteln und habe einiges geändert.

Leider bekomme ich derzeit noch Fehlerhinweise geliefert :(Die ErrorFunktion funktioniert auch noch nicht 100%ig und ich erhalte leider noch Fehler bzgl Requotes obwohl ich schon "Refreshrates()" etc eingebaut habe...desweiteren übernimmt der aus meiner OrderModify leider nicht den TP / SL den ich eingebaut habe und erhalte hierzu auch keine Fehlerhinweise obwohl ich meines Erachtens nach die Errorhinweise zu genüge eingefügt habe. Was mir letztendlich noch fehlt ist die Lotsizeerhöhung die ich dann nachträglich aufarbeiten will...

Falls jemand Zeit und Lust hat würd eich mich über ein kurzes Feedback freuen.

 

Liebe Grüße und Danke

 

Marc

Hier der Code

 

 
//+------------------------------------------------------------------+
//|                                                    GridRange.mq4 |
//|                                                      Marc Stolic |
//|                                                no link available |
//+------------------------------------------------------------------+
/*
Handelslogik:
--> 1.1 Wenn es keine offene Positionen gibt und die TradingTime, TradingDay in Ordnung ist, dann öffne eine Initialposition
    Long mit einer m_Start_Lotsize x und Short mit einer m_Start_Lotsize x. Beide Positionen haben einen fixen m_TP_Initial 
    von je x Pip.
    
--> 2.1 Bewegt sich der Kurs in irgendeine Richtung um m_Range_Initial (in diesem Beispiel steigt Währung 1 gegen Währung 2), 
    eröffne eine neue Position in Trendrichtung:
    m_Start_Lotsize*m_Lotsize_Faktor_in_Trend mit TP analog des Wertes aus dem Initialtrade.
    
--> 2.3 Sollte der Markt in Trendrichtung weiterlaufen und die TP erreichen werden alle Positionen geschlossen und der EA startet erneut.
 
--> 3.1 Bewegt sich der Markt wieder zurück in Richtung des Kurses bei Eröffnung der Initialpositionen (sozusagen m_Range_Initial) wird erneut gehandelt.
    Da sich der Markt in eine andere Richtung bewegt hat (Währung 1 ist schwächer geworden zu Währung 2) nehmen wir die Position mit der
    höchsten m_Start_Lotsize*m_Lotsize_Faktor_in_Trend aus dem vorherigen Handel Punkt 2.2 und drehen nun die Trendrichtung von Long auf Short. 
    
--> 3.2 Eine neue Shortposition in Trendrichtung:
    m_Start_Lotsize(höchste Lotsize aus dem vorherigen Trade Punkt 2.2)*m_Lotsize_Faktor_in_Trend(höchste Lotsize aus dem aktuellen Trade Punkt 3.2)
    mit TP analog des Wertes aus dem Initialtrade.
      
--> 4.1 Steigt der Kurs weiter in die Trendrichtung (in diesem Fall weiterhin Short) dann eröffnen wir (sozusagen m_Range_Initial) wieder eine Position in Trendrichtung: 
    m_Start_Lotsize(höchste Lotsize aus dem vorherigen Trade Punkt 3.3)*m_Lotsize_Faktor_in_Trend mit TP analog des Wertes aus dem Initialtrade.
    
--> 5.1 Sollte der Markt in Trendrichtung weiterlaufen und die TP erreichen werden alle Positionen geschlossen und der EA startet erneut. 
 
--> 6.1 Sollte der Markt wieder drehen wird genau so vorgegangen wie es bisher der Fall war: 
    Es wird immer in Trendrichtung der höchsten Lotsize aus des noch offenen vorherigen Trades um den Lotsizefaktor erhöht.
    TP haben immer einen gleichen fixen Wert der durch den Initialtrade vorgegeben ist.  
    
/*Versionsänderungen nach Datum: 
/Version 26.11.2012 Einfügen eines Spreadcheck und Erweiterung um die einzelnen TP+SL-Levels für die Trendfolgen und Hedges
/Version 28.11.2012 Einfügen einer Slippage- und PointFunktion. Einfügen von stdlib.mqh (weitere Standardfunktionen. Ergänzen der Funktion IsTradeContextBusy...
/Version 02.12.2012 Fehlerbehebung bei SL und TP bzw. Einfügen von Ausgangslevelkorrektur wenn der Kurs wieder zum Urspünglichen Kurs, dem Initialeinstieg zurück kommt
/Version 15.12.2012 Herausnahme der Hedgefunktion. Entfernen des SL gegen mögliche Brokermanipulationen. Änderung der Handelslogik
/Version 23.12.2012 Einfügen getLastError. CloseAll-Funktion ändern und Emergency TP einfügen
/Version 24.12.2012 GetLastError angepasst
/Version 25.12.2012 Anpassen der Initialpositionierungen beim Einstieg. Integrieren der Handelstage und Handelszeit in die Start Funktion. Einfügen eines Emergency StopLoss
/Version 27.12.2012 Anpassen an ECN-Broker und verändern der Trendfolgetrades
/
/
*/
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
#property copyright "Marc Stolic"
#property link      "no link available"
#include <stdlib.mqh>
#include <stderror.mqh>
//---Eingabeparameter
extern string    Einstellung1                = "----------Hauptsettings---------";
extern int       m_Magicnumber_long          = 912873465; //m_Magicnumber_long erhält den Wert x; einzigartige Nummer für den EA
extern int       m_Magicnumber_short         = 198237645; //m_Magicnumber_short erhält den Wert x; einzigartige Nummer für den EA
extern double    m_Start_Lotsize             = 0.01; //m_Start_Lotsize erhält den Wert 0.01; Initiallotsize für den Long- und Shorteinstieg
extern double    m_Lotsize_Faktor            = 0.75; //m_Lotsize_Faktor_in_Trend erhält den Wert 1.5; Multiplikator um den die höchste Lotisze aus dem letzten Trade erhöht wird
extern double    m_Range_Initial             = 10; //m_Range_Initial erhält den Wert 10; Die Range um die sich das Underlying nach dem Initialtrade bewegen muss bevor neue modifizierte Positionen eröffnet werden
extern double    m_TP_Initial_Long           = 20; //m_TP_Initial_Long erhält den Wert 20; Initialtakeprofit, Alle anderen offenen Orders werden geschlossen sobald ein TP erreicht wird.
extern double    m_TP_Initial_Short          = 20; //m_TP_Initial_Short erhält den Wert 20; Initialtakeprofit, Alle anderen offenen Orders werden geschlossen sobald ein TP erreicht wird.
extern double    m_SL_Emergency              = 100; //m_SL ist der Notausstieg falls nichts mehr gehen sollte
extern double    m_Slippage                  = 2; //
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
extern string    Einstellung2                = "----------Handelstage----------";
extern bool      Montag                      = true; //Soll Montag gehandelt werden true/false
extern bool      Dienstag                    = true; //Soll Dienstag gehandelt werden true/false
extern bool      Mittwoch                    = true; //Soll Mittwoch gehandelt werden true/false
extern bool      Donnerstag                  = true; //Soll Donnerstag gehandelt werden true/false
extern bool      Freitag                     = true; //Soll Freitag gehandelt werden true/false
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
extern string    Einstellung3                = "----------Handelszeiten----------";
extern int       StartTradingHour            = 7; //Stunde die vorhanden sein muss um die Logik auszuführen
extern int       StartTradingMinute          = 0; //Minute die in der Stunde erreicht sein muss
extern int       StopTradingHour             = 20; //Stunde bei der der Handel unterbrochen wird
extern int       StopTradingMinute           = 0; //Minute zu der der Handel unterbrochen wird
//---Globale Parameter
double           UsePoint; //Genutzer Multiplikator pro Pip 
int              UseRange_Initial; //Anpassung der m_Range_Initial an Pipgröße des Brokers                                             
int              UseTP_Initial_Long; //Anpassung der m_TP an Pipgröße des Brokers
int              UseTP_Initial_Short; //Anpassung der m_TP an der Pipgröße des Brokers
int              UseSlippage; // Anpassung der Slippage an GetSlippage
int              UseSL_Emergency; // Anpassung des m_SL an Pipgröße des Brokers
double           initialLongwert = 0.0; //initialLongwert bekommt den Wert 0.0 und wird vergeben wenn der initallong gehandelt wurde
double           initialShortwert = 0.0; //initialShortwert bekommt den Wert 0.0 und wird vergeben wenn der initialshort gehandelt wurde
int              InitialLong = 0; //InitialLong bekommt den Wert 0
int              InitialShort = 0; //InitialShort bekommt den Wert 0
int              TrendLong = 0; //TrendLong bekommt den Wert 0
int              TrendShort = 0; //TrendShort bekommt den Wert 0
bool             running = false; //running bekommt zuerst den Wert false. Hier werden Handelszeiten und Handelstage zuerst geprüft um den Wert auf true zu setzen
bool             initialpositioniert = false; //initialpositioniert bekommt den Wert false
int              TrendLongTicket = 0; //trendLongTicket bekommt den Wert 0
int              TrendShortTicket = 0; //trendShortTicket bekommt den Wert 0
int              CloseAll = 0; //Alle Positionen werden geschlossen
string           cmd = "";
int              ErrorCode; //Anzeige der Fehler die innerhalb des EA's bei der Ausführung auftauchen
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
 UsePoint                       = PipPoint(Symbol());
 UseRange_Initial               = m_Range_Initial*UsePoint; //UseRange bekommt den Wert m_Range_Initial*UsePoint             
 UseTP_Initial_Long             = m_TP_Initial_Long*UsePoint; //UseTP_Long bekommt den Wert m_TP*UsePoint
 UseTP_Initial_Short            = m_TP_Initial_Short*UsePoint; //UseTP_Short bekommt den Wert m_TP*UsePoint
 UseSL_Emergency                = m_SL_Emergency*UsePoint; //UseSL bekommt den Wert m_SL*UsePoint   
 UseSlippage                    = GetSlippage(Symbol(), m_Slippage);                   
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
 if (Montag == true && DayOfWeek() == 1 || Dienstag == true && DayOfWeek() == 2 || Mittwoch == true && DayOfWeek() == 3 || Donnerstag == true && DayOfWeek() == 4 || Freitag == true && DayOfWeek() == 5)
   {
    if (StartTradingHour >= Hour() && StartTradingMinute >= Minute() && StopTradingHour >=Hour() && StopTradingMinute >=Minute())
      {
       if (initialpositioniert == true && CountLong(m_Magicnumber_long) == 0 || CountShort(m_Magicnumber_short) == 0) //Wenn initialpositioniert den Wert wahr hat und CountLong gleich 0 ist und CountShort gleich 0, dann...
        {
         CloseAll(); //Springe zu CloseAll
         initialpositioniert = false; //setze initialpositioniert auf false
        }
       if (initialpositioniert == false) //Wenn initialpositioniert gleich false ist, dann
        {
         Initialpositionierung(); //springe zu Initialpositionierung
        }
       if (initialpositioniert == true && CountLong(m_Magicnumber_long) >=1 && CountShort(m_Magicnumber_short) >= 1 && initialLongwert < Ask-(UseRange_Initial)) 
        {
         Trendfolge_Trades_Long(); //Springe zu Trendfolge_Trades
        }
       if (initialpositioniert == true && CountLong(m_Magicnumber_long) >=1 && CountShort(m_Magicnumber_short) >= 1 && initialShortwert > Bid+(UseRange_Initial)) 
        {
         Trendfolge_Trades_Short(); //Springe zu Trendfolge_Trades
        }
      } 
   }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--->Ermitteln und Eröffnen der Initialpositionen
void Initialpositionierung() 
{
 if (CountLong(m_Magicnumber_long) == 0 && initialpositioniert == false) //Wenn CountLong den Wert 0 hat und initialpositioniert den Wert 0 hat...
    {
     RefreshRates();
     while(IsTradeContextBusy()) Sleep(100);
     int IniLong = OrderSend(Symbol(), OP_BUY, m_Start_Lotsize, Ask, UseSlippage, 0, 0, "InitialLong", m_Magicnumber_long,0, Green);
      if (IniLong == 1)
       {
        RefreshRates();
        while(IsTradeContextBusy()) Sleep(100);
        bool IniLongMod = OrderModify(IniLong, OrderOpenPrice(), Ask - UseSL_Emergency, Bid + UseTP_Initial_Long, 0, CLR_NONE);
         if (IniLongMod == -1)
          {
           ErrorCode = GetLastError();
           string ErrorDescIniLongMod = ErrorDescription(ErrorCode);
           string ErrorAlertIniLongMod = StringConcatenate("OP_BUY-Initial-Modifiy does not work ", ErrorCode, " ", ErrorDescIniLongMod);
           Print(ErrorAlertIniLongMod); 
           return(0);
          } 
         } 
        if (IniLong == -1)
         {
          ErrorCode = GetLastError();
          string ErrorDescIniLong = ErrorDescription(ErrorCode);
          string ErrorAlertIniLong = StringConcatenate("OP_BUY-Initial does not work ", ErrorCode, " ", ErrorDescIniLong);
          Print(ErrorAlertIniLong); 
          return(0);
         }
        return(IniLong);
       }
 if (CountShort(m_Magicnumber_short) == 0 && initialpositioniert == false) //Wenn CountShort den Wert 0 hat und der initialpositioniert den Wert 0 hat...
    {
     RefreshRates();
     while(IsTradeContextBusy()) Sleep(100);
     int IniShort = OrderSend(Symbol(), OP_SELL, m_Start_Lotsize, Bid, UseSlippage, 0, 0, "InitialShort", m_Magicnumber_short,0, Red);
      if (IniShort == 1)
       {
        RefreshRates();
        while(IsTradeContextBusy()) Sleep(100);
        bool IniShortMod = OrderModify(IniShort, OrderOpenPrice(), Bid + UseSL_Emergency, Ask - UseTP_Initial_Short, 0, CLR_NONE);
         if (IniShortMod == -1)
          {
           ErrorCode = GetLastError();
           string ErrorDescIniShortMod = ErrorDescription(ErrorCode);
           string ErrorAlertIniShortMod = StringConcatenate("OP_SELL-Initial-Modifiy does not work ", ErrorCode, " ", ErrorDescIniShortMod);
           Print(ErrorAlertIniShortMod); 
           return(0);
          }
       }
      if (IniShort == -1)
       {
        ErrorCode = GetLastError();
        string ErrorDescIniShort = ErrorDescription(ErrorCode);
        string ErrorAlertIniShort = StringConcatenate("OP_SELL-Initial does not work ", ErrorCode, " ", ErrorDescIniShort);
        Print(ErrorAlertIniShort); 
        return(0);
       }
      return(IniShort);
     } 
  if (CountLong(m_Magicnumber_long) == 1 && CountShort(m_Magicnumber_short) == 1 && initialpositioniert == false) //wenn CountLong und CountShort den Wert 0 haben und initialpositioniert den Wert false hat...
     {
      initialpositioniert = true; //dann setze initialpositioniert auf true...
      initialLongwert  = LongPrice(InitialLong); //initialLongwert bekommt den Wert LongPrice
      initialShortwert = ShortPrice(InitialShort); //initialShortwert bekommt den Wert ShortPrice
     }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--->Ermitteln und Eröffnen der Trendfolgepositionen Long 
void Trendfolge_Trades_Long() 
{
  {
   RefreshRates();
   while(IsTradeContextBusy()) Sleep(100);
   int TrendLongTicket = OrderSend(Symbol(), OP_BUY, m_Start_Lotsize*m_Lotsize_Faktor, 0, 0 ,0 , "Trendfolge Long",0, Green);
   if(TrendLongTicket == -1)
    {
     ErrorCode = GetLastError();
     string ErrorDescLongTrend = ErrorDescription(ErrorCode);
     string ErrorAlertLongTrend = StringConcatenate("OP_BUY-Trend does not work ", ErrorCode, " ", ErrorDescLongTrend);
     Print(ErrorAlertLongTrend); 
     return(0);
    }
    return(TrendLongTicket);
   }
  TrendLong = LongPrice(TrendLongTicket);
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--->Ermitteln und Eröffnen der Trendfolgepositionen Short 
void Trendfolge_Trades_Short()
{
  {
   RefreshRates();
   while(IsTradeContextBusy()) Sleep(100);
   int TrendShortTicket = OrderSend(Symbol(), OP_SELL, m_Start_Lotsize*m_Lotsize_Faktor, 0, 0 ,0 , "Trendfolge Short",0, Red);
   if(TrendShortTicket == -1)
    {
     ErrorCode = GetLastError();
     string ErrorDescShortTrend = ErrorDescription(ErrorCode);
     string ErrorAlertShortTrend = StringConcatenate("OP_SELL-Trend does not work ", ErrorCode, " ", ErrorDescShortTrend);
     Print(ErrorAlertShortTrend); 
    }
   return(TrendShortTicket);
  }
  TrendShort = ShortPrice(TrendShortTicket);
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--->alle anderen Positionen werden zum Marktpreis geschlossen wenn der TP der Initialpositionen erreicht wurde
void CloseAll()
{
 RefreshRates();
 while(IsTradeContextBusy()) Sleep(100);
 int CloseAll = OrderClose(OrderTicket(), OrderLots(), MarketInfo(OrderSymbol(), MODE_BID), 0, Yellow); //...wird wenn es sich um OP_Buy Orders handelt alle offenen Long Positionen geschlossen
  if (CloseAll == -1)
   {
    ErrorCode = GetLastError();
    string ErrorDesc = ErrorDescription(ErrorCode);
    string ErrAlert = StringConcatenate("CloseAll does not work", ErrorCode, ErrorDesc);
    Print(ErrAlert);
   }
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--->Ermitteln des Long und Shortpreises
double LongPrice(int Ticketnumber) 
{
 double returner = 0.0;   
 OrderSelect(Ticketnumber, SELECT_BY_TICKET, MODE_TRADES);
 returner = OrderOpenPrice();        
 return(returner);
}
double ShortPrice(int Ticketnumber) 
{
 double returner = 0.0;   
 OrderSelect(Ticketnumber, SELECT_BY_TICKET, MODE_TRADES);
 returner = OrderOpenPrice();        
 return(returner);
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---Aufzählen der Orders Long
int CountLong(int m_Magicnumber_long) 
{
int RETURNER = 0;
 for (int Counter = 0; Counter <= OrdersTotal(); Counter++) 
   {
    OrderSelect(Counter, SELECT_BY_POS, MODE_TRADES);
    if (OrderMagicNumber()== m_Magicnumber_long)
     {
      if (OrderType() == OP_BUY) 
       {
        RETURNER++;
       }   
     }
   }
  return(RETURNER);
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--->Aufzählen der Orders Short
int CountShort(int m_Magicnumber_short) 
{
 int RETURNER = 0;
  for (int Counter = 0; Counter <= OrdersTotal(); Counter++) 
    {
     OrderSelect(Counter, SELECT_BY_POS, MODE_TRADES);
     if (OrderMagicNumber()== m_Magicnumber_short)
      {
       if (OrderType() == OP_SELL) 
        {
         RETURNER++;
        }   
      }
    }
   return(RETURNER);
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--->Pip Point Funktion
double PipPoint(string Currency)
{
 int CalcDigits = MarketInfo(Currency,MODE_DIGITS);
 if(CalcDigits == 2 || CalcDigits == 3) double CalcPoint = 0.01;
 else if (CalcDigits == 4 || CalcDigits == 5) CalcPoint = 0.0001;
 return(CalcPoint);
}
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//--->Get Slippage Function
int GetSlippage(string Currency, int SlippagePips)
{
int CalcDigits = MarketInfo(Currency, MODE_DIGITS);
if(CalcDigits == 2 || CalcDigits == 4) double CalcSlippage = SlippagePips;
else if(CalcDigits == 3 || CalcDigits == 5) CalcSlippage = SlippagePips * 10;
return (CalcSlippage);
}

Kann schon jemand evtl helfen? *liebfrag*

Requote "Errors" wirst du im Realtrading nie verhindern können, das kommt einfach vom broker. Du musst nur im Code entsprechend reagieren. Es können auch mehrere Requotes hintereinander kommen.

 

bzgl. dem SL und TP: Bist du dir sicher das die OrderModify überhaupt ausgeführt wird? Der Returnwert von OrderSend ist im erfolgsfall nicht immer 1 sondern die OrderID.

Du hast u.a. einen Fehler im Ordersend() :

 

 

ich habe Deinen Code in meinen Editor gezogen, dort kompiliert und dann im Strategytester kurz laufen lassen . Screenshot oben . mehr habe ich nicht getan .

 

1.)dort lese ich den Fehler 131 und öffne den Link,den ich Dir oben gepostet hatte, der sagt dem Leser das 131

ERR_INVALID_TRADE_VOLUME 131 Invalid trade volume.

ist . Und das bedeutet also , dass irgendetwas mit deinem Tradevolumen nicht ok ist

2.) ich lese da auch (in deinem journal), dass =>

"invalid double number as parameter 7 for order send function"

das verstehe ich nicht , der Parameter 7 in meiner Lesart ist der TP ,hat also nix mit dem Volumen zu tun

 

Mein nächster Schritt wäre nun, dass ich mir einen Print-Befehl auf das Ordervolumen lege , also die variable "m_Start_Lotsize" ausdrucken lasse und gucke was Theorie vs Praxis sagt .

Vermutlich erste Überraschung und Rückwärtssuchen wo der KasusKnack ist

 

Mein zweiter Schritt ist gleichermassen mit dem TP (und gleich auch SL) vorzugehen .

 

Schön ist Deine Lösung mit der Errorausgabe im Falle das OrderSend() nicht funzt .

Die Arbeit , so wie ich sie Dir oben hier beschrieben habe, muss Dir (ist mir) in Fleisch und Blut übergegangen . Wenn der Editor ohne Fehler kompiliert hat, beginnt meist erst die richtige Arbeit . Ist aber spannender als Kreuzworträtsel ... für mich

 

Viel Erfolg

KB

Du hast u.a. einen Fehler im Ordersend() :

 

marc.png

 

ich habe Deinen Code in meinen Editor gezogen, dort kompiliert und dann im Strategytester kurz laufen lassen . Screenshot oben . mehr habe ich nicht getan .

 

1.)dort lese ich den Fehler 131 und öffne den Link,den ich Dir oben gepostet hatte, der sagt dem Leser das 131

ERR_INVALID_TRADE_VOLUME 131 Invalid trade volume.

ist . Und das bedeutet also , dass irgendetwas mit deinem Tradevolumen nicht ok ist

2.) ich lese da auch (in deinem journal), dass =>

"invalid double number as parameter 7 for order send function"

das verstehe ich nicht , der Parameter 7 in meiner Lesart ist der TP ,hat also nix mit dem Volumen zu tun

 

Mein nächster Schritt wäre nun, dass ich mir einen Print-Befehl auf das Ordervolumen lege , also die variable "m_Start_Lotsize" ausdrucken lasse und gucke was Theorie vs Praxis sagt .

Vermutlich erste Überraschung und Rückwärtssuchen wo der KasusKnack ist

 

Mein zweiter Schritt ist gleichermassen mit dem TP (und gleich auch SL) vorzugehen .

 

Schön ist Deine Lösung mit der Errorausgabe im Falle das OrderSend() nicht funzt .

Die Arbeit , so wie ich sie Dir oben hier beschrieben habe, muss Dir (ist mir) in Fleisch und Blut übergegangen . Wenn der Editor ohne Fehler kompiliert hat, beginnt meist erst die richtige Arbeit . Ist aber spannender als Kreuzworträtsel ... für mich

 

Viel Erfolg

KB

Vielen Dank für Deine Informationen :)

 

Die gleichen Fehler hatte ich auch beim Backtesten...Eigentlich hatte ich gehofft, dass nach dem Backtesten die ganze Schose live gehen kann... aber bis dahin scheint es echt was zu dauern.

Das Invalid Trade Volumen begründe ich erst mal mit dem Faktor, aber wenn ich mich richtig erinnere, dann war der Fehler nicht mehr zu erkennen wenn der Multiplikator größer 1 ist. Das liegt daran, dass mit einem Faktor von 0.75 und 0.01 Lot die nächste Lotsize nicht genau 0.01 ist sondern größer...ich runde dahingehend bisher händisch ab...Das mit dem Parameter scheint ein weiterer Fehler zu sein^^ Also vereint mein EA gerade mehr als ein Fehler die mir angezeigt werden....So lese ich das jetzt

Darf ich dahingehend um Hilfe bitten mir zu sagen wie ich die Printfunktion für die Lotsize in den EA einbauen kann? bzw. wo dort...nach der OrdersendFunktion?

Also einfach Print(Ordersize...) oder wie?

Ich hatte desweiteren überlegt den TP bei dem nächsten Tick über eine If Funktion separat zu ändern...also aus der eigentlichen Ordersendfunktion heraus zu nehmen...

Etwas unnützes habe ich aber noch als externen string eingebaut...und zwar die Handelssessions der Asian, European und NY-Session...

da kann man wenigstens die Handelszeit danach einstellen...juhu

Ab der Zeile 157 entnommen :

 

     while(IsTradeContextBusy()) Sleep(100);
     int IniLong = OrderSend(Symbol(), OP_BUY, m_Start_Lotsize, Ask, UseSlippage, 0, 0, "InitialLong", m_Magicnumber_long,0, Green);
      if (IniLong == 1)
       {
        RefreshRates();
        while(IsTradeContextBusy()) Sleep(100);

füge ich nun zusätzlich ein :

 

     while(IsTradeContextBusy()) Sleep(100);
       int IniLong = OrderSend(Symbol(), OP_BUY, m_Start_Lotsize, Ask, UseSlippage, 0, 0, "InitialLong", m_Magicnumber_long,0, Green);
       Print (" IniLong=",IniLong," : Volumen = ",m_Start_Lotsize," bei Preis =",Ask);
       if (IniLong == 1)
       {
        RefreshRates();
        while(IsTradeContextBusy()) Sleep(100);

 

Probiere damit mal herum und sehe Dir den Ausgabetext im Journal an . Passe es für OrderModiy u.a. an .

 

Das Journal wird übrigens auch als Datei in einem Log abgespeichert . Gucke mal mit rechtsklick auf den Text im Journal, was sich da so tut . Nutze den Explorer . Später, wenn Du lange Zeiträume testest und in selten bestimmten Umständen "Marken" hinterlassen willst, dann kannst Du unübliche Buchstaben mit Print ausdrucken . Dann öffnest Du danach Dein Log und suchst ( CTRL & F) diese Kombi im Log .

 

KB

PS.: Sequenz oben nicht kompiliert , hoffe das Syntax OK ist, wenn nicht, dann morgen wieder , KB geht jetzt OFF

PPS.: Die Variable IniLong wird zur OrderTicket , wenn Ordersend OK durchgeführt wurde .