Grid Range EA

[Kleinerbroker]

Ab der Zeile 157 entnommen :

 

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

füge ich nun zusätzlich ein :

 

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

 

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

 

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

 

KB

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

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

[Mythos]

grundsätzlich macht es Sinn bei solchen Problemen einfach ein Print (wie bei KB) einzubauen, das alle übergebenen Parameter 1:1 ausgibt. In der TB hab ich das AFAIR für das höchste Debuglevel so drin. Ist zwar extrem viel output wenn man ihn nicht braucht, aber wenn was falsch läuft braucht man nit lang probieren sondern sieht gleich wo es hackt.

 

bzgl. Invalid Lotsize würde ich empfehlen die übergebene Lotsize immer mit den MIN_LOT, MAX_LOT und LOT_STEP (ich hoff die heißen so) aus MarketInfo zu "normalisieren". (Beispielfunktion wie das geht gibts natürlich auch in der TB)

[Kleinerbroker]

@mast : Aus meiner persönlichen Erfahung (!!) : Du solltest Dir wirklich unbedingt die TB von Mythos schnappen und einmal durcharbeiten, danach nur noch benutzen .

 

Es gibt gerade beim Orderhandling mit MT4 soviel zu beachten, dass die erstmalige Einarbeitung vor der Du jetzt gerade stehst recht aufwendig ist , sich danach aber immer nur noch wiederholt . Und wenn Du dann jedesmal neu codest, dann hälst Du Dich selber gut aber unnötig beschäftigt, weil Du jedesmal neu debuggen mußt .

 

Wenn Du hingegen die TB einmal durcharbeitest, damit Du das Verständnis hast, dann ist das gut und richtig und meiner persönlichen Meinung nach auch wichtig (Inhalte aneignen) . Danach aber ist es effizienter, einfach "die TB neben Deinen EA zu stellen" und deren Inhalt zu vergessen und Deine volle Aufmerksamkeit auf den eigentlichen , eigenen EA zu richten .

 

KB

[_guest_]

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 :)

[Kleinerbroker]

Eh ... Aloha Eh ,

 

ich kenne nur den einen Editor , mußt Dich glaube ich , durchbeissen .

 

Gibt ein paar Erleichterungen, die aber nur die Visualisierung erleichtern/verbessern . Finden sich unter Tool > Options > ... ich nutze die Farben und die Schriftgröße

 

 

Es ist zwar schön, dass Fehler beim kompilieren angezeigt werden, aber manchmal hilft das auch nichts...

Erzähl mal, was findet sich denn da so ?

 

KB

[_guest_]

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

1.  
   
    
   //+------------------------------------------------------------------+
   //|                                                    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);
   }
   

Edited January 1, 2013 by whipsaw

[Kleinerbroker]

 

 

(left paranthesis)...kann aber nichts finden...kann jemand von euch mal schauen?

mein Favorit

 

 

* Mal in KB´S Trickkiste kramt* : Gefunden ! => Nutze

/* viele Zeilen Code */

um Code zu deaktivieren und in Kommentare zu wandeln, dann kompiliere . Deaktivere ganze Blöcke . Weite solange aus, bis Du ohne Fehlermeldung kompilierst . Dann verschiebst Du das " */ " zurück , bis die Fehlermeldung wieder auftritt . Dadurch findest Du den Bereich in Deinem Code, der fehlerbehaftet ist .

 

Ich guck gerade Udo Lindenberg Unplugged bei 3Sat , sorry, aber ich drück Dir feste die Daumen .

 

KB

[Mythos]

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?

Sorry aber mal im Ernst: Erwartest du wirklich das wir hier für dich den gesamten Code durchgehen auf der Suche nach einer fehlenden Klammer? Wir helfen ja gerne aber wir sind keine Arbeitssklaven an die man alles outsourcen kann wenn einem gerade die Lust fehlt.

Nichts für ungut aber das musste mal gesagt werden.

 

btw. wäre toll wenn du

[detail] Code... [/detail]

um diese elendslangen Codeblöcke packst damit es den Thread nicht unnötig aufbläht

[_guest_]

 

Sorry aber mal im Ernst: Erwartest du wirklich das wir hier für dich den gesamten Code durchgehen auf der Suche nach einer fehlenden Klammer? Wir helfen ja gerne aber wir sind keine Arbeitssklaven an die man alles outsourcen kann wenn einem gerade die Lust fehlt.

Nichts für ungut aber das musste mal gesagt werden.

 

btw. wäre toll wenn du

[detail] Code... [/detail]

um diese elendslangen Codeblöcke packst damit es den Thread nicht unnötig aufbläht

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

[Kleinerbroker]

jooo, meinerseits werde ich mich gerne weiter einbringen, so wie bisher, so wie Mythos das auch oben meint . Türen öffnen und jeder(Marc) entscheidet dann, ob er durchgeht nicht .

