Wie ich meinen Berater durch Versuch und Irrtum zusammenstelle - Seite 53

[Alexsandr San]

Alexsandr San:

#Eigenschaft Version "1.012"

Geringfügige Verbesserung der Funktion

Wenn die horizontale Linie VERKAUFEN ausgelöst wird, wird eine Position eröffnet und eine horizontale Linie KAUFEN angezeigt und umgekehrt.

Außerdem wird die Linie entweder ab "0" gesetzt und der Abstand wirddurch Obj: Trailing Step MACD

oder ab der horizontalen Linie"LOW".

FromTimer "LOW Up" "LOW Down" gleich, nurder Abstand wird gesetzt (input ushort InpObjTrailingStepCS = 5;// Obj: Trailing Step, in Pips (1.00045-1.00055=1 Pips)

Wie man den Abstand der horizontalen Linie in den IndikatorLow_Macd_Line.mq5 wissen, um in der Spur (auf jedem Paar, einen anderen Abstand) gesetzt

Kopieren und Einfügen der Einstellungen des Dienstprogramms

im Bild von "0" bis Horizontal BUY 0.0064 und wenn es Horizontal LOW berührt, wird Horizontal SELL gesetzt (nur unter"0"-0.0064)

WICHTIG!!! Setzen Sie kein Minus ( - ) vor die Zahlen, die wir im Dienstprogramm eingeben.

Eine der Varianten, wie diese Funktion funktioniert

Die Funktion Gewinn und Verlust wurde geändert #Eigenschaft 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)

schließt und löscht alles und ändert alle offenen Fenster in das angegebene Muster

[Alexsandr San]

Die Funktion öffnet eine Position, aus Gewinn oder Verlust

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

Ich habe in UtilityCommand.mq5 einen Assistenzindikator erstellt, Linien bewegen sich und es ist möglich, Befehle von ihnen zu setzen. Ich habe es mitSEM

Ich fand https://www.mql5.com/ru/code/16269 Es stellt sich heraus, ein mt4-Skript Ich danke dem AutorAlexey Volchanskiy.

[Alexsandr San]

Alexsandr San:

Ich suchte https://www.mql5.com/ru/code/16269 Es stellt sich heraus, dieses Skript von mt4 Dank an den AutorAlexey Volchanskiy!

Es gibt ein Skript nicht nur für mt4 sondern auch für mt5https://www.mql5.com/ru/code/16262 Ich habe es im Indicator gemeistert.Ich danke dem AutorAlexey Volchanskiy!

[Alexsandr San]

Alexsandr San:

Die Funktion Gewinn und Verlust wurde geändert #Eigenschaft Version "1.013"

Bei Erreichen dieses Ziels wird alles geschlossen und gelöscht, und alle offenen Fenster werden auf das angegebene Muster umgestellt.

#Eigenschaft Version "1.014"

Dennoch ist Profit from Balance eine notwendige Funktion - wenn ein Expert Advisor auf mehreren Paaren arbeitet.

hat Gewinn und Verlust neu gestaltet, um ein bestimmtes Paar zu schließen, ohne andere Paare zu beeinflussen

//+------------------------------------------------------------------+
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;           // Убыток на паре в валюте

Gewinn und Verlust, schreiben Sie den Betrag (z.B. 1 Einheit Ihrer Währung) in die Einstellung 1000000 - bis eine MillionIhrerWährung genommen wird, wird die Position nicht geschlossen

[Alexsandr San]

Alexsandr San:

#Eigenschaft Version "1.014"

Dennoch ist "Profit from Balance" eine notwendige Funktion, wenn ein Expert Advisor mit mehreren Paaren arbeitet.

Die Gewinn- und Verlustrechnung wurde so umgestaltet, dass sie nur für dieses Paar gilt und andere Paare nicht beeinflusst.

DieP&L-Funktion setzt den Betrag (z.B. 1 Einheit Ihrer Währung) auf 1000000 - sie schließt die Position erst, wenn sie eine MillionIhrer Währung nimmt.

#Eigenschaft Version "1.015"

ein wenig behoben, diese Funktion(Gewinn und Verlust) - weil auf einem Paar, können Sie mehrere Positionen zu öffnen, ein Weg - jetzt wird der Gesamtbetrag zu schließen, kann eine Position im Plus und die andere in den negativen, aber der Gesamtbetrag ist gleich dem angegebenen Betrag in den Einstellungen.

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

hier ist eine Funktion(Gewinn und Verlust)

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

#Eigenschaft Version "1.015"

Fixed it(Profit & Loss) - man kann mehrere Positionen für ein Währungspaar eröffnen und es wird auf den Gesamtbetrag geschlossen, eine Position kann profitabel sein und eine andere - negativ, aber der Gesamtbetrag ist gleich dem in den Einstellungen angegebenen Betrag.

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

Hier ist eine Funktion(Gewinn und Verlust)

Ich habe es auf einem echten Konto ausprobiert, ich wollte einen kleinen Gewinn aus zwei eröffneten Positionen erzielen. Ich hatte ihn auf 160 eingestellt und dachte, er würde die größte Minusposition schließen, aber das tat er nicht.

Ich dachte, er würde die größte Verlustposition schließen, aber das tat er nicht. Er schloss die Position, die 160 Gewinn brachte, und schloss beide Positionen, und ich bin ein Trottel. Es stellt sich heraus, dass ich von der ersten offenen Position ausgehen muss, indem ich die Minusposition hinzufüge

[Alexsandr San]

Alexsandr San:

#Eigenschaft Version "1.015"

Fixed it(Profit & Loss) - man kann mehrere Positionen für ein Währungspaar eröffnen und es wird auf den Gesamtbetrag geschlossen, eine Position kann profitabel sein und eine andere - negativ, aber der Gesamtbetrag ist gleich dem in den Einstellungen angegebenen Betrag.

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

hier ist die Funktion(Gewinn und Verlust)

#Eigenschaft Version "1.016"

Ich habe verschiedene Möglichkeiten ausprobiert, aber das scheint die einzige Möglichkeit zu sein. Wenn ich den Betrag auf einmal eingestellt, eröffnet eine Menge von Positionen - es schließt den gleichen Betrag.

Hier ist die Funktion, ein wenig anders

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

#Eigenschaft Version "1.016"

Ich habe alles Mögliche ausprobiert, aber das ist der einzige Weg, wie es sein sollte. Wenn ich den Betrag auf einmal festgelegt, eröffnet viele Positionen - es schließt genau diesen Betrag.

Hier ist eine etwas andere Funktion

Ich habe diese Funktion im Tester überprüft - ich habe einen Gewinn von 300 und einen Verlust von 10000 eingestellt. Die Eröffnung erfolgte durch den Indikator (LeMan_BrainTrend1Sig) auf dem EURUSD H1 mit einem Saldo von 100 leverage 100 mit 0.01 lot

Funktion Gewinn-Verlust in der Währung - KAUFEN und VERKAUFEN haben ihren eigenen Gewinn auf dem gleichen Paar, (zum Beispiel, wennKAUFEN einen Gewinn gemacht hat, wird es ihre Positionen zu schließen, wird SELL nicht schließen, bis es einen Gewinn gemacht hat)

[Alexsandr San]

Alexsandr San:

Ich habe diese Funktion im Tester überprüft - ich habe Gewinn 300, Verlust 10000 eingestellt. Die Eröffnung wurde mit dem Indikator (LeMan_BrainTrend1Sig) auf EURUSD H1 mit Balance 100, Leverage 100 mit 0.01 Lot durchgeführt

Funktion Gewinn-Verlust in der Währung - KAUF und VERKAUF haben ihren eigenen Gewinn auf dem gleichen Paar, (zum Beispiel, wennKAUF einen Gewinn gemacht hat, wird es ihre Positionen zu schließen, SELL wird nicht schließen, bis sie ihren eigenen Gewinn zu erreichen)

Es wurde eine weitere Funktion hinzugefügt. Ich muss es nur in Echtzeit im Terminal überprüfen.

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

Diese Version sieht folgendermaßen aus - Im Tester

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