Comment j'ai assemblé mon conseiller par essais et erreurs - page 53

[Alexsandr San]

Alexsandr San:

#propriété version "1.012"

Légère amélioration de la fonction

lorsqu'elle est déclenchée, la ligne horizontale SELL ouvre une position et affiche une ligne horizontale BUY et vice versa.

De même, la ligne est définie à partir de "0" et la distance est définiepar Obj : Trailing Step MACD

ou de la ligne horizontale"LOW".

FromTimer "LOW Up" "LOW Down" identique, seulela distance est définie (entrée ushort InpObjTrailingStepCS = 5;// Obj : Trailing Step, en pips (1.00045-1.00055=1 pips)

Comment connaître la distance de la ligne horizontale dans l'indicateurLow_Macd_Line.mq5 à mettre dans le sentier (sur chaque paire, une distance différente)

Copier et coller dans les paramètres de l'Utilitaire

dans l'image de "0" à Horizontal BUY 0.0064 et quand il touche Horizontal LOW, Horizontal SELL sera mis (seulement en dessous de"0"-0.0064)

IMPORTANT !!! Ne mettez pas de moins ( - ) devant les chiffres que nous tapons dans l'utilitaire.

Une des variantes, comment fonctionne cette fonction

Modification de la fonction "Profits et pertes #property version "1.013"

input string   t="-----  Parameters         -----";              //
input string   Template                     = "ADX";             // Имя шаблона(without '.tpl')
input bool     Inpwithout                   = false;             // Сменить только шаблон (true)
input datetime InpMonday_2                  = D'1970.01.01';     // Dell (00::00 -> off)
input double   TargetTakeProfit             = 1000000;           // Прибыль
input double   TargetStopLoss               = 1000000;           // Убыток
input uint     maxLimits                    = 1;                 // Кол-во Позиции Открыть в одну сторону
input double   InpLots                      = 0.01;              // Lots
input int      InpTakeProfit                = 900;               // Take Profit ("0"-No. 5<100)

s'il est atteint, fermera et effacera tout, et changera toutes les fenêtres ouvertes pour le modèle spécifié

[Alexsandr San]

La fonction ouvre une position, à partir du compte de résultat.

//+------------------------------------------------------------------+
//|                                            Close_Open_Profit.mq5 |
//|                        Copyright 2020, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2020, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"

#define  InpMagic 0
//---
#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>
CPositionInfo  m_position; // trade position object
CTrade         m_trade;    // trading object
CSymbolInfo    m_symbol;   // symbol info object
//---
input double InpLots                      = 0.01;  // Lots
input double TargetTakeProfit             = 10000; // Прибыль
input double TargetStopLoss               = 10000; // Убыток
input bool   Acc                          = false; // Open=true; CloseAll=false;
input string t10="- Buy=false><Sell=true  -----";  //
input bool   ObjRevers                    = false; // BUY=false; SELL=true;
//---
double m_adjusted_point; // point value adjusted for 3 or 5 points
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(!m_symbol.Name(Symbol())) // sets symbol name
      return(INIT_FAILED);;
//---
   m_trade.SetExpertMagicNumber(InpMagic);
   m_trade.SetMarginMode();
   m_trade.SetTypeFillingBySymbol(m_symbol.Name());
//--- 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);
//---
   ObjectCreate(0,"Buy",OBJ_BUTTON,0,0,0);
   ObjectSetInteger(0,"Buy",OBJPROP_XDISTANCE,ChartGetInteger(0,CHART_WIDTH_IN_PIXELS)-102);
   ObjectSetInteger(0,"Buy",OBJPROP_YDISTANCE,37);
   ObjectSetString(0,"Buy",OBJPROP_TEXT,"Buy");
   ObjectSetInteger(0,"Buy",OBJPROP_BGCOLOR,clrMediumSeaGreen);
//---
   ObjectCreate(0,"Sell",OBJ_BUTTON,0,0,0);
   ObjectSetInteger(0,"Sell",OBJPROP_XDISTANCE,ChartGetInteger(0,CHART_WIDTH_IN_PIXELS)-50);
   ObjectSetInteger(0,"Sell",OBJPROP_YDISTANCE,37);
   ObjectSetString(0,"Sell",OBJPROP_TEXT,"Sell");
   ObjectSetInteger(0,"Sell",OBJPROP_BGCOLOR,clrDarkOrange);
//---
   ObjectCreate(0,"CloseAll",OBJ_BUTTON,0,0,0);
   ObjectSetInteger(0,"CloseAll",OBJPROP_XDISTANCE,ChartGetInteger(0,CHART_WIDTH_IN_PIXELS)-75);
   ObjectSetInteger(0,"CloseAll",OBJPROP_YDISTANCE,57);
   ObjectSetString(0,"CloseAll",OBJPROP_TEXT,"CloseAll");
   ObjectSetInteger(0,"CloseAll",OBJPROP_BGCOLOR,clrMediumVioletRed);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   if(ObjectFind(0,"Buy")==0)
     {
      ObjectDelete(0,"Buy");
     }
   if(ObjectFind(0,"Sell")==0)
     {
      ObjectDelete(0,"Sell");
     }
   if(ObjectFind(0,"CloseAll")==0)
     {
      ObjectDelete(0,"CloseAll");
     }
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if(AccountInfoDouble(ACCOUNT_PROFIT)<-TargetStopLoss ||
      AccountInfoDouble(ACCOUNT_PROFIT)>=TargetTakeProfit)
     {
      if(!Acc)
        {
         CloseAll();
        }
      if(Acc)
        {
         if(!ObjRevers)
           {
            CloseAll();
            double price=m_symbol.Ask();
            m_trade.PositionOpen(m_symbol.Name(),ORDER_TYPE_BUY,InpLots,price,0.0,0.0);
           }
         if(ObjRevers)
           {
            CloseAll();
            double price=m_symbol.Bid();
            m_trade.PositionOpen(m_symbol.Name(),ORDER_TYPE_SELL,InpLots,price,0.0,0.0);
           }
        }
      PlaySound("ok.wav");
     }
   if(ObjectGetInteger(0,"Buy",OBJPROP_STATE)!=0)
     {
      ObjectSetInteger(0,"Buy",OBJPROP_STATE,0);
      double price=m_symbol.Ask();
      m_trade.PositionOpen(m_symbol.Name(),ORDER_TYPE_BUY,InpLots,price,0.0,0.0);
     }
   if(ObjectGetInteger(0,"Sell",OBJPROP_STATE)!=0)
     {
      ObjectSetInteger(0,"Sell",OBJPROP_STATE,0);
      double price=m_symbol.Bid();
      m_trade.PositionOpen(m_symbol.Name(),ORDER_TYPE_SELL,InpLots,price,0.0,0.0);
     }
   if(ObjectGetInteger(0,"CloseAll",OBJPROP_STATE)!=0)
     {
      ObjectSetInteger(0,"CloseAll",OBJPROP_STATE,0);
      CloseAll();
     }
  }
