ForumKategorien

Indikatoren: MACD Crossing the zero level (color candles) - Seite 3

Neuer Kommentar
Andrey F. Zelinsky:

posten Sie den Code mit Ihren Änderungen - erklären Sie, welche Änderungen Sie vorgenommen haben - mal sehen.

Wenn Sie daran interessiert sind, es selbst zu tun, gibt es eine Chance, es herauszufinden.


#property copyright   "Copyright 2009-2013, MetaQuotes Software Corp."
#property link        "http://www.mql5.com"
#property version     "5.20"
#property description "It is important to make sure that the expert works with a normal"
#property description "chart and the user did not make any mistakes setting input"
#property description "variables (Lots, TakeProfit, TrailingStop) in our case,"
#property description "we check TakeProfit on a chart of more than 2*trend_period bars"
//---
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\AccountInfo.mqh>
//---
input double InpLots          =0.1; // Lose.
input int    InpTakeProfit    =50;  // Gewinnmitnahme (in Pips)
input int    InpTrailingStop  =30;  // Trailing Stop Level (in Pips)
input int    InpMACDOpenLevel =3;   // MACD offenes Niveau (in Pips)
input int    InpMACDCloseLevel=2;   // MACD-Schlussstand (in Pips)
input int    InpMATrendPeriod =26;  // MA-Trendzeitraum
//---
int ExtTimeOut=10; // Zeitspanne in Sekunden zwischen den Handelsoperationen
//+------------------------------------------------------------------+
//| MACD Beispiel-Expertenklasse|
//+------------------------------------------------------------------+
class CSampleExpert
  {
protected:
   double            m_adjusted_point;             // Punktwert angepasst für 3 oder 5 Punkte
   CTrade            m_trade;                      // Handelsobjekt
   CSymbolInfo       m_symbol;                     // Symbol-Info-Objekt
   CPositionInfo     m_position;                   // Handelsposition Objekt
   CAccountInfo      m_account;                    // Kontoinfo-Verpackung
   //--- Indikatoren
   int               m_handle_macd;                // MACD-Indikator-Handle
   
   //--- Indikatorpuffer
   double            m_buff_MACD_main[];           // Hauptpuffer des MACD-Indikators
   
  
   //--- Indikatordaten für die Verarbeitung
   double            m_macd_current;
   double            m_macd_previous;
   

   //---
   double            m_macd_open_level;
   double            m_macd_close_level;
   double            m_traling_stop;
   double            m_take_profit;

public:
                     CSampleExpert(void);
                    ~CSampleExpert(void);
   bool              Init(void);
   void              Deinit(void);
   bool              Processing(void);

protected:
   bool              InitCheckParameters(const int digits_adjust);
   bool              InitIndicators(void);
   bool              LongClosed(void);
   bool              ShortClosed(void);
   bool              LongModified(void);
   bool              ShortModified(void);
   bool              LongOpened(void);
   bool              ShortOpened(void);
  };
//--- globaler Experte
CSampleExpert ExtExpert;
//+------------------------------------------------------------------+
//| Konstruktor|
//+------------------------------------------------------------------+
CSampleExpert::CSampleExpert(void) : m_adjusted_point(0),
                                     m_handle_macd(INVALID_HANDLE),
                                     
                                     m_macd_current(0),
                                     m_macd_previous(0),                                                                   
                                     m_macd_open_level(0),
                                     m_macd_close_level(0),
                                     m_traling_stop(0),
                                     m_take_profit(0)
  {
   ArraySetAsSeries(m_buff_MACD_main,true);
   
  
  }
//+------------------------------------------------------------------+
//| Destruktor|
//+------------------------------------------------------------------+
CSampleExpert::~CSampleExpert(void)
  {
  }
