Indicadores: MACD Crossing the zero level (color candles)

Krivets 2017.11.11 20:52 #21

Andrey F. Zelinsky:

postea el código con tus ediciones -- explica que ediciones hiciste -- veamos.

Si usted está interesado en hacerlo usted mismo, hay una posibilidad de averiguarlo.

#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; // Lotes.
input int    InpTakeProfit    =50;  // Take Profit (en pips)
input int    InpTrailingStop  =30;  // Nivel de Trailing Stop (en pips)
input int    InpMACDOpenLevel =3;   // Nivel de apertura MACD (en pips)
input int    InpMACDCloseLevel=2;   // Nivel de cierre MACD (en pips)
input int    InpMATrendPeriod =26;  // Periodo de tendencia MA
//---
int ExtTimeOut=10; // tiempo en segundos entre operaciones
//+------------------------------------------------------------------+
//| MACD Clase experta de ejemplo|
//+------------------------------------------------------------------+
class CSampleExpert
  {
protected:
   double            m_adjusted_point;             // valor del punto ajustado a 3 o 5 puntos
   CTrade            m_trade;                      // objeto comercial
   CSymbolInfo       m_symbol;                     // objeto de información de símbolos
   CPositionInfo     m_position;                   // objeto de posición comercial
   CAccountInfo      m_account;                    // información de la cuenta
   //--- indicadores
   int               m_handle_macd;                // Asa del indicador MACD
   
   //--- tampones indicadores
   double            m_buff_MACD_main[];           // Buffer principal del indicador MACD
   
  
   //--- datos indicadores para procesar
   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);
  };
//--- experto global
CSampleExpert ExtExpert;
//+------------------------------------------------------------------+
//| Constructor|
//+------------------------------------------------------------------+
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);
   
  
  }
//+------------------------------------------------------------------+
//| Destructor|
//+------------------------------------------------------------------+
CSampleExpert::~CSampleExpert(void)
  {
  }
//+------------------------------------------------------------------+
//| Inicialización y comprobación de los parámetros de entrada |
//+------------------------------------------------------------------+
bool CSampleExpert::Init(void)
  {
//--- inicializar información común
   m_symbol.Name(Symbol());              // símbolo
   m_trade.SetExpertMagicNumber(12345);  // magia
//--- sintonización para 3 o 5 dígitos
   int digits_adjust=1;
   if(m_symbol.Digits()==3 || m_symbol.Digits()==5)
      digits_adjust=10;
   m_adjusted_point=m_symbol.Point()*digits_adjust;
//--- fijar la desviación por defecto para operar en puntos ajustados
   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;
//--- fijar la desviación por defecto para operar en puntos ajustados
   m_trade.SetDeviationInPoints(3*digits_adjust);
//---
   if(!InitCheckParameters(digits_adjust))
      return(false);
   if(!InitIndicators())
      return(false);
//--- tener éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| Comprobación de los parámetros de entrada|
//+------------------------------------------------------------------+
bool CSampleExpert::InitCheckParameters(const int digits_adjust)
  {
//--- comprobaciones de datos iniciales
   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);
     }
//--- comprobar la cantidad correcta de lotes
   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);
     }
//--- advertencia
   if(InpTakeProfit<=InpTrailingStop)
      printf("Warning: Trailing Stop must be less than Take Profit");
//--- tener éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| Inicialización de los indicadores|
//+------------------------------------------------------------------+
bool CSampleExpert::InitIndicators(void)
  {
//--- crear indicador MACD
   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);
        }
//--- crear indicador EMA y añadirlo a la colección
  
      
//--- tener éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| Comprueba el cierre de la posición larga|
//+------------------------------------------------------------------+
bool CSampleExpert::LongClosed(void)
  {
   bool res=false;
//--- ¿debería cerrarse?
   
      if(m_macd_current<0 && m_macd_previous>0)
         if(m_macd_current<m_macd_close_level)
           {
            //--- cerrar posición
            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());
            //--- procesado y no puede ser modificado
            res=true;
           }
//--- resultado
   return(res);
  }
//+------------------------------------------------------------------+
//| Comprueba el cierre de la posición corta|
//+------------------------------------------------------------------+
bool CSampleExpert::ShortClosed(void)
  {
   bool res=false;
//--- ¿debería cerrarse?
   
      if(m_macd_current>0 && m_macd_previous<0)
         if(MathAbs(m_macd_current)>m_macd_close_level)
           {
            //--- cerrar posición
            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());
            //--- procesado y no puede ser modificado
            res=true;
           }
