Asesores Expertos: Polish Layer

 

Polish Layer:

Este Asesor Experto se basa en los siguientes indicadores: RSI, WPR, Stochastic, Moving Average, deMarker.

Polish Layer tester

Autor: Vladimir Karputov

 

Hola Vladimir,

Siempre encuentro tus codigos. Este es otro buen EA. Te pregunto: necesito un trailing stop. Por favor, construyelo en codigo.


Gracias

 

Hola Vladimir,

He cambiado el código de Polish Layer escrito por ti para mis propios fines. Quiero combinar los resultados de varios indicadores y sacar esto de los resultados. ¿Cómo puedo hacerlo?

 
csezo2 :

Hola Vladimir,

He cambiado el código de Polish Layer escrito por ti para mis propios fines. Quiero combinar los resultados de varios indicadores y sacar esto de los resultados. ¿Cómo puedo hacerlo?

Describe detalladamente lo que hiciste. Muestre el código. Dime qué más hay que hacer.

 
¿Cómo puedo insertar el código correctamente? ¿O simplemente copiar y pegar? Puedo ver la función Alt+S, pero no sé cómo funciona.
 
csezo2:
¿Cómo puedo insertar el código correctamente? ¿O simplemente copiar y pegar? Puedo ver la función Alt+S, pero no sé cómo funciona.
 
 
#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>  
#include <Trade\AccountInfo.mqh>
CPositionInfo  m_position;                   // objeto de posición comercial
CTrade         m_trade;                      // objeto comercial
CSymbolInfo    m_symbol;                     // objeto de información de símbolos
CAccountInfo   m_account;                    // información de la cuenta
//--- parámetros de entrada
input ENUM_TIMEFRAMES      per_kis    = PERIOD_M15; 
input ENUM_TIMEFRAMES      per_nagy   = PERIOD_H1; 
input int                  kis_trend_gyors_per= 99;
input int                  kis_trend_lassú_per= 99;
input int                  nagy_trend_gyors_per= 99;
input int                  nagy_trend_lassú_per= 99;
input ENUM_MA_METHOD       MA_method_kis   = MODE_SMA;                    
input ENUM_MA_METHOD       MA_method_nagy    = MODE_SMA;                    
input int                  ST_indikátor_periódus     = 14;    
input int                  RSI_indikátor_periódus     = 14;
input int                  STh_alsó    = 20;  
input int                  ST_lassuló    = 3; 
input ushort               TakeProfit=11111;
input ushort               StopLoss=90;
input ushort               TrailingStop=20;
input double               Lots=0.1;

ulong          m_magic=1;              // número mágico
ulong          m_slippage=30;                // deslizamiento

int            handle_iMA_kis_trend_gyors;               // variable para almacenar el asa del indicador iMA 
int            handle_iMA_kis_trend_lassú;    
int            handle_iMA_nagy_trend_gyors;
int            handle_iMA_nagy_trend_lassú;
int            handle_iRSI;
int            handle_iStochastic_M15;       // variable para almacenar el handle del indicador iStochastic 