//+------------------------------------------------------------------+
//| Initialisierung und Prüfung auf Eingabeparameter |
//+------------------------------------------------------------------+
bool CSampleExpert::Init(void)
  {
//--- gemeinsame Informationen initialisieren
   m_symbol.Name(Symbol());              // Symbol
   m_trade.SetExpertMagicNumber(12345);  // Magie
//--- Abstimmung für 3 oder 5 Ziffern
   int digits_adjust=1;
   if(m_symbol.Digits()==3 || m_symbol.Digits()==5)
      digits_adjust=10;
   m_adjusted_point=m_symbol.Point()*digits_adjust;
//--- Standardabweichung für den Handel in angepassten Punkten festlegen
   m_macd_open_level =InpMACDOpenLevel*m_adjusted_point;
   m_macd_close_level=InpMACDCloseLevel*m_adjusted_point;
   m_traling_stop    =InpTrailingStop*m_adjusted_point;
   m_take_profit     =InpTakeProfit*m_adjusted_point;
//--- Standardabweichung für den Handel in angepassten Punkten festlegen
   m_trade.SetDeviationInPoints(3*digits_adjust);
//---
   if(!InitCheckParameters(digits_adjust))
      return(false);
   if(!InitIndicators())
      return(false);
//--- erfolgreich
   return(true);
  }
//+------------------------------------------------------------------+
//| Überprüfung auf Eingabeparameter|
//+------------------------------------------------------------------+
bool CSampleExpert::InitCheckParameters(const int digits_adjust)
  {
//--- erste Datenprüfungen
   if(InpTakeProfit*digits_adjust<m_symbol.StopsLevel())
     {
      printf("Take Profit must be greater than %d",m_symbol.StopsLevel());
      return(false);
     }
   if(InpTrailingStop*digits_adjust<m_symbol.StopsLevel())
     {
      printf("Trailing Stop must be greater than %d",m_symbol.StopsLevel());
      return(false);
     }
//--- Prüfung auf richtige Losgröße
   if(InpLots<m_symbol.LotsMin() || InpLots>m_symbol.LotsMax())
     {
      printf("Lots amount must be in the range from %f to %f",m_symbol.LotsMin(),m_symbol.LotsMax());
      return(false);
     }
   if(MathAbs(InpLots/m_symbol.LotsStep()-MathRound(InpLots/m_symbol.LotsStep()))>1.0 E-10)
     {
      printf("Lots amount is not corresponding with lot step %f",m_symbol.LotsStep());
      return(false);
     }
//--- Warnung
   if(InpTakeProfit<=InpTrailingStop)
      printf("Warning: Trailing Stop must be less than Take Profit");
//--- erfolgreich
   return(true);
  }
//+------------------------------------------------------------------+
//| Initialisierung der Indikatoren|
//+------------------------------------------------------------------+
bool CSampleExpert::InitIndicators(void)
  {
//--- MACD-Indikator erstellen
   if(m_handle_macd==INVALID_HANDLE)
      if((m_handle_macd=iMACD(NULL,0,12,26,9,PRICE_CLOSE))==INVALID_HANDLE)
        {
         printf("Error creating MACD indicator");
         return(false);
        }
//--- EMA-Indikator erstellen und zur Sammlung hinzufügen
  
      
//--- erfolgreich
   return(true);
  }
//+------------------------------------------------------------------+
//| Prüfung auf Schließen der Long-Position|
//+------------------------------------------------------------------+
bool CSampleExpert::LongClosed(void)
  {
   bool res=false;
//--- soll sie geschlossen werden?
   
      if(m_macd_current<0 && m_macd_previous>0)
         if(m_macd_current<m_macd_close_level)
           {
            //--- Position schließen
            if(m_trade.PositionClose(Symbol()))
               printf("Long position by %s to be closed",Symbol());
            else
               printf("Error closing position by %s : '%s'",Symbol(),m_trade.ResultComment());
            //--- verarbeitet und kann nicht geändert werden
            res=true;
           }
//--- Ergebnis
   return(res);
  }
//+------------------------------------------------------------------+
//| Prüfung auf Schließen der Short-Position|
//+------------------------------------------------------------------+
bool CSampleExpert::ShortClosed(void)
  {
   bool res=false;
//--- soll sie geschlossen werden?
   
      if(m_macd_current>0 && m_macd_previous<0)
         if(MathAbs(m_macd_current)>m_macd_close_level)
           {
            //--- Position schließen
            if(m_trade.PositionClose(Symbol()))
               printf("Short position by %s to be closed",Symbol());
            else
               printf("Error closing position by %s : '%s'",Symbol(),m_trade.ResultComment());
            //--- verarbeitet und kann nicht geändert werden
            res=true;
           }
//--- Ergebnis
   return(res);
  }
