_guest_

Hi Mythos, ich versuche mal auf das von Dir einzugehen sofern ich es denn verstanden habe...also: --> 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 --> 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. --> 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. --> 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... --> 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... --> 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

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?

Ich bedanke mich schon mal für eure Hilfe bzgl meiner o.g. Probleme...

Einen wunderschönen guten Abend zusammen, ich habe mir versucht die Mühe zu machen den Code zu stricken und an allen möglichen Stellen zu kommentieren. Was mir noch nicht gelungen ist...ich habe irgendwo eine Klammer zu viel oder eher zu wenig...beim kompilieren bekomme ich diesen Fehlerhinweis. Folgende Probleme habe ich: --> Ich habe es nicht heraus bekommen wie ich die Positionen beim nächsten Trade um den Faktor erhöhen kann. --> Desweiteren muss ich dem Programm sagen, dass er immer die Range einhalten soll. Wenn ich also meine Initialtrades gemacht habe und der Kurs sich um 10 Punkte verändert hat dann mache ich die Trendbewegung mit. Wenn der Kurs aber um einige Punkte korrigiert und dann wieder die Bedingung mit der Range erfüllt ist, dann eröffne ich ja eine ungewollte Position...wie kann ich das verhindern? Hier nun 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 / / / / */ #property copyright "Marc Stolic" #property link "no link available" #include <stdlib.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_Slippage = 1; //m_Slippage erhält den Wert 1; Varianz in Pips bei der Ausführung einer Order 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 = 20; //m_TP erhält den Wert 20; Initialtakeprofit, Alle anderen offenen Orders werden geschlossen sobald ein TP erreicht wird. //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- extern string Einstellung2 = "----------Handelstage----------"; extern int Montag = 1; //entspricht DayofWeek extern int Dienstag = 2; //-1 eingeben, damit die Variable nicht erkannt wird und der Handelstag weg bleibt extern int Mittwoch = 3; //Doppelverwendungen sind Möglich extern int Donnerstag = 4; //Wenn Donnerstag = 4 und Freitag = 4 extern int Freitag = 5; //Dann haben diese Wochentag den selben Wert //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 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 double UseSlippage; //Anpassung der Slippage an Pipgröße des Brokers int UseRange_Initial; //Anpassung der m_Range_Initial an Pipgröße des Brokers int UseTP_Initial; //Anpassung der m_TP 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 initLongTicket = 0; //initLongTicket bekommt den Wert 0 int initShortTicket = 0; //initShortTicket 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 TrendLong = 0; //TrendLong bekommt den Wert 0 int TrendShort = 0; //TrendShort bekommt den Wert 0 string cmd = ""; //+------------------------------------------------------------------+ //| expert initialization function | //+------------------------------------------------------------------+ int init() { UsePoint = PipPoint(Symbol()); UseSlippage = GetSlippage(Symbol(), m_Slippage); UseRange_Initial = m_Range_Initial*UsePoint; //UseRange bekommt den Wert m_Range_Initial*UsePoint UseTP_Initial = m_TP_Initial*UsePoint; //UseTP bekommt den Wert m_TP*UsePoint } //--Handelstag und Handelszeit integrieren bool BotDarfHandeln() { bool returner = false; //returner hat den Wert false if (TradingDay() == true && TradingTime() == true) //Wenn TradingDay, TradingTime den boolschen Wert wahr haben... { returner = true; //dann bekommt retuner den Wert true und... } return (returner); //springt return zum Anfang des Blocks } //---Feststellen der Handelstage bool TradingDay() { bool returner = false; //returner hat den Wert false int DOW = DayOfWeek(); //DOW bekommt den Wert DayOfWeek int Handelstage[5]; Handelstage[0] = Montag; Handelstage[1] = Dienstag; Handelstage[2] = Mittwoch; Handelstage[3] = Donnerstag; Handelstage[4] = Freitag; for (int td_cnt1 = 0; td_cnt1<=5; td_cnt1++) //Die Variable td_cnt wird als int deklariert und bekommt den Wert 0. Ist td_cnt1 kleiner/gleich 5 dann wird td_cnt um 1 erhöht { if (Handelstage[td_cnt1] == DOW) returner = true; //Wenn Handelstage mit Wert von td_cnt gleich DOW, dann... } return(returner); //springt zu returner am Anfang des Blocks } //---Feststellen der Handelszeiten bool TradingTime() //abfragen der Wahrheitswerte für TradingTime { bool returner = false; //returner bekommt den Wert false if (returner == false && StartTradingHour == StopTradingHour && StartTradingMinute == StopTradingMinute) { returner = true; //bekommt returner den Wert true } if (returner == false && StartTradingHour <= StopTradingHour && Hour() >= StartTradingHour) { if (Hour() == StartTradingHour && Minute() >= StartTradingMinute) returner = true; if (returner == false && Hour() > StartTradingHour && Hour() < StopTradingHour) returner = true; if (returner == false && Hour() == StopTradingHour && Minute() < StopTradingMinute) returner = true; if (Hour() == StopTradingHour && Minute() >= StopTradingMinute) returner = false; } if (returner == false && StartTradingHour > StopTradingHour) { if (Hour() == StartTradingHour && Minute() >= StartTradingMinute) returner = true; if (Hour() > StartTradingHour || Hour() < StopTradingHour) returner = true; if (returner == false && Hour() == StopTradingHour && Minute() < StopTradingMinute) returner = true; if (returner == false && Hour() == StartTradingHour && Minute() >= StartTradingMinute) returner = true; } return(returner); //springt zu returner am Anfang des Blocks } //---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 cMAGIC) { int RETURNER = 0; for (int Counter = 0; Counter <= OrdersTotal(); Counter++) { OrderSelect(Counter, SELECT_BY_POS, MODE_TRADES); if (OrderMagicNumber()==cMAGIC) { if (OrderType() == OP_BUY) { RETURNER++; } } } return(RETURNER); } //---Aufzählen der Orders Short int CountShort(int cMAGIC) { int RETURNER = 0; for (int Counter = 0; Counter <= OrdersTotal(); Counter++) { OrderSelect(Counter, SELECT_BY_POS, MODE_TRADES); if (OrderMagicNumber()==cMAGIC) { if (OrderType() == OP_SELL) { RETURNER++; } } } return(RETURNER); } //+------------------------------------------------------------------+ //| expert start function | //+------------------------------------------------------------------+ 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 } } } 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() { 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 } } //---Ermitteln ob Initialkaufs und Initialverkaufs bereits geschehen sind void Initialpositionierung() { if (CountLong(m_Magicnumber_long) == 0 && initialpositioniert == false) //Wenn CountLong den Wert 0 hat und initialpositioniert den Wert 0 hat... { initLongTicket = OpenLong(m_Start_Lotsize,UseSlippage,0,UseTP_Initial,"Initial Long", m_Magicnumber_long); //dann bekommt initLongTicket den Wert OpenLong } if (CountShort(m_Magicnumber_short) == 0 && initialpositioniert == false) //Wenn CountShort den Wert 0 hat und der initialpositioniert den Wert 0 hat... { initShortTicket = OpenShort(m_Start_Lotsize,UseSlippage,0,UseTP_Initial,"Initial Short", m_Magicnumber_short); //dann bekommt initShortTicket den Wert OpenShort } 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(initLongTicket); //initialLongwert bekommt den Wert LongPrice initialShortwert = ShortPrice(initShortTicket); //initialShortwert bekommt den Wert ShortPrice } } //---Ermitteln und Eingehen der Trendfolgepositionen void Trendfolge_Trades() { if (initialLongwert < Ask-(UseRange_Initial) && initialpositioniert == true) //---LONG ermitteln { trendLongTicket = OpenLong((m_Start_Lotsize*m_Lotsize_Faktor),UseSlippage,0 ,0 ,"Trendfolge Long",0 ); } if (initialShortwert > Bid+(UseRange_Initial) && initialpositioniert == true) //---SHORT ermitteln { trendShortTicket = OpenShort((m_Start_Lotsize*m_Lotsize_Faktor),UseSlippage,0 ,0 ,"Trendfolge Short",0 ); } TrendLong = LongPrice(trendLongTicket); TrendShort = ShortPrice(trendShortTicket); } //---Eröffnen der Positionen. Das gilt für die Initialpositionen als auch die späteren Trendfolger int OpenLong(double l_lot, int l_slippage, double l_sl, double l_tp, string l_comment, int l_magic, color l_flag = Green) { while(IsTradeContextBusy()) Sleep(10); int Ticket = OrderSend(Symbol(),OP_BUY,l_lot,Ask,l_slippage,Bid-(l_sl*UsePoint),Bid+(l_tp*UsePoint),l_comment,l_magic,0,l_flag); return(Ticket); } int OpenShort(double s_lot, int s_slippage, double s_sl, double s_tp, string s_comment, int s_magic, color s_flag = Red) { while(IsTradeContextBusy()) Sleep(10); int Ticket = OrderSend(Symbol(),OP_SELL,s_lot,Bid,s_slippage,Ask+(s_sl*UsePoint),Ask-(s_tp*UsePoint),s_comment,s_magic,0,s_flag); return(Ticket); } //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //---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 Funktion double GetSlippage(string Currency, int SlippagePips) { int CalcDigits = MarketInfo(Currency,MODE_DIGITS); if(CalcDigits == 2 || CalcDigits == 3) double CalcSlippage = SlippagePips; else if (CalcDigits == 4 || CalcDigits == 5) CalcSlippage = SlippagePips*10; return(CalcSlippage); }