ENUM_ACCOUNT_MARGIN_MODE m_margin_mode;
double         m_adjusted_point;             // valor del punto ajustado a 3 ó 5 puntos
//+------------------------------------------------------------------+
//| Función de inicialización experta|
//+------------------------------------------------------------------+
int OnInit()
  {
   SetMarginMode();
   if(!IsHedging())
     {
      Print("Hedging only!");
      return(INIT_FAILED);
     }
     if(TrailingStop>=TakeProfit)
     {
      Print("Error! TrailingStop>=TakeProfit!");
      return(INIT_PARAMETERS_INCORRECT);
     }
//---
   m_symbol.Name(Symbol());                  // establece el nombre del símbolo
   if(!RefreshRates())
     {
      Print("Error RefreshRates. Bid=",DoubleToString(m_symbol.Bid(),Digits()),
            ", Ask=",DoubleToString(m_symbol.Ask(),Digits()));
      return(INIT_FAILED);
     }
   m_symbol.Refresh();
//---
   m_trade.SetExpertMagicNumber(m_magic);
//---
   m_trade.SetDeviationInPoints(m_slippage);
//--- sintonización para 3 o 5 dígitos
   int digits_adjust=1;
    
   m_adjusted_point=m_symbol.Point()*digits_adjust;

//--- crear asa del indicador iMA
   handle_iMA_kis_trend_gyors=iMA(m_symbol.Name(),per_kis,kis_trend_gyors_per,0, MA_method_kis,PRICE_CLOSE);
//--- crear asa del indicador iMA
   handle_iMA_kis_trend_lassú=iMA(m_symbol.Name(),per_kis,kis_trend_lassú_per ,0,MA_method_kis , PRICE_CLOSE );
//--- crear asa del indicador iMA
   handle_iMA_nagy_trend_gyors=iMA(m_symbol.Name(),per_nagy,nagy_trend_gyors_per ,0, MA_method_nagy , PRICE_CLOSE ); 
//--- crear asa del indicador iMA
   handle_iMA_nagy_trend_lassú=iMA(m_symbol.Name(),per_nagy,nagy_trend_lassú_per ,0, MA_method_nagy , PRICE_CLOSE );
//--- crear handle del indicador iRSI
   handle_iRSI=iRSI(m_symbol.Name(),per_kis,RSI_indikátor_periódus, PRICE_CLOSE);
//--- crear handle del indicador iStochastic
   handle_iStochastic_M15=iStochastic(m_symbol.Name(),per_kis,ST_indikátor_periódus,3,ST_lassuló,MODE_SMA,STO_CLOSECLOSE);
 
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Función de desinicialización experta|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
 
//---

  }
