Freie EAs schreiben - Seite 12

 
SanAlex:

Ich habe keine Ahnung - ich habe es so gemacht, wie es ist! Ich bin Autodidakt, alles durch wissenschaftliches Stochern

\\\\\\\\\\\\\ Ich bin selbst überrascht - es scheint auch ein gutes Ergebnis zu sein - mein Experte ist schwer - es dauert eine lange Zeit zu testen

Ihr Signal ist anders
Original ist ein Kreuz von Linien plus und minus
Sie haben auch die Hauptlinie im Signal

 
Iurii Tokman:

Sie haben ein anderes Signal
in der ursprünglichen Kreuzung von Linien plus und minus
Sie haben auch die Hauptlinie in das Signal

Ja! Ich habe drei Linien verwendet - die negative (rosa) Linie ist wie Null - und die beiden, die sie kreuzen, ergeben das Signal

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

Der März steht vor der Tür ---------- Ich werde diesen Test wahrscheinlich rechtzeitig zum neuen Jahr abschließen.

Bis jetzt läuft es gut 4

 
SanAlex:

Ja! Ich habe drei Linien verwendet - die Minuslinie (rosa) ist Null - und die beiden Linien, die sie kreuzen, geben ein Signal

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

der Monat März geht zu Ende ---------- Ich werde diesen Test wahrscheinlich bis zum neuen Jahr abschließen (ich bin erst zur Hälfte fertig)


Wenn Eulen den benutzerdefinierten Indikator
verwenden, dann sollte das Signal einfach in den Expert Advisor
übertragen werden und der Indikator nicht verwendet werden.

 
Es tut mir leid, können Sie einen EA auf der Grundlage meiner Anfrage für den Indikator adx-buy-sell machen?
 
SAJSRAh:
Es tut mir leid, können Sie einen Expert Advisor basierend auf meiner Anfrage für den adx-buy-sell Indikator erstellen?

wenn es sich um einen Signalindikator handelt - Sie können diesen Expert Advisor (mt4)https://www.mql5.com/ru/forum/310846/page63#comment_17088893 verwenden

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

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

an den gelb markierten Stellen - den Namen des Indikators eintragen

Как я собираю себе советника методом тыка
Как я собираю себе советника методом тыка
  • 2020.06.19
  • www.mql5.com
Из этих Советников весь материал Автор MQL5-кода: Vladimir Karputov. Stop loss Take profit.mq5TrendMeLeaveMe(barabashkakvn's edition...
 
SanAlex:

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

wenn Sie ein Kreuz verwenden, das keine Zukunft hat, gibt es keinen Gewinn


 
Iurii Tokman:

wenn Eulen den benutzerdefinierten Indikator
verwenden, sollte das Signal einfach an den EA
übertragen werden und nicht den Indikator verwenden

Ich habe eine schwere Expert Advisor aus der Tatsache, dass es eine Menge von Funktionen von Horizontal-und Trendlinien hat.

hier ist eshttps://www.mql5.com/ru/code/34046

Die Funktion selbst - arbeiten Sie hier mit dem Indikator

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

läuft bisher gut 5

Algorithm manually automate
Algorithm manually automate
  • www.mql5.com
Эксперт для Автоматизации Ручной торговли.
 
Iurii Tokman:

wenn Sie ein Kreuz verwenden, ohne Zukunft, gibt es keinen Gewinn dort


Ich habe allerdings ein anderes Ergebnis - bis zum Ende des Tests ist es noch ein bisschen hin

läuft bisher gut 6

 

TOTAL : "Back and forth ADX" März April Indikator - aus irgendeinem Grund nicht erfolgreich

läuft bisher gut 7

läuft bisher gut 8

läuft bisher gut 9

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

Hier ist der Indikator selbst

Dateien:
 
SanAlex :

ERGEBNIS: Indikator "Hin und Her ADX" März April - aus irgendeinem Grund nicht erfolgreich

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

hier ist der indikator

Hier arbeitet der Expert smart im Tester - Check Signal Indicators

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

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

KORRIGIERT - HABE HIER NICHT SCHREIBEN

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