//--- resultado
   return(res);
  }
//+------------------------------------------------------------------+
//| Comprobación de modificación de posición larga|
//+------------------------------------------------------------------+
bool CSampleExpert::LongModified(void)
  {
   bool res=false;
//--- comprobar 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)
           {
            //--- modificar posición
            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);
              }
            //--- modificado y debe salir de experto
            res=true;
           }
        }
     }
//--- resultado
   return(res);
  }
//+------------------------------------------------------------------+
//| Comprueba si la posición corta modifica ||
//+------------------------------------------------------------------+
bool CSampleExpert::ShortModified(void)
  {
   bool   res=false;
//--- comprobar 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)
           {
            //--- modificar posición
            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);
              }
            //--- modificado y debe salir de experto
            res=true;
           }
        }
     }
//--- resultado
   return(res);
  }
//+------------------------------------------------------------------+
//| Comprueba la apertura de una posición larga|
//+------------------------------------------------------------------+
bool CSampleExpert::LongOpened(void)
  {
   bool res=false;
//--- comprobar la posibilidad de posición larga (COMPRA)
   
      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;
            //--- cheque por dinero gratis
            if(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_BUY,InpLots,price)<0.0)
               printf("We have no money. Free Margin = %f",m_account.FreeMargin());
            else
              {
               //--- posición abierta
               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);
                 }
              }
            //--- en cualquier caso debemos salir de experto
            res=true;
           }
//--- resultado
   return(res);
  }
//+------------------------------------------------------------------+
//| Comprueba la apertura de una posición corta|
//+------------------------------------------------------------------+
bool CSampleExpert::ShortOpened(void)
  {
   bool res=false;
//--- comprobar la posibilidad de posición corta (VENTA)
  
      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;
            //--- cheque por dinero gratis
            if(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_SELL,InpLots,price)<0.0)
               printf("We have no money. Free Margin = %f",m_account.FreeMargin());
            else
              {
               //--- posición abierta
               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);
                 }
              }
            //--- en cualquier caso debemos salir de experto
            res=true;
           }
//--- resultado
   return(res);
  }
//+------------------------------------------------------------------+
//| función principal devuelve true si alguna posición procesada |
//+------------------------------------------------------------------+
bool CSampleExpert::Processing(void)
  {
//--- frecuencias de actualización
   if(!m_symbol.RefreshRates())
      return(false);
//--- actualizar indicadores
   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();
//--- para simplificar la codificación y acelerar el acceso
//--- los datos se introducen en variables internas
   m_macd_current   =m_buff_MACD_main[0];
   m_macd_previous  =m_buff_MACD_main[1];
   
  
//--- es importante entrar en el mercado correctamente, 
//--- pero es más importante que salga correctamente.... 
//--- primero comprueba si la posición existe - intenta seleccionarla
   if(m_position.Select(Symbol()))
     {
      if(m_position.PositionType()==POSITION_TYPE_BUY)
        {
         //--- intentar cerrar o modificar la posición larga
         if(LongClosed())
            return(true);
         if(LongModified())
            return(true);
        }
      else
        {
         //--- intentar cerrar o modificar la posición corta
         if(ShortClosed())
            return(true);
         if(ShortModified())
            return(true);
        }
     }
//--- ninguna posición abierta identificada
   else
     {
      //--- comprobar la posibilidad de posición larga (COMPRA)
      if(LongOpened())
         return(true);
      //--- comprobar la posibilidad de posición corta (VENTA)
      if(ShortOpened())
         return(true);
     }
//--- salir sin procesar la posición
   return(false);
  }