Sicherlich eine gute Idee...man gibt einen TP vor der nur aus der Initialen Position ermittelt wird. Aber nicht als solcher ausgewiesen wird...also sichtbar. Bin im übrigen nun raus aus meiner noch offenen Long Position! Hatte mich bei einem Level mit der Lotsize vertan und hatte dementsprechend weniger Gewinn, aber immerhin kam wieder was positives bei raus. Bzgl deines Vorschlages: kann man vorgeben, dass der TP immer analog einer Order gerechnet wird? Um mehr zu differenzieren würde ich als weiteres Kriterium noch Magicnumber Long und Magicnumber Short einfügen. Und Hmm zu dem TP...ich nehme einfach die ersten Initialtrades und lasse den TP darauf projizieren...allerdings kann ich natürlich später nicht mer dafür sorgen, dass der TP geändert wird wenn zu viele Positionen im Markt gelevelt wurden und ich ggf die Lotsize weiter anpasse oder den TP verändern will...

Vielen vielen Dank für deine Hilfe :)

Prinzipiell hast Du recht...in der Tat bin ich am Überlegen ob nicht ggf die Range bei neuen Levels verringert werden soll...Beispielsweise haben ich eine Range von 20 um den Einstieg herum... dann sage ich...maximal 10 Level gehe und ab dann die Einstiege verringere..Dementsprechend natürlich auch die SL und TP für alle Trades. Mein Ziel wäre es dabei im übrigen zumindest den Spread und die Slippage heraus zu bekommen... Sinnig wäre auch eine Abschöpfung der Gewinne...also von jedem Gewinn x-% an die Seite legen. Die Nachteile werde ich hieraus leider niemals ablegen können, aber prinzipiell könnte ich hier auch ein Reversesystem draus stricken. Also ich lasse das System 1 laufen und dann lasse ich es Zusätzlich mit Gegenpositionen als eigenständiges System laufen...oder aber!!! ich lasse das System erneut als eigenständiges Laufen wenn das Level 1 einmal erreicht worden ist. Heute beim manuellen Trading habe ich wieder gemerkt...Der Spread ist böse! Wieder mit SL raus, aber der TP nicht...nun hänge ich wieder in den Seilen...Der EA wird also nur TP im Markt handeln und alle Orders schließen sobald der TP berührt wurde...Somit hat man auch wengstens brokerseitig schonmal nicht dei "Angst" einer Spreadausweitung... Wenn die SL nicht gerissen wären hätte der EA zumindest bis Level 5 gehandelt und vll wäre ich da fein raus gewesen...Naja wenn das wörtchen wenn ncht wäre ;-) Ich bleibe am laufenden und teile euch alles mit!

