Écrire des EA gratuites - page 12

[Iurii Tokman]

SanAlex:

Je n'en ai aucune idée - je l'ai fait tel quel ! Je suis autodidacte, tout en piquant scientifiquement.

\\\\\\\\\\\\\ Je suis moi-même surpris - il semble aussi que le résultat soit bon - mon expert est lourd - il faut beaucoup de temps pour le tester

votre signal est différent
l'original est un croisement de lignes plus et moins
vous avez aussi la ligne principale dans le signal

[[Supprimé]]

Iurii Tokman:

Vous avez un signal différent
dans le croisement original des lignes plus et moins
vous avez aussi la ligne principale dans le signal

Oui ! J'ai utilisé trois lignes - la ligne négative (rose) est comme le zéro - et les deux qui la croisent donnent le signal

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

Le mois de mars est en baisse ---------- Je vais probablement terminer ce test à temps pour le nouvel an.

[Iurii Tokman]

SanAlex:

Oui ! j'ai utilisé trois lignes - la ligne moins (rose) est zéro - et les deux qui la croisent donnent un signal

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

le mois de mars se termine ---------- Je terminerai probablement ce test avant le nouvel an (je n'en suis qu'à la moitié).

Si les hiboux utilisent l'indicateur personnalisé
, alors le signal doit simplement être transféré vers le Conseiller Expert
et ne pas utiliser l'indicateur

[SAJSRAh]

Je suis désolé, pouvez-vous faire un EA basé sur ma demande pour l'indicateur adx-buy-sell ?

[[Supprimé]]

SAJSRAh:
Je suis désolé, pouvez-vous faire un Expert Advisor basé sur ma demande pour l'indicateur adx-buy-sell ?

s'il s'agit d'un indicateur de signal - vous pouvez utiliser cet Expert Advisor (mt4)https://www.mql5.com/ru/forum/310846/page63#comment_17088893

input string   t="------------- Balans Parameters -----"; //
input double   TargetProfit     = 999999.99;     // Баланс + Прибыль(прибавить к балансу)
input double   TargetLoss       = 0;             // Баланс - Убыток(отнять от баланса)
input string   t2="------------ Exchange TP SL --------"; //
input double   InpTProfit       = 1000;          // Exchange TP
input double   InpStopLoss      = 1000000;       // Exchange SL
input string   t0="------------ Lots Parameters -------"; //
input double   InpLots          = 0.01;          // Lots
input double   InpLots1         = 0.02;          // : Lots 1
input int      InpLots_01       = 200;           // Exchange Lots
input double   InpLots2         = 0.04;          // : Lots 2
input int      InpLots_02       = 400;           // Exchange Lots
input double   InpLots3         = 0.08;          // : Lots 3
input int      InpLots_03       = 800;           // Exchange Lots
input double   InpLots4         = 0.16;          // : Lots 4
input string   _Orders_="------ Parameters Order ------"; //
input double   TakeProfit       = 500;           // Take Profit
input double   TrailingStop     = 300;           // Фиксированный размер трала
input double   TrailingStep     = 50;            // Шаг трала
input string   short_name       = "FilterSignal";// Name Indicators
input bool     InpOnlyOne       = false;         // Close opposite
input bool     ObjRevers        = false;         // Revers

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

là où c'est marqué en jaune - écrivez le nom de votre Indicateur

[Iurii Tokman]

SanAlex:

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

si vous utilisez une croix, sans avenir, il n'y a pas de profit à en tirer

[[Supprimé]]

Iurii Tokman:

si les hiboux utilisent l'indicateur personnalisé
alors vous devez juste transférer le signal à l'EA
et ne pas utiliser l'indicateur

J'ai un Expert Advisor lourd du fait qu'il a de nombreuses fonctions de lignes horizontales et de tendances.

le voicihttps://www.mql5.com/ru/code/34046

La fonction elle-même - travaillez à partir du code ici