//+------------------------------------------------------------------+
//| Prüfung auf Änderung der Long-Position|
//+------------------------------------------------------------------+
bool CSampleExpert::LongModified(void)
  {
   bool res=false;
//--- Prüfung auf Trailing-Stop
   if(InpTrailingStop>0)
     {
      if(m_symbol.Bid()-m_position.PriceOpen()>m_adjusted_point*InpTrailingStop)
        {
         double sl=NormalizeDouble(m_symbol.Bid()-m_traling_stop,m_symbol.Digits());
         double tp=m_position.TakeProfit();
         if(m_position.StopLoss()<sl || m_position.StopLoss()==0.0)
           {
            //--- Position ändern
            if(m_trade.PositionModify(Symbol(),sl,tp))
               printf("Long position by %s to be modified",Symbol());
            else
              {
               printf("Error modifying position by %s : '%s'",Symbol(),m_trade.ResultComment());
               printf("Modify parameters : SL=%f,TP=%f",sl,tp);
              }
            //--- geändert und muss vom Experten verlassen werden
            res=true;
           }
        }
     }
//--- Ergebnis
   return(res);
  }
//+------------------------------------------------------------------+
//| Prüfung auf Veränderung der Short-Position |
//+------------------------------------------------------------------+
bool CSampleExpert::ShortModified(void)
  {
   bool   res=false;
//--- Prüfung auf Trailing-Stop
   if(InpTrailingStop>0)
     {
      if((m_position.PriceOpen()-m_symbol.Ask())>(m_adjusted_point*InpTrailingStop))
        {
         double sl=NormalizeDouble(m_symbol.Ask()+m_traling_stop,m_symbol.Digits());
         double tp=m_position.TakeProfit();
         if(m_position.StopLoss()>sl || m_position.StopLoss()==0.0)
           {
            //--- Position ändern
            if(m_trade.PositionModify(Symbol(),sl,tp))
               printf("Short position by %s to be modified",Symbol());
            else
              {
               printf("Error modifying position by %s : '%s'",Symbol(),m_trade.ResultComment());
               printf("Modify parameters : SL=%f,TP=%f",sl,tp);
              }
            //--- geändert und muss vom Experten verlassen werden
            res=true;
           }
        }
     }
//--- Ergebnis
   return(res);
  }
//+------------------------------------------------------------------+
//| Prüfung auf Eröffnung einer Long-Position|
//+------------------------------------------------------------------+
bool CSampleExpert::LongOpened(void)
  {
   bool res=false;
//--- Prüfung auf Möglichkeit einer Long-Position (BUY)
   
      if(m_macd_current>0 && m_macd_previous<0)
         if(MathAbs(m_macd_current)>(m_macd_open_level))
           {
            double price=m_symbol.Ask();
            double tp   =m_symbol.Bid()+m_take_profit;
            //--- Scheck für kostenloses Geld
            if(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_BUY,InpLots,price)<0.0)
               printf("We have no money. Free Margin = %f",m_account.FreeMargin());
            else
              {
               //--- offene Position
               if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_BUY,InpLots,price,0.0,tp))
                  printf("Position by %s to be opened",Symbol());
               else
                 {
                  printf("Error opening BUY position by %s : '%s'",Symbol(),m_trade.ResultComment());
                  printf("Open parameters : price=%f,TP=%f",price,tp);
                 }
              }
            //--- in jedem Fall müssen wir von expert aussteigen
            res=true;
           }
//--- Ergebnis
   return(res);
  }
//+------------------------------------------------------------------+
//| Prüfung auf Eröffnung einer Short-Position|
//+------------------------------------------------------------------+
bool CSampleExpert::ShortOpened(void)
  {
   bool res=false;
//--- Prüfung auf mögliche Short-Position (SELL)
  
      if(m_macd_current<0 && m_macd_previous>0)
         if(m_macd_current<(m_macd_open_level) )
           {
            double price=m_symbol.Bid();
            double tp   =m_symbol.Ask()-m_take_profit;
            //--- Scheck für kostenloses Geld
            if(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_SELL,InpLots,price)<0.0)
               printf("We have no money. Free Margin = %f",m_account.FreeMargin());
            else
              {
               //--- offene Position
               if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_SELL,InpLots,price,0.0,tp))
                  printf("Position by %s to be opened",Symbol());
               else
                 {
                  printf("Error opening SELL position by %s : '%s'",Symbol(),m_trade.ResultComment());
                  printf("Open parameters : price=%f,TP=%f",price,tp);
                 }
              }
            //--- in jedem Fall müssen wir von expert aussteigen
            res=true;
           }