Initialtrade Long 1,30515 TP 1,30715 SL 1,30305 Lotsize 0,01 Pips +20 Short 1,30487 TP 1,30300 SL 1,30700 Lotsize 0,01 Pips -21,3 (Slippage!) Level 1 Long 1,30615 TP 1,30715 SL 1,30305 Lotsize 0,01 Pips -30 Gewinn von 8,7 Pips Lotsize Total: 0,01 Margin Total: 2€ Gewinn EUR: 0,67 EUR RoI EUR: 33,5% RoC EUR: 0,20% Ja das stimmt...es muss kontinuierlich was bringen...gerne würde ich auch öfter handeln, aber mit dem iphone am Arbeitsplatz...naja schaut blöd aus ;-) Also wenn ich 2 Trades am Tag manuell hinbekomme ist das schon okay denke ich Derzeit teste ich mit einem Centliveaccount von Tradefort...wenn dann sollen die Quotes schon realistisch sein und ich will da nicht selber herum Mogeln :) Also ...es ist ernst :) Auch wenn es n centaccount ist ;-)

Also gewonnen habe ich heute nun 2 mal...je öfter ich drehen würde, desto mehr Gewinn erziele ich rechnerisch auch...Deshalb wäre es interessant im schlimmsten Fall, also wenn man mit vielen vielen Positionen im Markt ist, einfach einen "Aus-Knopf" zu haben der alles schließen kann...Und bisher habe ich drei mal stetige Gewinne eingefahren :)