sinput group "----------------- Indicators: UP -----------------------"
sinput bool               InpIndicators_1            = false;            // Indicators: Start (true)
sinput ENUM_MODE          FilterLine_3               = mode_All;         // FILTER: ВКЛ.ВЫКЛ.
sinput string             short_name_1               = "Имя Индикатора"; // Name Indicators "UP"
sinput int                InpBars_1                  = 1;                // Bars
sinput ENUM_TIMEFRAMES    Period_1                   = PERIOD_CURRENT;   // Period Indicators
sinput ENUM_TRADE_COMMAND InpLongOpened_1Command     = close_open_b;     // Buy command:
sinput ENUM_TRADE_COMMAND InpShortOpened_1Command    = close_open_s;     // Sell command:

//+------------------------------------------------------------------+
//| Initialization of the indicators                                 |
//+------------------------------------------------------------------+
bool CSampleExpert::InitIndicators_1(void)
  {
//--- create MACD indicator
   if(m_handle_macd_1==INVALID_HANDLE)
      if((m_handle_macd_1=iCustom(m_symbol.Name(),Period_1,short_name_1))==INVALID_HANDLE)
        {
         printf("Error creating indicator_1");
         return(false);
        }
//--- succeed
   return(true);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Check for long position opening                                  |
//+------------------------------------------------------------------+
bool CSampleExpert::LongOpened_1(void)
  {
   bool res=false;
//--- check for long position (BUY) possibility
   if(m_macd_current_1<m_signal_current_1)
     {
      InpTradeCommand(InpLongOpened_1Command);
      //--- in any case we must exit from expert
      res=true;
     }
//--- result
   return(res);
  }
//+------------------------------------------------------------------+
//| Check for short position opening                                 |
//+------------------------------------------------------------------+
bool CSampleExpert::ShortOpened_1(void)
  {
   bool res=false;
//--- check for short position (SELL) possibility
   if(m_macd_current_1>m_signal_current_1)
     {
      InpTradeCommand(InpShortOpened_1Command);
      //--- in any case we must exit from expert
      res=true;
     }
//--- result
   return(res);
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| main function returns true if any position processed             |
//+------------------------------------------------------------------+
bool CSampleExpert::Processing_1(void)
  {
//--- we work only at the time of the birth of new bar
   datetime time_0=iTime(m_symbol.Name(),Period_1,0);
   if(time_0==ExtPrevBars_1)
      return(false);
   ExtPrevBars_1=time_0;
   if(!m_symbol.RefreshRates())
     {
      ExtPrevBars_1=0;
      return(false);
     }
//--- refresh indicators
   if(BarsCalculated(m_handle_macd_1)<2)
      return(false);
   if(CopyBuffer(m_handle_macd_1,0,InpBars_1,2,m_buff_MACD_main_1)  !=2 ||
      CopyBuffer(m_handle_macd_1,1,InpBars_1,2,m_buff_MACD_signal_1)!=2)
     {
      ExtPrevBars_1=0;
      return(false);
     }
//   m_indicators.Refresh();
//--- to simplify the coding and speed up access
//--- data are put into internal variables
   m_macd_current_1   =m_buff_MACD_main_1[0];
   m_signal_current_1 =m_buff_MACD_signal_1[0];
//--- check for long position (BUY) possibility
   if(LongOpened_1())
      return(true);
//--- check for short position (SELL) possibility
   if(ShortOpened_1())
      return(true);
//--- exit without position processing
   return(false);
  }
//+------------------------------------------------------------------+

[[Supprimé]]

Iurii Tokman:

si vous utilisez une croix, sans avenir, il n'y a pas de profit là-dedans

J'ai un résultat différent, cependant - il y a encore un peu de chemin à parcourir avant la fin du test.

[[Supprimé]]

TOTAL : Indicateur "Back and forth ADX" mars avril - pas de succès pour une raison quelconque

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

Voici l'indicateur lui-même

[[Supprimé]]

SanAlex :

RÉSULTAT : Indicateur "Aller et retour ADX" mars avril - échec pour une raison quelconque

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

voici l'indicateur

Ici, l'expert travaille intelligemment dans le testeur - vérifiez les indicateurs de signal

 //+------------------------------------------------------------------+
//|                                           Back and forth ADX.mq5 |
//|                                  Copyright 2021, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, MetaQuotes Software Corp."
#property link        " http://www.mql5.com "
#property version    "1.00"

#define   MACD_MAGIC 9294501
//---
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\AccountInfo.mqh>
//---
input double InpLots          = 0.01 ;                 // Lots
input int     InpTakeProfit    = 500 ;                   // Take Profit (in pips)
input int     InpTrailingStop  = 300 ;                   // Trailing Stop Level (in pips)
sinput group "----------------- Indicators: -----------------------"
input string Inp_name_1       = "Back and forth ADX" ; // Name Indicators
input int     InpBars_1        = 1 ;                     // Bars
//---
int ExtTimeOut= 10 ; // time out in seconds between trade operations
//+------------------------------------------------------------------+
//| MACD Sample expert class                                         |
//+------------------------------------------------------------------+
class CSampleExpert
  {
protected :
   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
   //--- indicators
   int                m_handle_macd;                 // MACD indicator handle
   //--- indicator buffers
   double             m_buff_MACD_main[];           // MACD indicator main buffer
   double             m_buff_MACD_signal[];         // MACD indicator signal buffer
   //--- indicator data for processing
   double             m_macd_current;
   double             m_signal_current;
   //---
   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 );
  };
//--- global expert
CSampleExpert ExtExpert;
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CSampleExpert::CSampleExpert( void ) : m_adjusted_point( 0 ),
   m_handle_macd( INVALID_HANDLE ),
   m_macd_current( 0 ),
   m_signal_current( 0 ),
   m_traling_stop( 0 ),
   m_take_profit( 0 )
  {
   ArraySetAsSeries (m_buff_MACD_main, true );
   ArraySetAsSeries (m_buff_MACD_signal, true );
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CSampleExpert::~CSampleExpert( void )
  {
  }
//+------------------------------------------------------------------+
//| Initialization and checking for input parameters                 |
//+------------------------------------------------------------------+
bool CSampleExpert::Init( void )
  {
//--- 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_traling_stop    =InpTrailingStop*m_adjusted_point;
   m_take_profit     =InpTakeProfit*m_adjusted_point;
//--- set default deviation for trading in adjusted points
   m_trade.SetDeviationInPoints( 3 *digits_adjust);
//---
   if (!InitCheckParameters(digits_adjust))
       return ( false );
   if (!InitIndicators())
       return ( false );
//--- succeed
   return ( true );
  }
//+------------------------------------------------------------------+
//| Checking for input parameters                                    |
//+------------------------------------------------------------------+
bool CSampleExpert::InitCheckParameters( const int digits_adjust)
  {
//--- initial data checks
   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 );
     }
//--- check for right lots amount
   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 );
     }
