Jump to content
Tom Next - Daytrading Community

_guest_

Addict
  • Posts

    59
  • Joined

  • Last visited

Community Informationen

  • Newsletter Abonnement
    Kein Abo
  • Typ Newsletter
    Keine

Verschiedenes

  • auf die Community aufmerksam geworden durch
    Google

_guest_'s Achievements

Newbie

Newbie (1/14)

4

Reputation

  1. Guten Morgen...und? Wie schaut es aus? Ein Monat ist wieder rum...hat sich etwas getan? Danke für Deine bisherigen Ausführungen Mythos *Thumbsup*
  2. Hallo Zusammen, ich habe es geschafft zumindest die Initialtrades raus zu hauen und diese sogar über eine Ordermodify-Funktion zu implementieren...Was anfänglich falsch war kann ich nicht sagen, aber ich weiß was nun richtig ist: //+------------------------------------------------------------------+//| expert initialization function |//+------------------------------------------------------------------+int init(){ if(Digits == 3 || Digits == 5) UsePoint = 10 * Point; else if(Digits == 2 || Digits == 4) UsePoint = Point; UseRange_Initial = m_Range_Initial*UsePoint; //UseRange bekommt den Wert m_Range_Initial*UsePoint UseSlippage = GetSlippage(Symbol(), m_Slippage);}...//--->Ermitteln und Eröffnen der Initialpositionen in der init start()void Initialpositionierung() { if (CountLong(m_Magicnumber_long) == 0 && initialpositioniert == false) //Wenn CountLong den Wert 0 hat und initialpositioniert den Wert 0 hat... { double OpenPriceBuy = Ask; RefreshRates(); while(IsTradeContextBusy()) Sleep(100); int IniLong = OrderSend(Symbol(), OP_BUY, m_Start_Lotsize, OpenPriceBuy, UseSlippage, 0, 0, "InitialLong", m_Magicnumber_long,0, Green); Print (" IniLong=",IniLong," : Volumen = ",m_Start_Lotsize," bei Preis =",Ask); if (IniLong > 0) { if (m_SL_Emergency > 0) double BuyStopLoss = OpenPriceBuy - (m_SL_Emergency * UsePoint); if (m_TP_Initial > 0) double BuyTakeProfit = OpenPriceBuy + (m_TP_Initial * UsePoint); RefreshRates(); while(IsTradeContextBusy()) Sleep(100); bool IniLongMod = OrderModify(IniLong, OrderTicket(), BuyStopLoss, BuyTakeProfit, 0, CLR_NONE); Print (" IniLongMod=",IniLongMod, " bei Preis =", Ask, " mit TP bei =", BuyTakeProfit, "mit SL bei =" ,BuyStopLoss); ...
  3. Ich hatte den m_SL_Emergency mal drin, aber ich hatte weiterhin den Fehler bekommen, dass ein Wert von 0 bei der Eingabe des SL nicht erlaubt ist..."Invalid Stop" Zumindest konnte ich den Fehler jetzt darauf reduzieren die Komplexität zu verringern in dem ich die ECN Geschichte weg gelassen habe und weiß nun, dass ich einen Fehler in den Use...Befehlen drin hatte... Grundlegend scheint das was ich will bereits zu klappen...die Fehleranalyse muss ich ja irgendwo starten und habe erst mal das vereinfacht was man vereinfachen konnte...und somit war es dann ja auch logisch für mich die TP und SL erstmal in der einfachsten Variante in den Code zu integrieren bevor ich weiter suche und nichts gefunden hätte.... Immerhin kann ich dort jetzt erneut ansetzen und es wieder ausprobieren udn dann schritt für schritt das was ich vorher hatte neu integrieren :) Ich meine ich hatte schon mal den einen oder anderen Start-EA geschrieben bei dem ich 2 MA's habe gegeneinander laufen und da ging das mit dem SL und TP ohne jegliches Problem...dies hatte mich dann wieder auf die Idee gebracht ob ich es noch mal mit der Stop und Limitsetzung so ausprobieren sollte^^... Zumindest scheint wie gesagt ein teil des Codes nun doch zu funktionieren. Wenn es sich heute Abend einrichten lässt werde ich daran weiter werkeln... VG und vielen Dank für die ganze Hilfe Marc
  4. Hi KB, ich habe m_SL_Emergency gestern hinzugenommen und den SL und TP direkt aus der externen Parametern in die OrderSend-Funktion übertragen. Das ganze hat über UseTP_Initial zum Beispiel nicht funktioniert...Jetzt bin ich zumindest soweit, dass die Initialtrades gemacht werden und das das Prog nun auch die Trendtrades machen will. Hier muss ich noch zusehen, dass die Lots korrekt berechnet werden. Dies ist aber bisher nicht der Fall...Ich dachte ich könnte Orderlots()*m_Lot_Faktor zur Berechnung nehmen, aber ich muss wohl generell eine Funktion einbauen die nur dafür gedacht ist die neuen Lotsizes zu berechnen und dann in der Ordersendfunktion für die Trends einzubeziehen. VG Marc
  5. Ich habe schon mal Fehler dafür ausgemacht warum das mit den Trades nicht funktioniert hat... int init() { UsePoint = PipPoint(Symbol()); UseRange_Initial = m_Range_Initial*UsePoint; //UseRange bekommt den Wert m_Range_Initial*UsePoint UseTP_Initial = m_TP_Initial*UsePoint; //UseTP_Long bekommt den Wert m_TP*UsePoint UseSL_Emergency = m_SL_Emergency*UsePoint; UseSlippage = GetSlippage(Symbol(), m_Slippage); } Daran hat es gehapert...
  6. Hi Mythos, es war nicht beabsichtigt hier ein Sklaventreiber zu sein. Ich bedanke mich weiterhin für die Hilfe die mir in diesem Forum geboten wird! VG Marc
  7. Dadurch fühle ich mich nicht angegriffen! :) Alles gut :) Zum damaligen Zeitpunkt wusste ich ja selber nicht so genau wie das Geschäft im wahren Leben läuft. Ich habe vieles so hingenommen und dachte mir immer...Wenn Der Kunde verdient und wir eben so dann ist alles okay...aber wenn ich daran denke wie viele Kunden (mit denen ich mal Kontakt hatte) Geld verlieren, dann ist das schon mies :( Natürlich habe ich versucht ne Menge Konten zu eröffnen und das hat auch Spaß gemacht..wenn ich überlege für welchen "Mikrigen" Lohn ich teilweise von 8 bis halb 10 da auf der Arbeit gesessen habe und extras geliefert habe,,,, Chartanalysen...Indikatorenerklärugen etc... Für mich war das Geschäft für die Bank eine kleine Cashcow...der Kunde verdient und wir...klar muss der Handeln...ohne geht es ja auch nicht ;-) Übrigens fuhr Herr Stobbe damals einen CLS AMG mit ich glaube 6,3 Litern....schöner Wagen...die Livekundenbetreuer hatten einen Mini und der damalige Analyst...Herr P*** der längst bei der Deutschen Bank arbeitet...hatte einen BMW Z3....ich weiß nur nicht ob der über die Bank lief^^
  8. Hallo nochmals...habe übrigens fest gestellt...das Notepad++ zeigt zumindest die Klammern an... hier nun der aktualisierte Code...leider bekomme ich einen Fehlerhinweis auf eine falsche Klammer (left paranthesis)...kann aber nichts finden...kann jemand von euch mal schauen? GridRange31.12.2012.mq4;428:2;'\end_of_program' - unbalanced left parenthesis //+------------------------------------------------------------------+ //| 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 /Version 29.12.2012 Anpassen der Initialorders mit Handelserlaubnis und weiteren Kommentaren. Einfügen der Kommentare in der Ordermodify. Handelssessions als Hilfe beigefügt. / */ //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- #property copyright "Marc Stolic" #property link "no link available" #include <stdlib.mqh> #include <stderror.mqh> #import "stdlib.ex4" //---Eingabeparameter extern string Einstellung1 = "----------Hauptsettings---------"; extern bool m_Allow_Trading = true; // 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 = 20; //m_TP_Initial erhält den Wert 20; Initialtakeprofit, Alle anderen offenen Orders werden geschlossen sobald ein TP erreicht wird. extern double m_Slippage = 2; // extern bool m_ECN_Broker = false; //Handelt es sich um einen ECN-Broker //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 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 double GMT_Shift = 1; //Differenz GMT zu ServerZeit des Brokers 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 extern string Asian_Session = "Asian-Session 0:00 - 8:00 GMT"; extern string European_Session = "European-Session 6:00 - 16:00 GMT"; extern string NY_Session = "New-York-Session 12:00 - 21:00 GMT"; //---Globale Parameter string CS; //Kommentarfunktion double UsePoint; //Genutzer Multiplikator pro Pip double MinLotSize; //Minimale Lotsize die der Broker erlaubt double StopLevel; //Minimae Größe die der Broker vorgibt um SL's und TP's zu setzen 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 int UseSlippage; // Anpassung der Slippage an GetSlippage 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 int ErrorCode; //Anzeige der Fehler die innerhalb des EA's bei der Ausführung auftauchen //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //+------------------------------------------------------------------+ //| expert initialization function | //+------------------------------------------------------------------+ int init() { if(Digits == 3 || Digits == 5) UsePoint = 10 * Point; else UsePoint = Point; CS = "GridRange EA CIInvest"; UseRange_Initial = NormalizeDouble(m_Range_Initial*UsePoint, Digits); //UseRange bekommt den Wert m_Range_Initial*UsePoint UseTP_Initial = NormalizeDouble(m_TP_Initial*UsePoint, Digits); //UseTP_Long bekommt den Wert m_TP*UsePoint UseSlippage = NormalizeDouble(GetSlippage(Symbol(), m_Slippage), Digits); } //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //+------------------------------------------------------------------+ //| expert start function | //+------------------------------------------------------------------+ int start() { if (m_Allow_Trading == true) { if (Montag == true && DayOfWeek() == 1 || Dienstag == true && DayOfWeek() == 2 || Mittwoch == true && DayOfWeek() == 3 || Donnerstag == true && DayOfWeek() == 4 || Freitag == true && DayOfWeek() == 5) { if (StartTradingHour + GMT_Shift >= Hour() && StartTradingMinute >= Minute() && StopTradingHour + GMT_Shift >=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_Long } if (initialpositioniert == true && CountLong(m_Magicnumber_long) >=1 && CountShort(m_Magicnumber_short) >= 1 && initialShortwert > Bid+(UseRange_Initial)) { Trendfolge_Trades_Short(); //Springe zu Trendfolge_Trades_Short } } } } } //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--->Ermitteln und Eröffnen der Initialpositionen void Initialpositionierung() { if (m_ECN_Broker == true) { 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 IniLongECN = OrderSend(Symbol(), OP_BUY, m_Start_Lotsize, Ask, UseSlippage, 0, 0, "InitialLong", m_Magicnumber_long,0, Green); Print (" IniLong = ",IniLongECN," : Volumen = ",m_Start_Lotsize," bei Preis = " if (IniLongECN > 0) { RefreshRates(); while(IsTradeContextBusy()) Sleep(100); bool IniLongModECN = OrderModify(IniLongECN, OrderTicket(), 0, UseTP_Initial, 0, CLR_NONE); Print (" IniLongMod = ",IniLongModECN, " bei Preis = ", Ask, " mit TP bei = ", Ask + UseTP_Initial); if (IniLongModECN < 0) { ErrorCode = GetLastError(); string ErrorDescIniLongMod = ErrorDescription(ErrorCode); string ErrorAlertIniLongMod = StringConcatenate("OP_BUY-Initial-Modifiy does not work ", ErrorCode, " ", ErrorDescIniLongMod); Print(ErrorAlertIniLongMod); Print("Handel gestoppt! - OP_BUY-Modifikation"); return(0); } } if (IniLongECN < 0) { ErrorCode = GetLastError(); string ErrorDescIniLongECN = ErrorDescription(ErrorCode); string ErrorAlertIniLongECN = StringConcatenate("OP_BUY-Initial does not work ", ErrorCode, " ", ErrorDescIniLongECN); Print(ErrorAlertIniLongECN); Print("Handel gestoppt! - OP_Buy-Initial"); return(0); } return(IniLongECN); } 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 IniShortECN = OrderSend(Symbol(), OP_SELL, m_Start_Lotsize, Bid, UseSlippage, 0, 0, "InitialShort", m_Magicnumber_short,0, Red); Print (" IniShort = ",IniShortECN," : Volumen = ",m_Start_Lotsize," bei Preis = ",Bid); if (IniShortECN > 0) { RefreshRates(); while(IsTradeContextBusy()) Sleep(100); bool IniShortModECN = OrderModify(IniShortECN, OrderTicket(), 0, UseTP_Initial, 0, CLR_NONE); Print (" IniShortMod = ",IniShortModECN, " bei Preis = ",Bid, " mit TP bei = ", Bid - UseTP_Initial); if (IniShortModECN < 0) { ErrorCode = GetLastError(); string ErrorDescIniShortModECN = ErrorDescription(ErrorCode); string ErrorAlertIniShortModECN = StringConcatenate("OP_SELL-Initial-Modifiy does not work ", ErrorCode, " ", ErrorDescIniShortModECN); Print(ErrorAlertIniShortModECN); Print("Handel gestoppt! - OP_SELL-Modifikation"); return(0); } } if (IniShortECN < 0) { ErrorCode = GetLastError(); string ErrorDescIniShortECN = ErrorDescription(ErrorCode); string ErrorAlertIniShortECN = StringConcatenate("OP_SELL-Initial does not work ", ErrorCode, " ", ErrorDescIniShortECN); Print(ErrorAlertIniShortECN); Print("Handel gestoppt! - OP_SELL-Initial"); return(0); } return(IniShortECN); } } else { if (m_ECN_Broker == false) { 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, UseTP_Initial, "InitialLong", m_Magicnumber_long,0, Green); Print (" IniLong = ",IniLong," : Volumen = ",m_Start_Lotsize," bei Preis = ",Ask); if (IniLong < 0) { ErrorCode = GetLastError(); string ErrorDescIniLong = ErrorDescription(ErrorCode); string ErrorAlertIniLong = StringConcatenate("OP_BUY-Initial does not work ", ErrorCode, " ", ErrorDescIniLong); Print(ErrorAlertIniLong); Print("Handel gestoppt! - OP_Buy-Initial"); 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, UseTP_Initial, "InitialShort", m_Magicnumber_short,0, Red); Print (" IniShort = ",IniShort," : Volumen = ",m_Start_Lotsize," bei Preis = ",Bid); if (IniShort < 0) { ErrorCode = GetLastError(); string ErrorDescIniShort = ErrorDescription(ErrorCode); string ErrorAlertIniShort = StringConcatenate("OP_SELL-Initial does not work ", ErrorCode, " ", ErrorDescIniShort); Print(ErrorAlertIniShort); Print("Handel gestoppt! - OP_SELL-Initial"); 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, NormalizeDouble(OrderLots()*m_Lotsize_Faktor, 2), 0, 0 ,0 , "Trendfolge Long",0, Green); if(TrendLongTicket < 0) { ErrorCode = GetLastError(); string ErrorDescLongTrend = ErrorDescription(ErrorCode); string ErrorAlertLongTrend = StringConcatenate("OP_BUY-Trend does not work ", ErrorCode, " ", ErrorDescLongTrend); Print(ErrorAlertLongTrend); Print("Handel gestoppt! - Trendfolge_Trades_Long"); 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, NormalizeDouble(OrderLots()*m_Lotsize_Faktor, 2), 0, 0 ,0 , "Trendfolge Short",0, Red); if(TrendShortTicket < 0) { ErrorCode = GetLastError(); string ErrorDescShortTrend = ErrorDescription(ErrorCode); string ErrorAlertShortTrend = StringConcatenate("OP_SELL-Trend does not work ", ErrorCode, " ", ErrorDescShortTrend); Print(ErrorAlertShortTrend); Print("Handel gestoppt! - Trendfolge_Trades_Short"); } return(TrendShortTicket); } TrendShort = ShortPrice(TrendShortTicket); } //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--->Ordermodifikation der Initialpositionen //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--->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 < 0) { ErrorCode = GetLastError(); string ErrorDesc = ErrorDescription(ErrorCode); string ErrAlert = StringConcatenate("CloseAll does not work", ErrorCode, ErrorDesc); Print("Handel gestoppt! - Es konnten nicht alle Trades geschlossen werden - CloseAll"); 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_Long = 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_Long++; } } } return(RETURNER_Long); } //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--->Aufzählen der Orders Short int CountShort(int m_Magicnumber_short) { int RETURNER_Short = 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_Short++; } } } return(RETURNER_Short); } //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--->Aufzählen aller Orders //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //--->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); }
  9. Aloha, kann jemand von euch einen eventuell besseren Editor empfehlen? Es ist zwar schön, dass Fehler beim kompilieren angezeigt werden, aber manchmal hilft das auch nichts... Übrigens einen guten Rutsch an euch :)
  10. Genau...bitte seht es mir nach ;-) Ist auch schon was länger her...
  11. 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
  12. Kann schon jemand evtl helfen? *liebfrag*
  13. Das haben aber sicherlich fast alle Broker gemacht die dort oben stehen wollten...(siehe Brokerwahl) Ich habe selber mal bei der FX gearbeitet...ein halbes Jahr
  14. 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); }
  15. 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
×
×
  • Create New...