Hi Licens, also die Slippage hatte ich bei dem Trade schon mit Berücksichtigt...der jetzige Trade ist zum Glück ebenfalls im Gewinn geschlossen und nach Slippage waren es dann 0,67€... Der Einstieg war übrigens willkürlich gewählt...Lies sich einfacher rechnen ;-)

Ein Problem des händischen Trading merke ich gerade...Der Spread ändert sich und man ist mit einer Seite rausgeworfen worden und mit der anderen noch drin :( Es müsste also automatisiert so laufen, dass wenn der TP erreicht wird, alle Positionen geschlossen werden...das macht das ganze sicherer und sorgt dafür, dass der Broker nicht aufeinmal anfängt den Spread zu drehen wie er Lustig ist...

So...fertig gehandelt: Folgende Trades habe ich getätigt... Equity 331,07€, Hebel 1:500, Faktor von 0,75 Initialtrade Long 1,30863 TP 1,31063 SL 1,30663 Lotsize 0,01 Pips -20 Short 1,30848 TP 1,30648 SL 1,31048 Lotsize 0,01 Pips +20 Level 1 Long 1,30963 TP 1,31063 SL 1,30663 Lotsize 0,01 Pips -30 Level 2 Short 1,30848 TP 1,30648 SL 1,31048 Lotsize 0,01 Pips +20 Level 3 Short 1,30748 TP 1,30648 SL 1,31048 Lotsize 0,02 Pips +20 Gewinn von 10 Pips Lotsize Total: 0,01 Margin Total: 2€ Gewinn EUR: 0,77 EUR RoI EUR: 38,5% RoC EUR: 0,23% Alles in allem eigentlich okay denke ich

Heute wird neu getestet...ich gehe nun keine Hedgepositionen ein, sondern verringere den Faktor...rechnerisch habe ich gestern bei einem Faktor von 0,75 nach 10 Leveln (wenn ich das noch richtig im Kopf habe) gerade mal 3,2% bei 1000€ Equity eingesetzt kam kam ohne Spread auf 90Pips...also weiter testen...

Nach deiner Erklärung dürften es hinzukommende Posis sein. Es will mir jedoch nicht in meinem Kopf warum du Long und Short gleichzeitig tiggerst statt nur eine Seite (halt den Unterschied zwischen Long und Short) hinzufügst. Mit einem Zähler der die Liniendurchbrüche zählt könnte dann als dein Multiplikator dienen. Dann sparst du doch Slippage und Brokergebühren und würdest bei einem Seitwärtsmarkt trotzdem Long und Short posis im Markt haben jedoch mit viel kleineren Posis mit dem selben Profit - und würdest auch länger im Seitwärtsmarkt durchhalten. Nette Idee...habe ich noch nicht drüber nachgedacht...Bin wahrscheinlich zu fixiert bisher...Prinzipiell würde es auch reichen, dass ich nur eine Initialorder eingehe...zum Beispiel long über dem vorherigen high oder highest high ...ist ja auch egal wo...und dann anfange mit dem Multiplikator zu rechnen...ich müsste ohne die Gegenseite einzugehen dann lediglich den faktor halbieren... Was ich aber in Seitwärtsphasen habe kommt erst noch... Stell Dir vor du bis long und short...Initialtrade...dann bewegt sich der Markt in deine Richtung um 10 Pips...also was passiert...ich gehe long mit faktor und mit halbiertem hedge...jetzt mache ich folgendes...ich tue einfach so als wenn ich gar keine Position offen habe und spiele bei dem ersten Level die Initialpositionierung nach...was passiert? Habe jetzt 2 Initialtrades mit verschiedenen Kursen und eine Long Trend/ Short Hedge Position...jetzt bewegt sich der Markt gegen meine Richtung und ich erhöhe auf der einen Seite zu Level 2 und auf der anderen Seite zu Level 1...Wenn ich mich nicht all zu sehr irre kann ich dann auch Seitwärtsphasen überstehen und nehme dann Gewinne mit in dem ich eine Position zum schließen bringe und auf der anderen Seite dann erneut eine eröffne...Ich kopiere also meine Trades mit einem anderen Kursniveau welches meiner Range für das erste Level entspricht :) Ich hoffe das war nicht zu abstrakt ;-) musste da jetzt selber 5 mal drüber nachdenken