//--- warning
   if (InpTakeProfit<=InpTrailingStop)
       printf ( "Warning: Trailing Stop must be less than Take Profit" );
//--- succeed
   return ( true );
  }
//+------------------------------------------------------------------+
//| Initialization of the indicators                                 |
//+------------------------------------------------------------------+
bool CSampleExpert::InitIndicators( void )
  {
//--- create MACD indicator
   if (m_handle_macd== INVALID_HANDLE )
       if ((m_handle_macd= iCustom ( _Symbol , _Period ,Inp_name_1))== INVALID_HANDLE )
        {
         printf ( "Error creating MACD indicator" );
         return ( false );
        }
//--- succeed
   return ( true );
  }
//+------------------------------------------------------------------+
//| Check for long position closing                                  |
//+------------------------------------------------------------------+
bool CSampleExpert::LongClosed( void )
  {
   bool res= false ;
//--- should it be closed?
   if (m_macd_current>m_signal_current)
     {
       //--- close position
       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());
       //--- processed and cannot be modified
      res= true ;
     }
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Check for short position closing                                 |
//+------------------------------------------------------------------+
bool CSampleExpert::ShortClosed( void )
  {
   bool res= false ;
//--- should it be closed?
   if (m_macd_current<m_signal_current)
     {
       //--- close position
       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());
       //--- processed and cannot be modified
      res= true ;
     }
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Check for long position modifying                                |
//+------------------------------------------------------------------+
bool CSampleExpert::LongModified( void )
  {
   bool res= false ;
//--- check for 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 )
           {
             //--- modify position
             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);
              }
             //--- modified and must exit from expert
            res= true ;
           }
        }
     }
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Check for short position modifying                               |
//+------------------------------------------------------------------+
bool CSampleExpert::ShortModified( void )
  {
   bool    res= false ;
//--- check for 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 )
           {
             //--- modify position
             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);
              }
             //--- modified and must exit from expert
            res= true ;
           }
        }
     }
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Check for long position opening                                  |
//+------------------------------------------------------------------+
bool CSampleExpert::LongOpened( void )
  {
   bool res= false ;
//--- check for long position (BUY) possibility
   if (m_macd_current<m_signal_current)
     {
       double price=m_symbol.Ask();
       double tp   =m_symbol.Bid()+m_take_profit;
       //--- check for free money
       if (m_account.FreeMarginCheck( Symbol (), ORDER_TYPE_BUY ,InpLots,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 ,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 any case we must exit from expert
      res= true ;
     }
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Check for short position opening                                 |
//+------------------------------------------------------------------+
bool CSampleExpert::ShortOpened( void )
  {
   bool res= false ;
//--- check for short position (SELL) possibility
   if (m_macd_current>m_signal_current)
     {
       double price=m_symbol.Bid();
       double tp   =m_symbol.Ask()-m_take_profit;
       //--- check for free money
       if (m_account.FreeMarginCheck( Symbol (), ORDER_TYPE_SELL ,InpLots,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 ,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 any case we must exit from expert
      res= true ;
     }
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| main function returns true if any position processed             |
//+------------------------------------------------------------------+
bool CSampleExpert::Processing( void )
  {
//--- refresh rates
   if (!m_symbol.RefreshRates())
       return ( false );
//--- refresh indicators
   if ( BarsCalculated (m_handle_macd)< 2 )
       return ( false );
   if ( CopyBuffer (m_handle_macd, 0 ,InpBars_1, 2 ,m_buff_MACD_main)  != 2 ||
       CopyBuffer (m_handle_macd, 1 ,InpBars_1, 2 ,m_buff_MACD_signal)!= 2 )
       return ( false );
//   m_indicators.Refresh();
//--- to simplify the coding and speed up access
//--- data are put into internal variables
   m_macd_current   =m_buff_MACD_main[ 0 ];
   m_signal_current =m_buff_MACD_signal[ 0 ];
//--- it is important to enter the market correctly,
//--- but it is more important to exit it correctly...
//--- first check if position exists - try to select it
   if (m_position.Select( Symbol ()))
     {
       if (m_position.PositionType()== POSITION_TYPE_BUY )
        {
         //--- try to close or modify long position
         if (LongClosed())
             return ( true );
         if (LongModified())
             return ( true );
        }
       else
        {
         //--- try to close or modify short position
         if (ShortClosed())
             return ( true );
         if (ShortModified())
             return ( true );
        }
     }
//--- no opened position identified
   else
     {
       //--- check for long position (BUY) possibility
       if (LongOpened())
         return ( true );
       //--- check for short position (SELL) possibility
       if (ShortOpened())
         return ( true );
     }
//--- exit without position processing
   return ( false );
  }
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit ( void )
  {
//--- create all necessary objects
   if (!ExtExpert.Init())
       return ( INIT_FAILED );
//--- secceed
   return ( INIT_SUCCEEDED );
  }
//+------------------------------------------------------------------+
//| Expert new tick handling function                                |
//+------------------------------------------------------------------+
void OnTick ( void )
  {
   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 (ExtExpert.Processing())
            limit_time= TimeCurrent ()+ExtTimeOut;
        }
     }
  }
//+------------------------------------------------------------------+

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

CORRIGÉ - N'A PAS ÉCRIT ICI

       if ((m_handle_macd= iCustom ( _Symbol , _Period , Inp_name_1 ))== INVALID_HANDLE )