//+------------------------------------------------------------------+
//| start function                                                   |
//+------------------------------------------------------------------+
void CloseAll(void)
  {
   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
        {
         ClosePosition(m_position.Symbol()); // close a position by the specified symbo
        }
  }
//+------------------------------------------------------------------+
//| Close selected position                                          |
//+------------------------------------------------------------------+
void ClosePosition(const string symbol)
  {
   if(InitTrade(symbol))
      m_trade.PositionClose(m_position.Ticket()); // close a position by the specified symbo
   PlaySound("ok.wav");
  }
//+------------------------------------------------------------------+
//| Init trade object                                                |
//+------------------------------------------------------------------+
bool InitTrade(const string symbol)
  {
   if(!m_symbol.Name(symbol)) // sets symbol name
      return(false);
   if(IsFillingTypeAllowed(symbol,SYMBOL_FILLING_FOK))
      m_trade.SetTypeFilling(ORDER_FILLING_FOK);
   else
      if(IsFillingTypeAllowed(symbol,SYMBOL_FILLING_IOC))
         m_trade.SetTypeFilling(ORDER_FILLING_IOC);
      else
         m_trade.SetTypeFilling(ORDER_FILLING_RETURN);
   return(true);
  }
//+------------------------------------------------------------------+
//| Checks if the specified filling mode is allowed                  |
//+------------------------------------------------------------------+
bool IsFillingTypeAllowed(string symbol,int fill_type)
  {
//--- Obtain the value of the property that describes allowed filling modes
   int filling=(int)SymbolInfoInteger(symbol,SYMBOL_FILLING_MODE);
//--- Return true, if mode fill_type is allowed
   return((filling & fill_type)==fill_type);
  }