die kommen hinzu...am Ende hatte ich heute folgende absolute Größen: Long: 0,01 + 0,01 + 0,03 + 0,05 = 0,1 Lots Short: 0,01 + 0,02 + 0,02 + 0,03 = 0,08 Lots

Hi Siscop, vielen Dank fürs Nachfragen... Die Initialtrades habe ich um 9:05 (ich gehe davon aus, dass es brokertime ist) Habe da nicht drauf geachtet ;-) Um 9:29 wurde der SellStop getriggert...Lotsize short 0,02 und long 0,01 Um 9:58 wurde der BuyStop getriggert...Lotsize long 0,03 und short 0,02 Um 10:20 wurde der dritte BuyStop getriggert...Lotsize long 0,05 und short 0,03 Ich hoffe, dass es nun deutlicher wurde...bei Fragen bitte gerne stellen :) ... Übrigens...Du hast Recht...ich habe mich oben verschrieben...ich hatte die Lotsize im ersten Leven beim short vergrößert und nicht beim long...mea culpa

So, der Stand für heute nach meinen Trades: Initialtrade: Long 1,30100 SL 1,29900 TP 1,30300 Lotsize 0,01 Short 1,30083 TP 1,30283 SL 1,29883 Lotsize 0,01 Level 1 Long 1,30000 SL 1,29900 TP 1,30300 Lotsize 0,02 Short 1,29982 SL 1,30283 TP 1,29883 Lotsize 0,01 level 2 Long 1,30100 SL 1,29900 TP 1,30300 Lotsize 0,03 Short 1,30083 SL 1,30283 TP 1,29883 Lotsize 0,02 Level 3 Long 1,30200 SL 1,29900 TP 1,30300 Lotsize 0,05 Short 1,30182 SL 1,30283 TP 1,29883 Lotsize 0,03 Das Kapital betrug 330,36 EuroCent. Margininanspruchnahme: 1,21% oder 4€. Bei 1,3030 wurde ich dann aus den Positionen gerissen mit SL/TP und habe mit dem Centaccount verdient: 17,75% oder 71ct auf die Margin gerechnet. 0,21% auf die Account Equity. Dis Ergebnisse Berücksichtigen den Spread. Hört sich nicht viel an, aber wenn man davon 2 oder 3 Trades am Tag hinlegt hat man auch (auf diesen Fall bezogen) 0,6% p.T. / 12% p.M. oder 144%p.a. verdient. Das ist wiederrum schon okay oder?

