Domande dai principianti MQL5 MT5 MetaTrader 5

Sprut 185 2021.07.01 00:13 #13221

Alexey Viktorov:

Martin deve essere attivato solo quando il segnale dell'indicatore è opposto o indipendentemente?

Esempio: una posizione Buy è stata aperta secondo l'indicatore. Il prezzo è sceso della distanza stabilita e l'indicatore sta già mostrando Sell. Deve essere aperta una posizione Buy?

Per farla breve, .....Martin lavora solo contro il trend, con ordini al ribasso, mentre l'indicatore lavora solo con il trend.

Domani proverò a disegnarlo su Photoshop e posterò il file

[Eliminato] 2021.07.01 00:57 #13222

Sprut 185 :

Insomma - Allo stesso tempo..... Martin lavora solo in controtendenza, con ordini in rosso, e secondo l'indicatore, lavoriamo solo con la tendenza.

Domani proverò a disegnare su photoshop e posto il file

Ho fatto qualcosa qui - che io stesso non capisco con 100.000 rubli. fino a due milioni

 //+------------------------------------------------------------------+
//|                                                  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.07.01 01:01 #13223

Bisogna rinominarlo ora, con un test del genere è sicuro che sia spratto, o rubato, non so cosa sia giusto.

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

[Eliminato] 2021.07.01 01:08 #13224

Vitaly Muzichenko:

Dobbiamo rinominarlo subito, con un test del genere è sicuro che verrà spuntato, o rubato, non sono sicuro di quale sia la parola giusta.

Forse qualcuno diventerà ricco - io non lo capisco, mi piace vivere modestamente.

Vitaly Muzichenko 2021.07.01 01:36 #13225

SanAlex:

Forse qualcuno diventerà ricco - io non lo capisco, mi piace solo vivere modestamente.

Questo è il primo EA che ho eseguito nel tester in più di 2 anni.

Ho a che fare con il tester ora, tutto è cambiato così tanto, sono apparsi così tanti pulsanti diversi.

Finora sono giunto alla conclusione che dovrei metterlo in demo e farlo funzionare per un paio di settimane.

Comunque, l'ho già rubato ;)

Robot completo per MT5 Interessante e umorismo FOREX - Tendenze, previsioni

Ivan Nagibin 2021.07.01 07:21 #13226

Aleksei Stepanenko:

Non è così che funziona?

Ho fatto lo stesso, ma i buffer rimangono 0, potete provare voi stessi. L'unica cosa che non capisco è la funzioneIndicatorBuffers() nel mio mt5, ho usato #propertyindicatorbuffers

Fast235 2021.07.01 08:31 #13227

SanAlex:

Ho sbagliato qualcosa qui - non so cosa sia passato da 100.000 rubli a due milioni.

Non avresti dovuto, stanno per lanciarlo sul mercato.

[Eliminato] 2021.07.01 09:16 #13228

Fast235:

Non dovresti, stanno per lanciarlo sul mercato.

Non mi importa - almeno otterrò qualcosa dai miei studi. Ho altre idee in testa.

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

Ci sono solo due funzioni di cui avete bisogno. E devono essere riscritte correttamente da un esperto di programmazione perché io sono un apprendista.

queste sono le funzioni

1. - 1. sono moltiplicatori di lotto. la prima posizione viene aperta, poi la seconda viene moltiplicata, e così via. la prima posizione viene aperta, poi la seconda viene moltiplicata, e così via.

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

e 2 - chiude l'importo totale in valuta, posizioni aperte in 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);
  }
//+------------------------------------------------------------------+

e naturalmente la seconda metà

[Qualsiasi domanda da principiante, Caratteristiche utili da KimIV [Qualsiasi domanda da principiante,

Fast235 2021.07.01 09:18 #13229

SanAlex:

Ho altre idee in testa. Ho altre idee in testa.

Allora dovreste metterlo nel codebase, se ne vale la pena.

[Eliminato] 2021.07.01 09:50 #13230

Vitaly Muzichenko:

Questo è il primo EA che ho eseguito nel tester in più di 2 anni.

Sto cercando di capire il tester, tutto è cambiato così tanto, sono apparsi tanti pulsanti diversi.

Finora sono giunto alla conclusione che dovrei metterlo in demo e farlo funzionare per un paio di settimane.

In breve, l'ho rubato ;)

L'ho anche testato con Expert Advisor - in qualche modo dipende dall'importo di chiusura. Se si mette una quantità minore, perderebbe, se si mette di più, perderebbe anche.

Stavo testando 100 000 Rbls e 100 000 Rbls di profitto e sono arrivato a due milioni (l'anno scorso su EUR/USD per 1 ora).

Portafoglio: PriceChannelExpert e altri Quali modi conosci per EURUSD - Tendenze, previsioni

Domande dai principianti MQL5 MT5 MetaTrader 5 - pagina 1323