//+------------------------------------------------------------------+

[Alexsandr San]

Alexsandr San:

J'ai créé un indicateur d'assistant dans UtilityCommand.mq5, les lignes se déplacent et il est possible de définir des commandes à partir de celles-ci. Je l'ai construit avecSEM

J'ai trouvé https://www.mql5.com/ru/code/16269 Il s'avère être un script mt4 Je remercie l'auteurAlexey Volchanskiy.

[Alexsandr San]

Alexsandr San:

J'ai cherché https://www.mql5.com/ru/code/16269 Il s'avère que ce script de mt4 Merci à l'auteurAlexey Volchanskiy!

Il existe un script non seulement pour mt4 mais aussi pour mt5https://www.mql5.com/ru/code/16262 Je l'ai maîtrisé dans l'Indicateur.Je remercie l'auteurAlexey Volchanskiy!

[Alexsandr San]

Alexsandr San:

Modification de la fonction "Profits et pertes #property version "1.013"

lorsqu'il est atteint, il fermera et supprimera tout, et changera toutes les fenêtres ouvertes pour le modèle spécifié.

#propriété version "1.014"

Pourtant, le profit de la balance est une fonction nécessaire - lorsqu'un conseiller expert travaille sur plusieurs paires.

a redéfini le concept de "Profit et Perte" afin de pouvoir clôturer sur une paire donnée sans affecter les autres paires.

//+------------------------------------------------------------------+
input string   t="-----  Parameters         -----";              //
input string   Template                     = "ADX";             // Имя шаблона(without '.tpl')
input bool     Inpwithout                   = false;             // Сменить только шаблон (true)
input datetime InpMonday_2                  = D'1970.01.01';     // Dell (00::00 -> off)
input double   TargetProfit                 = 999999.99;         // Цель Баланса(Ваш Баланс + сумма)
input uint     maxLimits                    = 1;                 // Кол-во Позиции Открыть в одну сторону
input double   InpLots                      = 0.01;              // Lots
input int      InpTakeProfit                = 900;               // Take Profit ("0"-No. 5<100)
input double   TargetTakeProfit             = 1000000;           // Прибыль на паре в валюте
input double   TargetStopLoss               = 1000000;           // Убыток на паре в валюте

Profits et pertes, écrivez le montant (par exemple 1 unité de votre devise) dans le paramètre 1000000 - jusqu'à ce qu'il prenne un million devotredevise, il ne fermera pas la position.

[Alexsandr San]

Alexsandr San:

#propriété version "1.014"

Néanmoins, le profit de la balance est une fonction nécessaire lorsqu'un conseiller expert travaille sur plusieurs paires.

refonte des profits et pertes pour clôturer sur cette paire et ne pas affecter les autres paires

Lafonction P&L fixe le montant (par exemple, 1 unité de votre devise) à 1000000 - elle ne ferme pas la position avant d'avoir pris un million devotre devise.

#propriété version "1.015"

un peu fixe, cette fonction(Profit et Perte) - parce que sur une paire, vous pouvez ouvrir plusieurs positions, une façon - maintenant va fermer le montant total, une position peut être dans le plus et l'autre dans le négatif, mais le montant total est égal au montant spécifié dans les paramètres.

----------------------

voici une fonction(Profit & Loss)