Wobei ich glaube, dass KB wohl eher Murphys Gesetz meinte und der Herr bei Trinkaus John Murphy Das ähm kann sogar gut sein :) Leider hat der andere Murphy zumeist immer recht :-$ Ausnahmen bestätigen aber meist die Regel...Ich muss aber gestehen, dass ich bei dem Teil zuversichtlich bin ;-) Trade gerade und bin inzwischen beim Level 3 angekommen...

Aloha KB, Du bist aber hier früh aktiv :) Danke erst mal für die Info bzgl. BWILC. Ich denke, dass man sicherlich verschiedene Arten von Einstiegsfiltern hier einbauen kann. Ich werde mir das o.g. Thema mal durchlesen... Die Hedgepositionen werden alle als Marketorders gleichzeitig mit der Trendrichtung ausgeführt...ich müsste aber mal zusehen, dass bei verschiedenen Spreads die diskrepanz ausgeblendet wird...Sprich wird eine Order eröffnet erfolgt die nächste...in diesem Fall also zuerst der "Trend" und automatisch dazu der Hedge...

Kann man irgendwie Codes einfügen (ohne, dass diese kryptisch nebeneinander und auseinander etc dargestellt werden)?

Hi KB, also der Trend ist hier bei dem EA reine Auslegungssache...Ich habe das System mal einige tage händisch getradet...leider mehr nebenher, aber auf die Einstiege geachtet und es hat da auf jeden Fall geklappt... Natürlich kann ich dafür MA benutzen, aber im Endeffekt versuche ich zu erreichen, dass mein System aus der Range von 10 Punkten um den Einstig herum weiterläuft...ob es 10 Punkte nach oben oder unten sind ist ja völlig egal dabei. Ich gewinne auf jeden Fall (solange ich genug Kohle zur Verfügung habe. Der TF spielt hier auch keine große Rolle...lediglich die Handelszeit würde ich in diesem Fall schon in Betracht ziehen wollen...als Beispiel zwischen 7-19Uhr den Tag hinaus... Der Drawdown ist in diesem Falle zum Glück ja nur auf die Pips beschränkt die ich als SL festgelegt habe...er wird ja zusätzlich noch abgehedged...Die Seitwärtsphase muss ich aber auf jeden Fall aushalten bis ich im Gewinn bin..Zur Not wäre die Überlegung einen Notausstieg zu basteln wenn ich mit x Lots oder %-ualer Equity investiert bin und den Breakeven erreicht habe...sprich plus minus Null heraus komme...aber soweit habe ich erst mal noch gar nicht gedacht ;-) Auf den ersten blick vll schon...ich wollte mit meiner Idee ein System umsetzen bei dem es egal ist ob ein Trend oder eine Seitwärtsphase gibt...Also hatte ich mich dazu entschlossen zu hedgen...darüber hinaus kann das noch attraktiv ewrden wenn man rebates vom broker erhält...somit gibt es also ggf ein wenig Cashback ;-) Hi KB, mache Dich mal nicht schlechter als Du bist ;-) Ich habe genau so viel oder genau so viel Erfahrung wie sicherlich einige hier. Was ist denn BWILC? Davon habe ich noch nicht gehört...Ich muss ja gestehen, dass ich auch kein so großer Freund von Martingale-Strategien sind, weil diese EA's irgendwann sicherlich hopps gehen werden. Das Thema inverse Martingale muss ich auf jeden Fall mal nachlesen... Der Gute Murphy wurde mir übrigens auch vom Leiter des technischen Tradings bei Trinkaus empfohlen ;-) Ob dies hier der heilige Gral ist...bezweifel ich, aber ich glaube hier einen (Über-)Lebensfähigen EA vom Grundgedanken her "geschaffen" zu haben...Wobei ich das eher ganz vorsichtig sagen will. Weiterhin ist aber immer noch das gleiche Problem...wie bekomme ich den EA dazu so technisch zu vervollständigen, dass er auch wirklich so handelt wie die Handelslogik es will :) Daran hapert es... Hier übrigens die Logik: Handelslogik: --> 1.1 Wenn es keine offene Positionen gibt und die TradingTime, TradingDay und Spread 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 und m_SL_Initial von je x Pip. --> 2.1 Bewegt sich der Kurs in irgendeine Richtung um m_Range_Initial_Initial_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 in Höhe von m_TP_in_Trend_Long_Level1 und SL in Höhe von m_SL_in_Trend_Long_Level1. --> 2.2 Gleichzeitig wird eine Hedgeposition entgegen der Trendrichtung: m_Start_Lotsize(höchste Lotsize aus dem vorherigen Trade Punkt 2.1)/m_Lotsize_Faktor_Hedge(höchste Lotsize aus dem aktuellen Trade Punkt 2.2) mit einem TP in Höhe von m_TP_Hedge_Short_Level1 und einem SL in Höhe von m_SL_Hedge_Short_Level1 aufgebaut. --> 2.3 Sollte der Markt in Trendrichtung um die vorgegebenen TP un SL weiterlaufen 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 in Höhe von m_TP_in_Trend_Short_Level2 wird eröffnet. --> 3.3 Gleichzeitig wird und eine Hedgeposition entgegen der Trendrichtung: m_Start_Lotsize(höchste Lotsize aus dem vorherigen Trade Punkt 3.2)/m_Lotsize_Faktor_Hedge(höchste Lotsize aus dem aktuellen Trade Punkt 3.3) mit einem TP in Höhe von m_TP_Hedge_Long_Level2 und einem SL in Höhe von m_SL_Hedge_Long_Level2 aufgebaut. --> 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 in Höhe von m_TP_in_Trend_Short_Level1 und SL in Höhe von m_SL_in_Trend_Long_Level1 --> 4.2 Gleichzeitig wird und eine Hedgeposition entgegen der Trendrichtung: m_Start_Lotsize(höchste Lotsize aus dem vorherigen Trade Punkt 4.1)/m_Lotsize_Faktor_Hedge(höchste Lotsize aus dem aktuellen Trade Punkt 4.2) mit einem TP in Höhe von m_TP_Hedge_Long_Level1 und einem SL in Höhe von m_SL_Hedge_Long_Level1 aufgebaut. --> 5.1 Sollte der Markt in Trendrichtung um die vorgegebenen TP un SL weiterlaufen 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 und genau diese Position dann mit der Hälfte abgesichert. SL und TP ergeben sich jeweils aus den Levels. Dabei muss sich für einen neu zu öffnenden Trade der Kurs des Underlyings immer um 10 Pips in eine Richtung geändert haben bevor entweder alle Trades durch erreichen der TP und SL geschlossen oder 2 neue Trades nach bekanntem Schema eröffnet werden.