//+------------------------------------------------------------------+
//| Función tick experto|
//+------------------------------------------------------------------+
void OnTick()
  {
 if(kis_trend_gyors_per>=kis_trend_lassú_per || nagy_trend_gyors_per>=nagy_trend_lassú_per)
  return;
 
 static datetime PrevBars=0;
   datetime time_0=iTime(0);
   if(time_0==PrevBars)
      return;
   PrevBars=time_0;
//--- вычисляем начальные параметры индикаторов для поиска условий входа
   double MA_kis_trend_gyors   = iMAGet(handle_iMA_kis_trend_gyors,0);
   double MA_kis_trend_lassú    = iMAGet(handle_iMA_kis_trend_lassú,0);
   double MA_nagy_trend_gyors    = iMAGet(handle_iMA_nagy_trend_gyors,0);
   double MA_nagy_trend_lassú    = iMAGet(handle_iMA_nagy_trend_lassú,0);
   
    
   double Stoh_fast = iStochasticGet(MAIN_LINE,0);
   double Stoh_fast_prew=iStochasticGet(MAIN_LINE,1);

   double RSI0    = iRSIGet(0);
   double RSI1    = iRSIGet(1);
       
   double StRSI=(Stoh_fast*RSI0)/100;//------------------------------------------------------------------------ I would like to draw out these outcomes.
   double StRSI_prew=(Stoh_fast_prew*RSI1)/100;//--------------------------------------------------------------
    
   double price_M15=iClose(1,NULL,per_kis);
   bool Long=false;
       
   if(MA_kis_trend_gyors>MA_kis_trend_lassú   &&   MA_nagy_trend_gyors>MA_nagy_trend_lassú)
     Long=true;
       
   if(!Long  )
      return; 

//--- проверка условий для совершения сделки
   if(Long==true  )
     {
       if(  StRSI>STh_alsó && StRSI_prew<=STh_alsó  )
         { 
         
         if(!RefreshRates())
            return;

         //--- comprobar el volumen antes de OrderSend para evitar el error "not enough money" (CTrade)
         double chek_volime_lot=m_trade.CheckVolume(m_symbol.Name(),Lots,m_symbol.Ask(),ORDER_TYPE_BUY);

         if(chek_volime_lot!=0.0)
            if(chek_volime_lot>=Lots)
              {
               Print("COMPRA разница (MA_M15-precio_M15) = ",DoubleToString(MA_kis_trend_gyors,m_symbol.Digits()),
                     " MA_M15 = ",DoubleToString(MA_kis_trend_gyors,m_symbol.Digits()),
                     " price_M15 = ",DoubleToString(MA_kis_trend_gyors,m_symbol.Digits()));
               double sl=m_symbol.NormalizePrice(m_symbol.Bid()-StopLoss*m_adjusted_point);
               double tp=m_symbol.NormalizePrice(m_symbol.Bid()+TakeProfit*m_adjusted_point);

               if(m_trade.Buy(Lots,NULL,m_symbol.Ask(),sl,tp))
                 {
                  if(m_trade.ResultDeal()==0)
                     Print("Buy -> false. Result Retcode: ",m_trade.ResultRetcode(),
                           ", description of result: ",m_trade.ResultRetcodeDescription());
                  else
                     Print("Buy -> true. Result Retcode: ",m_trade.ResultRetcode(),
                           ", description of result: ",m_trade.ResultRetcodeDescription());
                 }
               else
                  Print("Buy -> false. Result Retcode: ",m_trade.ResultRetcode(),
                        ", description of result: ",m_trade.ResultRetcodeDescription());
              }
            }     
        }
//--- трейлинг
   if(TrailingStop==0)
      return;

   for(int i=PositionsTotal()-1;i>=0;i--)
      if(m_position.SelectByIndex(i)) // selecciona la posición por el índice para acceder posteriormente a sus propiedades
         if(m_position.Symbol()==Symbol() && m_position.Magic()==m_magic)
           {
             if(m_position.PositionType()==POSITION_TYPE_BUY)
              {
             if(!RefreshRates())
                  continue;

               if(m_symbol.Bid()-m_position.PriceOpen()>TrailingStop*m_adjusted_point)
                 {
                  if(m_position.StopLoss()<m_symbol.Bid()-TrailingStop*m_adjusted_point)
                    {
                     if(!m_trade.PositionModify(m_position.Ticket(),
                        m_symbol.NormalizePrice(m_symbol.Bid()-TrailingStop*m_adjusted_point),
                        m_position.TakeProfit()))
                        Print("PositionModify -> false. Result Retcode: ",m_trade.ResultRetcode(),
                              ", description of result: ",m_trade.ResultRetcodeDescription());
                    }
                 }
              }
            }
//---
   return;
  }
//+------------------------------------------------------------------+
//||
//+------------------------------------------------------------------+
void SetMarginMode(void)
  {
   m_margin_mode=(ENUM_ACCOUNT_MARGIN_MODE)AccountInfoInteger(ACCOUNT_MARGIN_MODE);
  }
//+------------------------------------------------------------------+
//||
//+------------------------------------------------------------------+
bool IsHedging(void)
  {
   return(m_margin_mode==ACCOUNT_MARGIN_MODE_RETAIL_HEDGING);
  }
