Questions des débutants MQL5 MT5 MetaTrader 5

Sprut 185 2021.06.30 22:13 #13221

Alexey Viktorov:

Martin ne doit-il être activé que lorsque le signal de l'indicateur est opposé ou non ?

Exemple : Une position d'achat a été ouverte selon l'indicateur. Le prix a baissé de la distance fixée et l'indicateur montre déjà Sell. Une position d'achat doit être ouverte ?

Pour faire court, .....Martin ne fonctionne que contre la tendance, avec des ordres à la baisse, alors que l'indicateur ne fonctionne qu'avec la tendance.

Demain, je vais essayer de le dessiner sur Photoshop et je posterai le fichier.

FORTS. Questions relatives à [Archive] Toute question de Outil ligne Fibonacci

[Supprimé] 2021.06.30 22:57 #13222

Sprut 185 :

En bref - En même temps ..... Martin ne travaille qu'à contre-tendance, avec des commandes dans le rouge, et selon l'indicateur, nous ne travaillons qu'avec la tendance.

Demain j'essaierai de dessiner sur photoshop et posterai le fichier

J'ai fait quelque chose ici - que je ne comprends pas moi-même avec 100 000 roubles. jusqu'à deux millions

 //+------------------------------------------------------------------+
//|                                                  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

Il faut le renommer maintenant, avec un test comme ça, c'est sûr que c'est sprat, ou volé, pas sûr que ce soit le bon.

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

[Supprimé] 2021.06.30 23:08 #13224

Vitaly Muzichenko:

Nous devons le renommer maintenant, avec un test comme celui-là, il est sûr d'être jeté, ou volé, je ne suis pas sûr du mot juste.

Peut-être que quelqu'un va s'enrichir - je ne comprends pas, j'aime vivre modestement.

Vitaly Muzichenko 2021.06.30 23:36 #13225

SanAlex:

Peut-être que quelqu'un deviendra riche - je ne comprends pas, j'aime juste vivre modestement.

C'est le premier EA que je fais fonctionner dans le testeur depuis plus de 2 ans.

Je m'occupe maintenant du testeur, tout a tellement changé, tant de boutons différents sont apparus.

Jusqu'à présent, je suis arrivé à la conclusion que je devrais le mettre en mode démo et le faire fonctionner pendant quelques semaines.

De toute façon, je l'ai déjà volé ;)

En plus de - TS Scalping sur M1 FOREX - Tendances, prévisions

Ivan Nagibin 2021.07.01 05:21 #13226

Aleksei Stepanenko:

Ce n'est pas comme ça que ça marche ?

J'ai fait la même chose, mais les tampons restent à 0, vous pouvez essayer vous-même. La seule chose que je ne comprends pas est la fonctionIndicatorBuffers() dans mon mt5, j'ai utilisé #propertyindicatorbuffers

Fast235 2021.07.01 06:31 #13227

SanAlex:

J'ai fait quelque chose de mal ici - je ne sais pas ce qui est passé de 100 000 roubles à deux millions.

Tu n'aurais pas dû, ils sont sur le point de le lancer sur le marché.

[Supprimé] 2021.07.01 07:16 #13228

Fast235:

Tu ne devrais pas, ils sont sur le point de le lancer sur le marché.

Je m'en fiche - au moins, je tirerai quelque chose de mes études. J'ai d'autres idées dans un coin de ma tête.

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

Il n'y a que deux fonctions dont vous avez besoin. Et ils doivent être correctement réécrits par un expert en programmation, car je suis un apprenti.

voici les fonctions

1. - 1. ce sont des multiplicateurs de lots. la première position est ouverte, puis la deuxième est multipliée, et ainsi de suite. la première position est ouverte, puis la seconde est multipliée, et ainsi de suite.

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

et 2 - il clôture le montant total en devise, des positions ouvertes en Achat

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

et bien sûr la seconde moitié

[ARCHIVE !] Toute question De la théorie à [Archive] Toute question de

Fast235 2021.07.01 07:18 #13229

SanAlex:

J'ai d'autres idées dans un coin de ma tête. J'ai d'autres idées dans un coin de ma tête.

Ensuite, vous devriez le mettre dans la base de code, s'il en vaut la peine.

[Supprimé] 2021.07.01 07:50 #13230

Vitaly Muzichenko:

C'est le premier EA que je fais fonctionner dans le testeur depuis plus de 2 ans.

J'essaie de comprendre le testeur, tout a tellement changé, tant de boutons différents sont apparus.

Jusqu'à présent, j'en suis arrivé à la conclusion que je devrais le mettre en démo et l'utiliser pendant quelques semaines.

En bref, je l'ai volé ;)

Je l'ai également testé avec Expert Advisor - cela dépend en quelque sorte du montant de clôture. Si vous mettez un montant plus petit, il perdra ; si vous mettez plus, il perdra aussi.

Je testais 100 000 Rbls et 100 000 Rbls de profit et c'est monté jusqu'à deux millions (l'année dernière sur EUR/USD pendant 1 heure).

Basé sur la stratégie Qui a déjà essayé Le Graal existe-t-il ?

Questions des débutants MQL5 MT5 MetaTrader 5 - page 1323