Eigentlich total simpel...und nun ziehe ich die Hosen aus ;-) Als Beispiel: Ich nehme irgendeinen x-beliebigen Kurs...Der einfachheithalber 1,3000 beim EUR/USD. Ich gehe long und short (Spread mal unberücksichtigt) Habe also 2 Positionen zu dem o.g. Kurs auf. Nun lege ich SL und TP fest...als beispiel jeweils 20. Also Long 1,3000 TP 1,3020 SL 1,2980 Lots 0,01 Also Short 1,3000 TP 1,2980 SL 1,3020 Lots 0,01 --> ergibt in der Summe (ohne den Spread zu Berücksichtigen) ein Null-Summenspiel! Ich gebe dem Programm allerdings vor, dass der Kurs sich um meinen Einstieg (1,3000) in einer minimalen Range bewegen muss, damit ich hier einen "Trend" vorliegen habe und der liegt bei mindestens 10 Pips. Steigt der Kurs auf 1,3010 dann gehe ich long und multipliziere meine Lotsize aus dervorherigen Position mit der größten Lotsize ( in diesem Fall 0,01) mit dem Faktor 1,5. Ergo bin ich Long zu 1,3010 mit Lotsize 0,02. Der SL und TP ist weiterhin der aus dem ersten Trade...also SL 1,2980 und TP 1,3020. Gleichzeitig wird eine neue shortposition bei 1,3010 mit der halben Lotisze aus der in Trendrichtung gehenden Position...also 0,02/2 = 0,01 Das bedeutet: Short 1,3010 mit SL 1,3020 und TP 1,2980. Ich habe nun 4 offene Positionen: Initiallong 1,3000 TP 1,3020 SL 1,2980 Lotsize 0,01 Initialshort 1,3000 SL 1,3020 TP 1,2980 Lotsize 0,01 Kurs steigt auf 1,3010 TrendLong 1,3010 TP 1,3020 SL 1,2980 Lotsize 0,02 ShortHedge 1,3010 TP 1,2980 SL 1,3020 Lotsize 0,01 Sollte der Kurs dann auf 1,3020 steigen...habe ich einen kleinen Gewinn erwirtschaftet. Sollte der Kurs fallen wird dann bei 1,3000 wieder short gegangen mit Lotsizefaktorerhöhung aus dem Trade vorher mit der größten Lotsize...und natürlich abgehedged werden mit der halbierten Lotsize... Ich hoffe das Prinzip ist nun verständlich ;-)

Sozusagen...also ich nehme einen Initialeinstieg zum Beispiel 1,3000 beim EURUSD und sage dem EA...Bewege Dich in einer maximalen Range von zum Beispiel 20 Punkten und gehe in Trendrichtung wenn der Kurs um 10 Pips vom Einstieg in eine Richtung gelaufen ist... Ich könnte ja mal den kompletten File hier posten...ist ne Menge und es fehlt auch noch viel denke ich...

Hallo Mythos, genau das soll der machen...ab einem Level eine neue Order mit Faktor x Lotsize in Trendrichtung aufbauen und mit der hälfte eine weitere Order zum abhedgen...um es mal zu simulieren: Ich habe je eine Order Long/Short mit Lotsize 0,01 drin...der Kurs steigt um x Pips und ich gehe in Trendrichtung mit Lotsize * x erneut Long und habe dann somit 2 Long Positionen mit 0,01 und 0,02 im Markt. Gleichzeitig wird eine weitere Short Position eröffnet...anstatt aber mit 0,02 nehme ich die Lotsize aus der Trenderhöhung und teile diese durch 2...bin also Short mit 2 Positionen je 0,01...

Es ist doch nie zu spät um Hallo zusagen :) Vielen Dank für die Begrüßung :)