//+------------------------------------------------------------------+
//| Función de inicialización experta|
//+------------------------------------------------------------------+
int OnInit(void)
  {
//--- crear todos los objetos necesarios
   if(!ExtExpert.Init())
      return(INIT_FAILED);
//--- secceed
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Experto nueva función de manejo de ticks|
//+------------------------------------------------------------------+
void OnTick(void)
  {
   static datetime limit_time=0; // tiempo de procesamiento de la última operación + tiempo de espera
//--- no procesar si timeout
   if(TimeCurrent()>=limit_time)
     {
      //--- comprobar datos
      
        {
         //--- cambiar el tiempo límite por el tiempo de espera en segundos si se procesa
         if(ExtExpert.Processing())
            limit_time=TimeCurrent()+ExtTimeOut;
        }
     }
  }

Quité todos los datos sobre"media móvil" y "línea de señal MACD", todo lo que pude encontrar.

bool CSampleExpert::LongOpened(void)
  {
   bool res=false;
//--- comprobar la posibilidad de posición larga (COMPRA)
   
      if(m_macd_current>0 && m_macd_previous<0)
         if(MathAbs(m_macd_current)>(m_macd_open_level))

En este lugar, en lugar de un valor de "0", se dio la línea media. Lo sustituí por "0" en todas partes, al vender, y al cerrar trazas.

Автоматический трейдинг и тестирование торговых стратегий

www.mql5.com

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

Andrey F. Zelinsky 2017.11.11 21:11 #22

Krivets:

Eliminado todos los datos sobre"media móvil" y "MACD línea de señal", todo lo que pude encontrar.

En este lugar, en lugar del valor "0", se especificó la línea media. Reemplazado con un valor de "0" en todas partes, al vender, y al cerrar las trazas.

En el ejemplo largo:

bool CSampleExpert::LongOpened(void)
  {
   bool res=false;
//--- comprobar la posibilidad de posición larga (COMPRA)
   
      if(m_macd_current>0 && m_macd_previous<0)
         if(MathAbs(m_macd_current)>(m_macd_open_level))
           {

-- ¿qué papel juega la condición resaltada?

Andrey F. Zelinsky 2017.11.11 21:15 #23

Esto es lo que tengo después de corregir lo resaltado anteriormente (pequeños comentarios sobre los detalles de las aperturas):

Krivets 2017.11.11 21:33 #24

Andrey F. Zelinsky:

utilizando long como ejemplo:

-- ¿qué papel juega la condición resaltada?

MathAbs(m_macd_current)>m_macd_open_level - valor actual de la línea principal del indicador MACD modulo

Andrey F. Zelinsky 2017.11.11 21:36 #25

Krivets:

MathAbs(m_macd_current)>m_macd_open_level - valor actual de la línea principal del indicador MACD modulo

sí, sólo esta condición debe ser eliminada o configurada correctamente -- arriba hay una imagen del rendimiento del EA con esta condición eliminada

Krivets 2017.11.12 08:47 #26

Andrey F. Zelinsky:

Sí, sólo esta condición debe ser eliminada o configurada correctamente -- arriba hay una imagen del rendimiento de EA con esta condición eliminada.

No cambié la condición, pero cambié otros valores.

input double InpLots          =0.1; // Lotes.
input int    InpTakeProfit    =0;  // Take Profit (en pips)
input int    InpTrailingStop  =0;  // Nivel de Trailing Stop (en pips)
input int    InpMACDOpenLevel =0;   // Nivel de apertura MACD (en pips)
input int    InpMACDCloseLevel=0;   // Nivel de cierre MACD (en pips)
input int    InpMATrendPeriod =26;  // Periodo de tendencia MA

He cambiado OpenLevel y Closelevel a 0, si he entendido bien, esta es una de las condiciones para la apertura de una posición.

Y desactivé Takeprofit y Stoploss.

Krivets 2017.11.12 08:53 #27

La apertura de la posición se produce a través del cruce "0", pero por alguna razón la operación se cierra después de 10 pips. Y es deseable que el acuerdo se abrió después de la segunda barra, porque la primera barra no se forma, y hay falsa entrada.

También me puse que el acuerdo se hizo no antes de 60 segundos, es de 10, y que cada 10 segundos, durante el minuto hace una compra o venta, es decir, por un minuto 6 ofertas. Se establece 1 lote, por un minuto hay una compra de 6 lotes o venta, dependiendo de donde se cruza la línea "0".

int ExtTimeOut=60; // tiempo en segundos entre operaciones

[¡Archivo!] Cualquier pregunta de Cómo armo mi asesor Martingala y antimartingala.

Krivets 2017.11.12 09:05 #28

En parte lo he solucionado, he puesto TakeProfit a 10000 y ha empezado a rollover normalmente, pero se pierden algunas operaciones. Es necesario añadir una función que el rollover se produce en la segunda barra, se obtienen operaciones falsas, y lo más probable debido a esta falta de operaciones.

Si TakeProfit se establece en la cantidad requerida, por ejemplo en "RTS" 100 puntos, cierra una operación en TP, y abre una nueva cuando el indicador cruza "0". Lo he probado en minutos, ya que hay muchas señales.

¿Hay alguien capaz de Índice de calidad de Teoría del mercado

Indicadores: MACD Crossing the zero level (color candles) - página 3