In diesem Fall hatte ich per PN Kontakt aufgenommen um zusätzlich zu empfehlen, wie Mythos oben auch : Nehme Komplexität raus .

 

Genau wie Mast habe ich am Anfang meiner Coderei vor ca 2 Jahren die eierlegende Traderwollmilchsau coden wollen, mit Martinggale und Hedgen und allem Schnick und allem Schnack . Und die Kollegen die mich länger kennen, wissen wie ich immer mehr abspecken mußte . Nur damit ich dann neu ansetzen konnte und wieder ein Stück mehr dazu zulernen . Es braucht Zeit .

 

@Mast : Gebe Dir mal "ein Jahr +" Zeit , wenn Du einen EA coden willst, der dauerhaft kein Geld verliert . Dann bist Du doppelt so schnell wie ich und ich habe das Ziel jetzt noch nicht erreicht . Verlasse Dich darauf, dass ich auch nicht aufgeben werde, es macht mir viel zuviel Spaß . Aber der Wettbewerb ist groß, ganze IT Abteilungen der verschiedenen Banken sind gegen uns . Das WWW ist voller Geheimniskrämer die gerne mitlesen aber ungerne Preis geben . Du wirst schneller voran kommen, wenn Du erst eine kleine KeimZelle , Dein erster eigener EA , entwickelst und diese dann wachsen läst . Aber da wiederhole ich mich nun .

 

Hier im Forum wird Dir (wurde mir zumindest) immer geholfen, die nächste Türe wurde geöffnet . Nochmals , Durchlaufen muß dann jeder selber , kann Dir keiner abnehmen . Und das schon alleine deswegen nicht, weil nicht nur jeder diskretionäre Trader ganz individuell , sondern (scheinbar) auch jeder Coder seinen eigenen Weg zum erfolgreichen Traden erarbeiten muss .

 

KB

[Kleinerbroker]

Ich nochmal

 

Prävention : Ich baue in neuen Code sofort konditionierte Print-Befehle ein . If (Debugging == true) Print ("ALLES was es wissenswertes geben könnte") ;

 

Im Test schaltest Du dann die boolsche Variable Debugging auf true/false je nachdem ob Du die Information im Journal willst oder nicht .

Wenn Dein eigener Code größer wird, dann machst Dir mehrere boolsche Variablen Debugg1 , Debugg2 usw und dadurch hast Du dann nur die Info, die Dich gerade interessiert

 

KB

[_guest_]

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... Edited January 1, 2013 by Mythos

[Kleinerbroker]

Moin :-)

 

Du meinst, dass es in diesem Bereich einen Fehler geben muss ? Oder hast Du den Fehler nun schon korrigiert ?

 

Mir fällt die Variable

m_SL_Emergency

auf .

Jede Variable die Du im Program aufrufst, mußt Du vorher definieren . Im Code ganz oben ist das nicht der Fall .

 

Die Init() in Post #87 müßte eigentlich einen Fehler beim kompilieren liefern .

 

KB

[_guest_]

Moin :-)

 

Du meinst, dass es in diesem Bereich einen Fehler geben muss ? Oder hast Du den Fehler nun schon korrigiert ?

 

Mir fällt die Variable

m_SL_Emergency

auf .

Jede Variable die Du im Program aufrufst, mußt Du vorher definieren . Im Code ganz oben ist das nicht der Fall .

 

Die Init() in Post #87 müßte eigentlich einen Fehler beim kompilieren liefern .

 

KB

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

[Kleinerbroker]

 

Mir fällt die Variable

m_SL_Emergency

auf

Schritt zurück für mich zum Verständnis : Du hast also diese Variable

m_SL_Emergency

weiter oben im Code definiert und der geändert Code kompiliert ohne Probleme durch ?

 

Frage : Es entsteht bei mir der Eindruck, dass Du jedenfalls diesen Code oben zuerst ans laufen bekommen möchtest, bevor Du Dich mit anderen Empfehlungen auseinander setzt ?

 

 

KB

[siscop]

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 :)

Frohes neues Jahr

 

 

Schau mal hier

Notepad++@TN

Notepad++ ist ein sehr gute Alternative für MQL code - vor allem offen und selbst einstellbar.

oder halt UltraEdit wenn man bezahlen möchte.

[Kleinerbroker]

@siscop , genialer Hinweis, hilft mir auch , Danke !

 

UltraEdit auch kostenlos ?

 

Grüße

KB

[_guest_]

Schritt zurück für mich zum Verständnis : Du hast also diese Variable

m_SL_Emergency

weiter oben im Code definiert und der geändert Code kompiliert ohne Probleme durch ?

 

Frage : Es entsteht bei mir der Eindruck, dass Du jedenfalls diesen Code oben zuerst ans laufen bekommen möchtest, bevor Du Dich mit anderen Empfehlungen auseinander setzt ?

 

 

KB

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

[_guest_]

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);        ...