//+------------------------------------------------------------------+
//| Check for long position closing                                  |
//+------------------------------------------------------------------+
bool ProfitOnTick(void)
  {
   bool res=false;
   double level;
   double PROFIT_BUY=0.00;
   double PROFIT_SELL=0.00;
   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())
           {
            if(m_position.PositionType()==POSITION_TYPE_BUY)
              {
               PROFIT_BUY=PROFIT_BUY+PositionGetDouble(POSITION_PROFIT);
               if(PROFIT_BUY<-TargetStopLoss || PROFIT_BUY>=TargetTakeProfit) // if the profit
                  if(FreezeStopsLevels(level))
                     ClosePositions(POSITION_TYPE_BUY,level);
              }
            else
               if(m_position.PositionType()==POSITION_TYPE_SELL)
                 {
                  PROFIT_SELL=PROFIT_SELL+PositionGetDouble(POSITION_PROFIT);
                  if(PROFIT_SELL<-TargetStopLoss || PROFIT_SELL>=TargetTakeProfit) // if the profit
                     if(FreezeStopsLevels(level))
                        ClosePositions(POSITION_TYPE_SELL,level);
                 }
            res=true;
           }
//--- result
   return(res);
  }
//+------------------------------------------------------------------+

[Alexsandr San]

Alexsandr San:

#propriété version "1.015"

Fixé(Profit & Perte) - on peut ouvrir plusieurs positions pour une paire de devises et il sera fermé sur le montant total, une position peut être rentable et une autre - négative, mais le montant total est égal au montant spécifié dans les paramètres.

----------------------

Voici une fonction(Profits et pertes)

J'ai essayé sur un compte réel, je voulais un petit profit sur deux positions ouvertes. Je l'avais réglé sur 160 et je pensais qu'il fermerait la plus grande position négative, mais il ne l'a pas fait.

Je pensais qu'il fermerait la plus grosse position perdante mais il ne l'a pas fait. Il a fermé celle qui avait 160 de profit et a fermé les deux positions et je suis un imbécile. Il s'avère que je dois calculer à partir de la première position ouverte, en ajoutant la position négative.

[Alexsandr San]

Alexsandr San:

#propriété version "1.015"

J'ai corrigé cette fonction(Profit & Perte) un peu - parce que sur une paire, vous pouvez ouvrir plusieurs positions, dans un sens - maintenant il va fermer sur le montant total, une position peut être dans le plus et l'autre dans le négatif, mais le montant total est égal au montant spécifié dans les paramètres.

----------------------

voici la fonction(Profit & Perte)

#propriété version "1.016"

J'ai essayé différentes méthodes, mais il semble que ce soit la seule. Si je fixe le montant en une fois, en ouvrant beaucoup de positions - il ferme le même montant.

Voici la fonction, un peu différemment

//+------------------------------------------------------------------+
//| Check for long position closing                                  |
//+------------------------------------------------------------------+
bool ProfitOnTick(void)
  {
   bool res=false;
   double level;
   double PROFIT_BUY=0.00;
   double PROFIT_SELL=0.00;
   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())
           {
            if(m_position.PositionType()==POSITION_TYPE_BUY)
              {
               PROFIT_BUY=PROFIT_BUY+m_position.Commission()+m_position.Swap()+m_position.Profit();
               if(PROFIT_BUY<-TargetStopLoss || PROFIT_BUY>=TargetTakeProfit) // if the profit
                  if(FreezeStopsLevels(level))
                     ClosePositions(POSITION_TYPE_BUY,level);
              }
            else
               if(m_position.PositionType()==POSITION_TYPE_SELL)
                 {
                  PROFIT_SELL=PROFIT_SELL+m_position.Commission()+m_position.Swap()+m_position.Profit();
                  if(PROFIT_SELL<-TargetStopLoss || PROFIT_SELL>=TargetTakeProfit) // if the profit
                     if(FreezeStopsLevels(level))
                        ClosePositions(POSITION_TYPE_SELL,level);
                 }
            res=true;
           }
//--- result
   return(res);
  }
//+------------------------------------------------------------------+