//+------------------------------------------------------------------+
//| Refresca los datos de las cotizaciones de los símbolos|
//+------------------------------------------------------------------+
bool RefreshRates()
  {
//--- frecuencias de actualización
   if(!m_symbol.RefreshRates())
      return(false);
//--- protección contra el valor de retorno de "cero"
   if(m_symbol.Ask()==0 || m_symbol.Bid()==0)
      return(false);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//| Obtener el valor de los buffers para el iMA|
//+------------------------------------------------------------------+
double iMAGet(int handle_iMA,const int index)
  {
   double MA[1];
//--- restablecer código de error 
   ResetLastError();
//--- rellenar una parte del array iMABuffer con valores del buffer indicador que tiene índice 0 
   if(CopyBuffer(handle_iMA,0,index,1,MA)<0)
     {
      //--- si la copia falla, indique el código de error 
      PrintFormat("Failed to copy data from the iMA indicator, error code %d",GetLastError());
      //--- salir con resultado cero - significa que el indicador se considera como no calculado 
      return(0.0);
     }
   return(MA[0]);
  }
//+------------------------------------------------------------------+
//| Obtener el valor de los buffers para el iStochastic |
//| los números de búfer son los siguientes:|
//| 0 - LÍNEA_PRINCIPAL, 1 - LÍNEA_SEÑAL|
//+------------------------------------------------------------------+
double iStochasticGet(const int buffer,const int index)
  {
   double Stochastic[1];
//--- restablecer código de error 
   ResetLastError();
//--- rellenar una parte del array iStochasticBuffer con valores del buffer indicador que tiene índice 0 
   if(CopyBuffer(handle_iStochastic_M15,buffer,index,1,Stochastic)<0)
     {
      //--- si la copia falla, indique el código de error 
      PrintFormat("Failed to copy data from the iStochastic indicator, error code %d",GetLastError());
      //--- salir con resultado cero - significa que el indicador se considera como no calculado 
      return(0.0);
     }
   return(Stochastic[0]);
  }
 
  
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Obtener el valor de los buffers para el iRSI|
//+------------------------------------------------------------------+
double iRSIGet(const int index)
  {
   double RSI[1];
//--- restablecer código de error 
   ResetLastError();
//--- rellenar una parte del array iRSI con valores del buffer del indicador que tiene índice 0 
   if(CopyBuffer(handle_iRSI,0,index,1,RSI)<0)
     {
      //--- si la copia falla, indique el código de error 
      PrintFormat("Failed to copy data from the iRSI indicator, error code %d",GetLastError());
      //--- salir con resultado cero - significa que el indicador se considera como no calculado 
      return(0.0);
     }
   return(RSI[0]);
  }
  
  //+------------------------------------------------------------------+ 
//| Obtener el cierre para el índice de barra especificado| 
//+------------------------------------------------------------------+ 
double iClose(const int index,string symbol=NULL,ENUM_TIMEFRAMES timeframe=PERIOD_CURRENT)
  {
   if(symbol==NULL)
      symbol=Symbol();
   if(timeframe==0)
      timeframe=per_kis;
   double Close[1];
   double close=0;
   int copied=CopyClose(symbol,timeframe,index,1,Close);
   if(copied>0) close=Close[0];
   return(close);
  }
//+------------------------------------------------------------------+ 
//| Obtener el tiempo para el índice de barra especificado| 
//+------------------------------------------------------------------+ 
datetime iTime(const int index,string symbol=NULL,ENUM_TIMEFRAMES timeframe=PERIOD_CURRENT)
  {
   if(symbol==NULL)
      symbol=Symbol();
   if(timeframe==0)
      timeframe=per_kis;
   datetime Time[1];
   datetime time=0;
   int copied=CopyTime(symbol,timeframe,index,1,Time);
   if(copied>0) time=Time[0];
   return(time);
  }
//+------------------------------------------------------------------+
 
Combinando Capa de Pulido y Tendencia de Obtención. He resaltado el tema con un fondo en blanco.
 
csezo2:
Combinando Capa de Pulido y Tendencia de Obtención. He resaltado el tema con un fondo en blanco.
//--- crear asa del indicador iMA
   handle_iMA_kis_trend_gyors=iMA(m_symbol.Name(),per_kis,kis_trend_gyors_per,0,MA_method_kis,PRICE_CLOSE);
//--- si no se crea el manejador 
   if(handle_iMA_kis_trend_gyors==INVALID_HANDLE)
     {
      //--- informa del fallo y muestra el código de error 
      PrintFormat("Failed to create handle \"handle_iMA_kis_trend_gyors\" of the iMA indicator for the symbol %s/%s, error code %d",
                  m_symbol.Name(),
                  EnumToString(per_kis),
                  GetLastError());
      //--- el indicador se detiene antes de tiempo 
      return(INIT_FAILED);
     }
//--- crear asa del indicador iMA
   handle_iMA_kis_trend_lassú=iMA(m_symbol.Name(),per_kis,kis_trend_lassú_per,0,MA_method_kis,PRICE_CLOSE);
//--- si no se crea el manejador 
   if(handle_iMA_kis_trend_lassú==INVALID_HANDLE)
     {
      //--- informa del fallo y muestra el código de error 
      PrintFormat("Fallo al crear handle \"handle_iMA_kis_trend_lassú\" del indicador iMA para el símbolo %s/%s, código de error %d",
                  m_symbol.Name(),
                  EnumToString(per_kis),
                  GetLastError());
      //--- el indicador se detiene antes de tiempo 
      return(INIT_FAILED);
     }
//--- crear asa del indicador iMA
   handle_iMA_nagy_trend_gyors=iMA(m_symbol.Name(),per_nagy,nagy_trend_gyors_per,0,MA_method_nagy,PRICE_CLOSE);
//--- si no se crea el manejador 
   if(handle_iMA_nagy_trend_gyors==INVALID_HANDLE)
     {
      //--- informa del fallo y muestra el código de error 
      PrintFormat("Failed to create handle \"handle_iMA_nagy_trend_gyors\" of the iMA indicator for the symbol %s/%s, error code %d",
                  m_symbol.Name(),
                  EnumToString(per_kis),
                  GetLastError());
      //--- el indicador se detiene antes de tiempo 
      return(INIT_FAILED);
     }
//--- crear asa del indicador iMA
   handle_iMA_nagy_trend_lassú=iMA(m_symbol.Name(),per_nagy,nagy_trend_lassú_per,0,MA_method_nagy,PRICE_CLOSE);
//--- si no se crea el manejador 
   if(handle_iMA_nagy_trend_lassú==INVALID_HANDLE)
     {
      //--- informa del fallo y muestra el código de error 
      PrintFormat("Fallo al crear handle \"handle_iMA_nagy_trend_lassú\" del indicador iMA para el símbolo %s/%s, código de error %d",
                  m_symbol.Name(),
                  EnumToString(per_kis),
                  GetLastError());
      //--- el indicador se detiene antes de tiempo 
      return(INIT_FAILED);
     }
//--- crear handle del indicador iRSI
   handle_iRSI=iRSI(m_symbol.Name(),per_kis,RSI_indikátor_periódus,PRICE_CLOSE);
//--- si no se crea el manejador 
   if(handle_iRSI==INVALID_HANDLE)
     {
      //--- informa del fallo y muestra el código de error 
      PrintFormat("Failed to create handle \"handle_iRSI\" of the iRSI indicator for the symbol %s/%s, error code %d",
                  m_symbol.Name(),
                  EnumToString(per_kis),
                  GetLastError());
      //--- el indicador se detiene antes de tiempo 
      return(INIT_FAILED);
     }
//--- crear handle del indicador iStochastic
   handle_iStochastic_M15=iStochastic(m_symbol.Name(),per_kis,ST_indikátor_periódus,3,ST_lassuló,MODE_SMA,STO_CLOSECLOSE);
//--- si no se crea el manejador 
   if(handle_iStochastic_M15==INVALID_HANDLE)
     {
      //--- informa del fallo y muestra el código de error 
      PrintFormat("Failed to create handle \"handle_iStochastic_M15\"  of the iStochastic indicator for the symbol %s/%s, error code %d",
                  m_symbol.Name(),
                  EnumToString(per_kis),
                  GetLastError());
      //--- el indicador se detiene antes de tiempo 
      return(INIT_FAILED);
     }

//--- Me gustaría extraer estos resultados.
   double StRSI=(Stoh_fast*RSI0)/100.0;
   double StRSI_prew=(Stoh_fast_prew*RSI1)/100.0;
//---
Archivos adjuntos:
1.mq5  33 kb
 
Me gustaría sacar el resultado del Estocástico multiplicado por el RSI.
 
csezo2 :
Me gustaría sacar el resultado del Estocástico multiplicado por el RSI.

No lo entiendo.

Trate de explicar con otras palabras o hacer un dibujo.