I’ve done something here - that I don’t understand with 100,000 rubles - Expert Advisors and Automated Trading

Sprut 185 2021.06.30 22:13 #13221

Alexey Viktorov:

Should Martin only be activated when the indicator signal is opposite or regardless?

Example: A Buy position was opened according to the indicator. The price has fallen by the set distance and the indicator is already showing Sell. A Buy position shall be opened?

To make it short, .....Martin works only against the trend, with orders to the downside, while the indicator works only with the trend.

Tomorrow I will try to draw it on Photoshop and I will post the file

[Deleted] 2021.06.30 22:57 #13222

Sprut 185 :

In short - At the same time ..... Martin works only against the trend, with orders in the red, and according to the indicator, we work only with the trend.

Tomorrow I'll try to draw on photoshop and post the file

I’ve done something here - that I myself don’t understand with 100,000 rubles. up to two million

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

Need to rename it now, with a test like that it's sure to be sprat, or stolen, not sure what's right.

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

[Deleted] 2021.06.30 23:08 #13224

Vitaly Muzichenko:

We need to rename it now, with a test like that it's sure to get sprung, or stolen, I'm not sure what's the right word.

Maybe someone will get rich - I don't get it, I like to live modestly.

Vitaly Muzichenko 2021.06.30 23:36 #13225

SanAlex:

Maybe someone will get rich - I don't get it, I just like to live modestly.

This is the first EA I have run in the tester in more than 2 years.

I am dealing with the tester now, everything has changed so much, so many different buttons have appeared.

So far I have come to the conclusion that I should put it on demo and run it for a couple of weeks.

Anyway, I've already stolen it ;)

In addition to - it possible to run [Archive] Learn how to

Ivan Nagibin 2021.07.01 05:21 #13226

Aleksei Stepanenko:

Isn't that how it works?

I did the same, but the buffers remain 0, you can try it yourself. The only thing I don't understand is theIndicatorBuffers() functionin my mt5, I used #propertyindicatorbuffers

Fast235 2021.07.01 06:31 #13227

SanAlex:

I've done something wrong here - I don't know what went from 100,000 roubles to two million.

You shouldn't have, they're about to launch it in the Market.

[Deleted] 2021.07.01 07:16 #13228

Fast235:

You shouldn't, they're about to launch it on the Market.

I don't care - at least I'll get something out of my studies. I've got more ideas in the back of my mind.

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

There's only two functions you need. And they need to be properly rewritten by a programming expert because I'm an apprentice.

these are the functions

1. - 1. they are lot multipliers. the first position is opened, then the second one is multiplied, and so on. the first position is opened, then the second one is multiplied, and so on.

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

and 2 - it closes the total amount in currency, opened positions 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);
  }
//+------------------------------------------------------------------+

and of course the second halves

Errors, bugs, questions Any questions from newcomers [ARCHIVE]Any rookie question, so

Fast235 2021.07.01 07:18 #13229

SanAlex:

I've got more ideas in the back of my mind. I've got more ideas in the back of my mind.

Then you should put it in the codebase, if it's worthy.

[Deleted] 2021.07.01 07:50 #13230

Vitaly Muzichenko:

This is the first EA I have run in the tester in more than 2 years.

I am trying to understand the tester, everything has changed so much, so many different buttons have appeared.

So far I've come to the conclusion that I should put it on demo and run it for a couple of weeks.

In short, I stole it ;)

I also tested it with Expert Advisor - it somehow depends on the closing amount. If you put a smaller amount, it would lose if you put more, it would also lose.

I was testing 100 000 Rbls and 100 000 Rbls of profit and it went up to two million (last year on EUR/USD for 1 hour).

Needs a little tweaking How do I get Change the lot

Questions from Beginners MQL5 MT5 MetaTrader 5 - page 1323