[Alexsandr San]

Alexsandr San:

#propriété version "1.016"

J'ai essayé toutes sortes de choses, mais c'est la seule façon dont ça devrait être. Si je fixe le montant en une fois, en ouvrant de nombreuses positions - il ferme exactement ce montant.

Voici une fonction, un peu différente

J'ai vérifié cette fonction dans le testeur - j'ai fixé un profit de 300, une perte de 10000. L'ouverture provient de l'indicateur (LeMan_BrainTrend1Sig) sur l'EURUSD H1 avec une balance de 100 levier 100 avec 0.01 lot

fonction Profit Perte en devise - BUY et SELL ont leur propre profit sur la même paire, (par exemple, siBUY a fait un profit, il fermera leurs positions, SELL ne fermera pas jusqu'à ce qu'il ait fait un profit)

[Alexsandr San]

Alexsandr San:

J'ai vérifié cette fonction dans le testeur - j'ai défini un profit de 300, une perte de 10000. L'ouverture a été effectuée en utilisant l'indicateur (LeMan_BrainTrend1Sig) sur EURUSD H1 avec un solde de 100, un effet de levier de 100 avec un lot de 0,01.

Fonction Profit Perte en devise - BUY et SELL ont leur propre profit sur une paire, (par exemple, siBUY a fait un profit, il fermera leurs positions, SELL ne fermera pas, jusqu'à ce qu'ils atteignent leur propre profit)

Une fonction supplémentaire a été ajoutée. J'ai juste besoin de le vérifier en temps réel dans le terminal.

input  int     limit_total_symbol           = 3;                 // Кол-во Позиции при Убытке
input double   TargetOpenLot                = 1000000;           // Убыток на Позиции Открыть Позицию

Cette version est comme ceci - Dans le Testeur

//+------------------------------------------------------------------+
//| Check for long position closing                                  |
//+------------------------------------------------------------------+
bool OpenLotBuy(void)
  {
   bool res=false;
   double PROFIT_BUY=0.00;
   CloseTikB=iClose(NULL,Period(),0);
   OpenTikB=iOpen(NULL,Period(),0);
//---
   int total=PositionsTotal(); // количество открытых позиций
   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())
           {
            if(total>0)
              {
               ulong position_ticket=PositionGetTicket(total-1); // тикет позиции
              }
            if(total<limit_total_symbol)// количество открытых позиций
              {
               if(OpenTikB<CloseTikB)
                 {
                  if(m_position.PositionType()==POSITION_TYPE_BUY)
                    {
                     PROFIT_BUY=PROFIT_BUY+m_position.Commission()+m_position.Swap()+m_position.Profit();
                     if(PROFIT_BUY<-TargetOpenLot)
                        ExtNeedOpenBuy=true;
                     if(LongObjOpened())
                        return(res);
                    }
                  res=true;
                 }
              }
           }
//--- result
   return(res);
  }
//+------------------------------------------------------------------+
//| Check for long position closing                                  |
//+------------------------------------------------------------------+
bool OpenLotSell(void)
  {
   bool res=false;
   double PROFIT_SELL=0.00;
   CloseTikS=iClose(NULL,Period(),0);
   OpenTikS=iOpen(NULL,Period(),0);
//---
   int total=PositionsTotal(); // количество открытых позиций
   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())
           {
            if(total>0)
              {
               ulong position_ticket=PositionGetTicket(total-1); // тикет позиции
              }
            if(total<limit_total_symbol)// количество открытых позиций
              {
               if(OpenTikS>CloseTikS)
                 {
                  if(m_position.PositionType()==POSITION_TYPE_SELL)
                    {
                     PROFIT_SELL=PROFIT_SELL+m_position.Commission()+m_position.Swap()+m_position.Profit();
                     if(PROFIT_SELL<-TargetOpenLot)
                        ExtNeedOpenSell=true;
                     if(ShortObjOpened())
                        return(res);
                    }
                  res=true;
                 }
              }
           }
//--- result
   return(res);
  }
//+------------------------------------------------------------------+