//--- Ergebnis
   return(res);
  }
//+------------------------------------------------------------------+
//| Die Hauptfunktion gibt true zurück, wenn eine Position bearbeitet wurde.
//+------------------------------------------------------------------+
bool CSampleExpert::Processing(void)
  {
//--- Aktualisierungsraten
   if(!m_symbol.RefreshRates())
      return(false);
//--- Indikatoren aktualisieren
   if(BarsCalculated(m_handle_macd)<2 )
      return(false);
   if(CopyBuffer(m_handle_macd,0,0,2,m_buff_MACD_main)  !=2 )
      
      
      return(false);
// m_indicators.Refresh();
//--- um die Kodierung zu vereinfachen und den Zugriff zu beschleunigen
//--- Daten werden in internen Variablen gespeichert
   m_macd_current   =m_buff_MACD_main[0];
   m_macd_previous  =m_buff_MACD_main[1];
   
  
//--- es ist wichtig, den Markt richtig zu erschließen, 
//--- aber es ist wichtiger, sie korrekt zu beenden.... 
//--- zuerst prüfen, ob die Position existiert - versuchen, sie auszuwählen
   if(m_position.Select(Symbol()))
     {
      if(m_position.PositionType()==POSITION_TYPE_BUY)
        {
         //--- versuchen, eine Long-Position zu schließen oder zu ändern
         if(LongClosed())
            return(true);
         if(LongModified())
            return(true);
        }
      else
        {
         //--- versuchen, die Short-Position zu schließen oder zu ändern
         if(ShortClosed())
            return(true);
         if(ShortModified())
            return(true);
        }
     }
//--- keine offene Position identifiziert
   else
     {
      //--- Prüfung auf Möglichkeit einer Long-Position (BUY)
      if(LongOpened())
         return(true);
      //--- Prüfung auf mögliche Short-Position (SELL)
      if(ShortOpened())
         return(true);
     }
//--- Beenden ohne Positionsverarbeitung
   return(false);
  }
