Preguntas de los principiantes MQL5 MT5 MetaTrader 5

Sprut 185 2021.06.30 22:13 #13221

Alexey Viktorov:

¿Debe Martin activarse sólo cuando la señal del indicador es contraria o independientemente?

Ejemplo: Se abrió una posición de compra según el indicador. El precio ha caído por la distancia establecida y el indicador ya muestra Venta. ¿Se abrirá una posición de compra?

Para abreviar, .....Martin trabaja sólo contra la tendencia, con órdenes a la baja, mientras que el indicador trabaja sólo con la tendencia.

Mañana intentaré dibujarlo en Photoshop y colgaré el archivo

SanAlex 2021.06.30 22:57 #13222

Sprut 185 :

En resumen - Al mismo tiempo ..... Martin trabaja solo contra la tendencia, con órdenes en rojo, y según el indicador, trabajamos solo con la tendencia.

Mañana intentaré dibujar en photoshop y publicar el archivo.

He hecho algo aquí, que yo mismo no entiendo con 100,000 rublos. hasta dos millones

 //+------------------------------------------------------------------+
//|                                                  6 Sprut 185.mq5 |
//|                                  Copyright 2021, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, MetaQuotes Ltd."
#property link        " https://www.mql5.com "
#property version    "1.00"
//---
#define MACD_MAGIC 1234502
//---
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\AccountInfo.mqh>
//---
double             m_adjusted_point;             // point value adjusted for 3 or 5 points
CTrade            m_trade;                       // trading object
CSymbolInfo       m_symbol;                     // symbol info object
CPositionInfo     m_position;                   // trade position object
CAccountInfo      m_account;                     // account info wrapper
input group   "---- : Parameters:  ----"
input int     InpTProfit       = 100000 ;   // : Take Profit --> (In currency the amount)
input double InpLotsRisk      = 0.1 ;     // : Maximum Risk in percentage
input group   "---- : Parameters:  ----"
input bool    InpClOp          = false ;     // : Close opposite
//---
int m_price_uno;
int m_handle_macd; // MACD indicator handle
int ExtTimeOut= 10 ; // time out in seconds between trade operations
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double OptimizedBuy( void )
  {
   double PROFIT_BUY= 0.00 ;
   int total= PositionsTotal ();
   for ( int i=total- 1 ; i>= 0 ; i--) // returns the number of open positions
     {
       string    position_GetSymbol= PositionGetSymbol (i); // GetSymbol позиции
       if (position_GetSymbol==m_symbol.Name())
        {
         if (m_position.PositionType()== POSITION_TYPE_BUY )
           {
            PROFIT_BUY=PROFIT_BUY+m_position.Select( Symbol ());
           }
        }
     }
   double Lots=InpLotsRisk;
   double ab=PROFIT_BUY;
   if (ab> 0 && ab<= 1 )
      Lots=InpLotsRisk* 2 ;
   if (ab> 1 && ab<= 2 )
      Lots=InpLotsRisk* 4 ;
   if (ab> 2 && ab<= 3 )
      Lots=InpLotsRisk* 8 ;
   if (ab> 3 )
      Lots=InpLotsRisk* 16 ;
   return (Lots);
  }
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double OptimizedSell( void )
  {
   double PROFIT_SELL= 0.00 ;
   int total= PositionsTotal ();
   for ( int i=total- 1 ; i>= 0 ; i--) // returns the number of open positions
     {
       string    position_GetSymbol= PositionGetSymbol (i); // GetSymbol позиции
       if (position_GetSymbol==m_symbol.Name())
        {
         if (m_position.PositionType()== POSITION_TYPE_SELL )
           {
            PROFIT_SELL=PROFIT_SELL+m_position.Select( Symbol ());
           }
        }
     }
   double Lots=InpLotsRisk;
   double ab=PROFIT_SELL;
   if (ab> 0 && ab<= 1 )
      Lots=InpLotsRisk* 2 ;
   if (ab> 1 && ab<= 2 )
      Lots=InpLotsRisk* 4 ;
   if (ab> 2 && ab<= 3 )
      Lots=InpLotsRisk* 8 ;
   if (ab> 3 )
      Lots=InpLotsRisk* 16 ;
   return (Lots);
  }
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit ()
  {
//--- initialize common information
   m_symbol.Name( Symbol ());                   // symbol
   m_trade.SetExpertMagicNumber(MACD_MAGIC); // magic
   m_trade.SetMarginMode();
   m_trade.SetTypeFillingBySymbol( Symbol ());
//--- tuning for 3 or 5 digits
   int digits_adjust= 1 ;
   if (m_symbol. Digits ()== 3 || m_symbol. Digits ()== 5 )
      digits_adjust= 10 ;
   m_adjusted_point=m_symbol. Point ()*digits_adjust;
//--- set default deviation for trading in adjusted points
   m_trade.SetDeviationInPoints( 3 *digits_adjust);
//--- create MACD indicator
   m_handle_macd= iCustom ( NULL , 0 , "StepMA_NRTR" );
   if (m_handle_macd== INVALID_HANDLE )
     {
       printf ( "Error creating MACD indicator" );
       return ( false );
     }
//---
   return ( INIT_SUCCEEDED );
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit ( const int reason)
  {
//---
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick ( void )
  {
//---
   if (ProfitBuy() || ProfitSell())
     {
       return ;
     }
   static datetime limit_time= 0 ; // last trade processing time + timeout
//--- don't process if timeout
   if ( TimeCurrent ()>=limit_time)
     {
       //--- check for data
       if ( Bars ( Symbol (), Period ())> 2 )
        {
         //--- change limit time by timeout in seconds if processed
         if (Processing())
            limit_time= TimeCurrent ()+ExtTimeOut;
        }
     }
  }
//+------------------------------------------------------------------+
//| main function returns true if any position processed             |
//+------------------------------------------------------------------+
bool Processing( void )
  {
//--- refresh rates
   if (!m_symbol.RefreshRates())
       return ( false );
   double m_buff_MACD_main[],m_buff_MACD_signal[];
   bool StNRUp,StNRDn;
   ArraySetAsSeries (m_buff_MACD_main, true );
   ArraySetAsSeries (m_buff_MACD_signal, true );
   int start_pos= 1 ,count= 3 ;
   if (!iGetArray(m_handle_macd, 0 ,start_pos,count,m_buff_MACD_main)||
      !iGetArray(m_handle_macd, 1 ,start_pos,count,m_buff_MACD_signal))
     {
       return ( false );
     }
//---
   StNRUp=m_buff_MACD_main[ 0 ]<m_buff_MACD_signal[ 0 ];
   StNRDn=m_buff_MACD_main[ 0 ]>m_buff_MACD_signal[ 0 ];
//--- BUY Signal
   if (StNRUp)
     {
       if (InpClOp)
         if (ShortClosed())
             Sleep ( 1000 );
       if (m_price_uno< 0 )
         LongOpened();
      m_price_uno=+ 1 ;
       return ( true );
     }
//--- SELL Signal
   if (StNRDn)
     {
       if (InpClOp)
         if (LongClosed())
             Sleep ( 1000 );
       if (m_price_uno> 0 )
         ShortOpened();
      m_price_uno=- 1 ;
       return ( true );
     }
//--- exit without position processing
   return ( false );
  }
//+------------------------------------------------------------------+
//| Check for long position closing                                  |
//+------------------------------------------------------------------+
bool LongClosed( void )
  {
   bool res= false ;
//--- should it be closed?
   ClosePositions( POSITION_TYPE_BUY );
//--- processed and cannot be modified
   res= true ;
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Check for short position closing                                 |
//+------------------------------------------------------------------+
bool ShortClosed( void )
  {
   bool res= false ;
//--- should it be closed?
   ClosePositions( POSITION_TYPE_SELL );
//--- processed and cannot be modified
   res= true ;
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Check for long position opening                                  |
//+------------------------------------------------------------------+
bool LongOpened( void )
  {
   bool res= false ;
//--- check for long position (BUY) possibility
   double price=m_symbol.Ask();
//--- check for free money
   if (m_account.FreeMarginCheck( Symbol (), ORDER_TYPE_BUY ,OptimizedBuy(),price)< 0.0 )
       printf ( "We have no money. Free Margin = %f" ,m_account.FreeMargin());
   else
     {
       //--- open position
       if (m_trade.PositionOpen( Symbol (), ORDER_TYPE_BUY ,OptimizedBuy(),price, 0.0 , 0.0 ))
         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" ,price);
        }
       PlaySound ( "ok.wav" );
     }
//--- in any case we must exit from expert
   res= true ;
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Check for short position opening                                 |
//+------------------------------------------------------------------+
bool ShortOpened( void )
  {
   bool res= false ;
//--- check for short position (SELL) possibility
   double price=m_symbol.Bid();
//--- check for free money
   if (m_account.FreeMarginCheck( Symbol (), ORDER_TYPE_SELL ,OptimizedSell(),price)< 0.0 )
       printf ( "We have no money. Free Margin = %f" ,m_account.FreeMargin());
   else
     {
       //--- open position
       if (m_trade.PositionOpen( Symbol (), ORDER_TYPE_SELL ,OptimizedSell(),price, 0.0 , 0.0 ))
         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" ,price);
        }
       PlaySound ( "ok.wav" );
     }
//--- in any case we must exit from expert
   res= true ;
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Refreshes the symbol quotes data                                 |
//+------------------------------------------------------------------+
bool RefreshRates()
  {
//--- refresh rates
   if (!m_symbol.RefreshRates())
     {
       return ( false );
     }
//--- protection against the return value of "zero"
   if (m_symbol.Ask()== 0 || m_symbol.Bid()== 0 )
     {
       return ( false );
     }
//---
   return ( true );
  }
//+------------------------------------------------------------------+
//| Check Freeze and Stops levels                                    |
//+------------------------------------------------------------------+
void FreezeStopsLevels( double &freeze, double &stops)
  {
//--- check Freeze and Stops levels
   double coeff=( double ) 1 ;
   if (!RefreshRates() || !m_symbol.Refresh())
       return ;
//--- FreezeLevel -> for pending order and modification
   double freeze_level=m_symbol.FreezeLevel()*m_symbol. Point ();
   if (freeze_level== 0.0 )
       if ( 1 > 0 )
         freeze_level=(m_symbol.Ask()-m_symbol.Bid())*coeff;
//--- StopsLevel -> for TakeProfit and StopLoss
   double stop_level=m_symbol.StopsLevel()*m_symbol. Point ();
   if (stop_level== 0.0 )
       if ( 1 > 0 )
         stop_level=(m_symbol.Ask()-m_symbol.Bid())*coeff;
//---
   freeze=freeze_level;
   stops=stop_level;
//---
   return ;
  }
//+------------------------------------------------------------------+
//| Close positions                                                  |
//+------------------------------------------------------------------+
void ClosePositions( const ENUM_POSITION_TYPE pos_type)
  {
   double freeze= 0.0 ,stops= 0.0 ;
   FreezeStopsLevels(freeze,stops);
   for ( int i= PositionsTotal ()- 1 ; i>= 0 ; i--) // returns the number of current positions
       if (m_position.SelectByIndex(i)) // selects the position by index for further access to its properties
         if (m_position. Symbol ()==m_symbol.Name() && m_position.Magic()==MACD_MAGIC)
             if (m_position.PositionType()==pos_type)
              {
               if (m_position.PositionType()== POSITION_TYPE_BUY )
                 {
                   bool take_profit_level=((m_position.TakeProfit()!= 0.0 && m_position.TakeProfit()-m_position.PriceCurrent()>=freeze) || m_position.TakeProfit()== 0.0 );
                   bool stop_loss_level=((m_position.StopLoss()!= 0.0 && m_position.PriceCurrent()-m_position.StopLoss()>=freeze) || m_position.StopLoss()== 0.0 );
                   if (take_profit_level && stop_loss_level)
                     if (!m_trade.PositionClose(m_position.Ticket())) // close a position by the specified m_symbol
                         Print ( __FILE__ , " " , __FUNCTION__ , ", ERROR: " , "BUY PositionClose " ,m_position.Ticket(), ", " ,m_trade.ResultRetcodeDescription());
                 }
               if (m_position.PositionType()== POSITION_TYPE_SELL )
                 {
                   bool take_profit_level=((m_position.TakeProfit()!= 0.0 && m_position.PriceCurrent()-m_position.TakeProfit()>=freeze) || m_position.TakeProfit()== 0.0 );
                   bool stop_loss_level=((m_position.StopLoss()!= 0.0 && m_position.StopLoss()-m_position.PriceCurrent()>=freeze) || m_position.StopLoss()== 0.0 );
                   if (take_profit_level && stop_loss_level)
                     if (!m_trade.PositionClose(m_position.Ticket())) // close a position by the specified m_symbol
                         Print ( __FILE__ , " " , __FUNCTION__ , ", ERROR: " , "SELL PositionClose " ,m_position.Ticket(), ", " ,m_trade.ResultRetcodeDescription());
                 }
               PlaySound ( "ok.wav" );
              }
  }
//+------------------------------------------------------------------+
//| Filling the indicator buffers from the indicator                 |
//+------------------------------------------------------------------+
bool iGetArray( const int handle, const int buffer, const int start_pos,
               const int count, double &arr_buffer[])
  {
   bool result= true ;
   if (! ArrayIsDynamic (arr_buffer))
     {
       return ( false );
     }
   ArrayFree (arr_buffer);
//--- reset error code
   ResetLastError ();
//--- fill a part of the iBands array with values from the indicator buffer
   int copied= CopyBuffer (handle,buffer,start_pos,count,arr_buffer);
   if (copied!=count)
     {
       return ( false );
     }
   return (result);
  }
//+------------------------------------------------------------------+
//| ProfitOnTick closing                                             |
//+------------------------------------------------------------------+
bool ProfitBuy( void )
  {
   bool res= false ;
   double PROFIT_BUY= 0.00 ;
   int total= PositionsTotal ();
   for ( int i=total- 1 ; i>= 0 ; i--)
     {
       string    position_GetSymbol= PositionGetSymbol (i);
       if (position_GetSymbol==m_symbol.Name())
        {
         if (m_position.PositionType()== POSITION_TYPE_BUY )
           {
            PROFIT_BUY=PROFIT_BUY+ PositionGetDouble ( POSITION_PROFIT );
           }
        }
       if (PROFIT_BUY>=InpTProfit)
        {
         if (LongClosed())
            res= true ;
         if (ShortOpened())
            res= true ;
        }
     }
   return (res);
  }
//+------------------------------------------------------------------+
//| ProfitOnTick closing                                             |
//+------------------------------------------------------------------+
bool ProfitSell( void )
  {
   bool res= false ;
   double PROFIT_SELL= 0.00 ;
   int total= PositionsTotal ();
   for ( int i=total- 1 ; i>= 0 ; i--)
     {
       string    position_GetSymbol= PositionGetSymbol (i);
       if (position_GetSymbol==m_symbol.Name())
        {
         if (m_position.PositionType()== POSITION_TYPE_SELL )
           {
            PROFIT_SELL=PROFIT_SELL+ PositionGetDouble ( POSITION_PROFIT );
           }
        }
       if (PROFIT_SELL>=InpTProfit)
        {
         if (ShortClosed())
            res= true ;
         if (LongOpened())
            res= true ;
        }
     }
   return (res);
  }
//+------------------------------------------------------------------+

Vitaly Muzichenko 2021.06.30 23:01 #13223

Hay que cambiarle el nombre ahora, con una prueba así seguro que es espadín, o robado, no sé qué es lo correcto.

//+------------------------------------------------------------------+
//|                                                 6 Сопрут 185.mq5 |
//|                                  Copyright 2021, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+

SanAlex 2021.06.30 23:08 #13224

Vitaly Muzichenko:

Hay que cambiarle el nombre ya, con una prueba como esa seguro que la saltan, o la roban, no sé cuál es la palabra correcta.

Tal vez alguien se haga rico - no lo entiendo, me gusta vivir modestamente.

Vitaly Muzichenko 2021.06.30 23:36 #13225

SanAlex:

Tal vez alguien se haga rico - no lo entiendo, simplemente me gusta vivir modestamente.

Este es el primer EA que he ejecutado en el probador en más de 2 años.

Ahora estoy tratando con el probador, todo ha cambiado mucho, han aparecido muchos botones diferentes.

De momento he llegado a la conclusión de que debería ponerlo en demo y ejecutarlo durante un par de semanas.

De todos modos, ya lo he robado ;)

La etiqueta del mercado Además de - "Evaluar [¡Archivo!] Cualquier pregunta de

Ivan Nagibin 2021.07.01 05:21 #13226

Aleksei Stepanenko:

¿No es así como funciona?

Yo hice lo mismo, pero los buffers se quedan a 0, puedes probarlo tú mismo. Lo único que no entiendo es la funciónIndicatorBuffers() en mi mt5, he utilizado #propertyindicatorbuffers

Fast235 2021.07.01 06:31 #13227

SanAlex:

Algo he hecho mal aquí: no sé qué ha pasado de 100.000 rublos a dos millones.

No deberías, están a punto de lanzarlo en el mercado.

SanAlex 2021.07.01 07:16 #13228

Fast235:

No deberías, están a punto de lanzarlo al mercado.

No me importa, al menos sacaré algo de provecho de mis estudios. Tengo más ideas en el fondo de mi mente.

\\\\\\\\\\\\\\\\\\\\

Sólo hay dos funciones que necesitas. Y necesitan ser reescritos adecuadamente por un experto en programación porque soy un aprendiz.

estas son las funciones

1. - 1. son multiplicadores de lotes. se abre la primera posición, luego se multiplica la segunda, y así sucesivamente. se abre la primera posición, luego se multiplica la segunda, y así sucesivamente.

//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double OptimizedBuy(void)
  {
   double PROFIT_BUY=0.00;
   int total=PositionsTotal();
   for(int i=total-1; i>=0; i--) // returns the number of open positions
     {
      string   position_GetSymbol=PositionGetSymbol(i); // GetSymbol позиции
      if(position_GetSymbol==m_symbol.Name())
        {
         if(m_position.PositionType()==POSITION_TYPE_BUY)
           {
            PROFIT_BUY=PROFIT_BUY+m_position.Select(Symbol());
           }
        }
     }
   double Lots=InpLotsRisk;
   double ab=PROFIT_BUY;
   if(ab>0 && ab<=1)
      Lots=InpLotsRisk*2;
   if(ab>1 && ab<=2)
      Lots=InpLotsRisk*4;
   if(ab>2 && ab<=3)
      Lots=InpLotsRisk*8;
   if(ab>3)
      Lots=InpLotsRisk*16;
   return(Lots);
  }
//+------------------------------------------------------------------+

y 2 - cierra la cantidad total en moneda, posiciones abiertas en Buy

//+------------------------------------------------------------------+
//| ProfitOnTick closing                                             |
//+------------------------------------------------------------------+
bool ProfitBuy(void)
  {
   bool res=false;
   double PROFIT_BUY=0.00;
   int total=PositionsTotal();
   for(int i=total-1; i>=0; i--)
     {
      string   position_GetSymbol=PositionGetSymbol(i);
      if(position_GetSymbol==m_symbol.Name())
        {
         if(m_position.PositionType()==POSITION_TYPE_BUY)
           {
            PROFIT_BUY=PROFIT_BUY+PositionGetDouble(POSITION_PROFIT);
           }
        }
      if(PROFIT_BUY>=InpTProfit)
        {
         if(LongClosed())
            res=true;
         if(ShortOpened())
            res=true;
        }
     }
   return(res);
  }
//+------------------------------------------------------------------+

y por supuesto las segundas mitades

[¡AVISO CERRADO!] Cualquier pregunta Cualquier pregunta de novato, necesito consejo de un

Fast235 2021.07.01 07:18 #13229

SanAlex:

Tengo más ideas en el fondo de mi mente. Tengo más ideas en el fondo de mi mente.

Entonces deberías ponerlo en la base de código, si vale la pena.

SanAlex 2021.07.01 07:50 #13230

Vitaly Muzichenko:

Este es el primer EA que he ejecutado en el probador en más de 2 años.

Estoy tratando de entender el probador, todo ha cambiado mucho, han aparecido muchos botones diferentes.

De momento he llegado a la conclusión de que debería ponerlo en demo y ejecutarlo durante un par de semanas.

En resumen, lo he robado ;)

También lo probé con Expert Advisor - de alguna manera depende de la cantidad de cierre. Si pones una cantidad menor, perdería si pones más, también perdería.

Estuve probando 100 000 Rbls y 100 000 Rbls de ganancia y subió a dos millones (el año pasado en EUR/USD durante 1 hora).

una estrategia de negociación Preguntas de Dummies. Necesita un pequeño ajuste

Preguntas de los principiantes MQL5 MT5 MetaTrader 5 - página 1323