//+------------------------------------------------------------------+
//| Experteninitialisierungsfunktion|
//+------------------------------------------------------------------+
int OnInit(void)
  {
//--- alle erforderlichen Objekte erstellen
   if(!ExtExpert.Init())
      return(INIT_FAILED);
//--- secceed
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Experte für neue Tick-Handling-Funktion|
//+------------------------------------------------------------------+
void OnTick(void)
  {
   static datetime limit_time=0; // Bearbeitungszeit des letzten Geschäfts + Timeout
//--- bei Zeitüberschreitung nicht verarbeiten
   if(TimeCurrent()>=limit_time)
     {
      //--- Prüfung auf Daten
      
        {
         //--- Änderung der Grenzzeit durch Timeout in Sekunden, wenn verarbeitet
         if(ExtExpert.Processing())
            limit_time=TimeCurrent()+ExtTimeOut;
        }
     }
  }

Ich habe alle Daten über"gleitender Durchschnitt" und "MACD-Signallinie" entfernt, alles was ich finden konnte.

bool CSampleExpert::LongOpened(void)
  {
   bool res=false;
//--- Prüfung auf Möglichkeit einer Long-Position (BUY)
   
      if(m_macd_current>0 && m_macd_previous<0)
         if(MathAbs(m_macd_current)>(m_macd_open_level))

An dieser Stelle wurde statt eines Wertes von "0" die Mittellinie angegeben. Ich habe sie überall durch "0" ersetzt, sowohl beim Verkauf als auch beim Schließen von Spuren.

Автоматический трейдинг и тестирование торговых стратегий
Автоматический трейдинг и тестирование торговых стратегий
  • www.mql5.com
Выберите подходящую торговую стратегию и оформите подписку на нее в пару кликов. Все Сигналы сопровождаются подробной статистикой и графиками. Станьте Поставщиком торговых сигналов и продавайте подписку тысячам трейдеров по всему миру. Наш сервис позволит вам хорошо зарабатывать на прибыльной стратегии даже при небольшом стартовом капитале...
Krivets:


Entfernt alle Daten über"gleitender Durchschnitt" und "MACD-Signallinie", alle, die ich finden konnte.

An dieser Stelle wurde anstelle des Wertes "0" die Durchschnittslinie angegeben. Ich habe sie überall durch den Wert "0" ersetzt, sowohl beim Verkauf als auch beim Schließen der Spuren.


zu dem langen Beispiel:

bool CSampleExpert::LongOpened(void)
  {
   bool res=false;
//--- Prüfung auf Möglichkeit einer Long-Position (BUY)
   
      if(m_macd_current>0 && m_macd_previous<0)
         if(MathAbs(m_macd_current)>(m_macd_open_level))
           {

-- Welche Rolle spielt die hervorgehobene Bedingung?

Hier ist, was ich nach der Korrektur der oben hervorgehobenen (kleine Kommentare zu den Besonderheiten der Öffnungen) haben:


Andrey F. Zelinsky:

am Beispiel von long:

-- Welche Rolle spielt die hervorgehobene Bedingung?


MathAbs(m_macd_current)>m_macd_open_level - aktueller Wert der Hauptlinie des MACD-Indikators modulo

Krivets:

MathAbs(m_macd_current)>m_macd_open_level - aktueller Wert der Hauptlinie des MACD-Indikators modulo


ja, nur diese Bedingung sollte entweder entfernt oder richtig gesetzt werden - oben ist ein Bild der EA-Leistung mit dieser Bedingung entfernt

Andrey F. Zelinsky:

Ja, aber diese Bedingung sollte entweder entfernt oder richtig eingestellt werden - oben ist ein Bild der EA-Leistung mit dieser Bedingung entfernt.


Ich habe die Bedingung nicht geändert, aber ich habe andere Werte geändert.

input double InpLots          =0.1; // Lose.
input int    InpTakeProfit    =0;  // Gewinnmitnahme (in Pips)
input int    InpTrailingStop  =0;  // Trailing Stop Level (in Pips)
input int    InpMACDOpenLevel =0;   // MACD offenes Niveau (in Pips)
input int    InpMACDCloseLevel=0;   // MACD-Schlussstand (in Pips)
input int    InpMATrendPeriod =26;  // MA-Trendzeitraum

Ich habe OpenLevel und Closelevel auf 0 geändert, wenn ich richtig verstanden habe, ist dies eine der Bedingungen für die Eröffnung einer Position.

Und ich habe Takeprofit und Stoploss deaktiviert.

DiePositionseröffnung erfolgt durch Überschreiten der "0", aber aus irgendeinem Grund wird das Geschäft nach 10 Pips geschlossen. Und es ist wünschenswert, dass das Geschäft nach der zweiten Bar geöffnet wurde, weil die erste Bar nicht gebildet wird, und es gibt falsche Eintrag.

Ich habe auch festgelegt, dass das Geschäft nicht früher als in 60 Sekunden gemacht wurde, ist es 10, und er alle 10 Sekunden, während der Minute macht einen Kauf oder Verkauf, dh für eine Minute 6 Angebote. Sie setzen 1 Lot, für eine Minute gibt es einen Kauf von 6 Lots oder Verkauf, je nachdem, wo die Linie "0" gekreuzt wird.

int ExtTimeOut=60; // Zeitspanne in Sekunden zwischen den Handelsoperationen

Ich teilweise herausgefunden, ich TakeProfit auf 10000 gesetzt und es begann zu rollen über normal, aber es verpasst einige Trades. Es ist notwendig, eine Funktion hinzuzufügen, dass der Rollover auf der zweiten Bar auftritt, falsche Trades erhalten werden, und mehr wahrscheinlich wegen dieser fehlenden Trades.

Wenn TakeProfit auf den erforderlichen Betrag eingestellt ist, z.B. auf "RTS" 100 Punkte, schließt es ein Geschäft auf TP und eröffnet ein neues, wenn der Indikator "0" überschreitet. Ich testete es auf Minuten, da es eine Menge von Signalen.
123
Neuer Kommentar