Como eu monto meu conselheiro por tentativa e erro - página 53

[Alexsandr San]

Alexsandr San:

#propriedade versão "1.012

Melhorou um pouco a função

quando acionada, a linha Horizontal SELL abre uma posição e exibe uma linha Horizontal BUY e vice versa.

Além disso, a linha é definida a partir de "0" e a distância é definidapelo Obj: Trailing Step MACD

ou da linha horizontal"LOW".

DeTimer "LOW Up" "LOW Down" mesmo, apenasa distância é definida (entrada ushort InpObjTrailingStepCS = 5;// Objeto: Trailing Step, em pips (1.00045-1.00055=1 pips)

Como saber a distância da linha horizontal no indicadorLow_Macd_Line.mq5 para definir na trilha (em cada par, uma distância diferente)

Copiar e colar nas configurações de Utilitários

na figura de "0" para Horizontal BUY 0.0064 e quando tocar Horizontal LOW, a VENDA Horizontal será definida (apenas abaixo de"0"-0.0064)

IMPORTANTE!! Não coloque menos ( - ) na frente dos números, que nós digitamos na utilidade.

Uma das Variantes, como funciona esta função

Mudou a função de Lucro e Perda #propriedade versão "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)

se alcançado, irá fechar e apagar tudo, e mudará todas as janelas abertas para o padrão especificado

[Alexsandr San]

A função abre uma posição, a partir do Lucro ou Perda

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

Eu fiz um indicador assistente nocomando UtilityCommand.mq5, as linhas estão em movimento e é possível definir comandos a partir delas. Eu o construí comSEM

Encontrei https://www.mql5.com/ru/code/16269. Acontece que é um roteiro mt4 que agradeço ao autorAlexey Volchanskiy.

[Alexsandr San]

Alexsandr San:

Eu pesquisei https://www.mql5.com/ru/code/16269 Acontece este roteiro do mt4 Graças ao autorAlexey Volchanskiy!

Há um roteiro não só para o mt4, mas também para o mt5https://www.mql5.com/ru/code/16262 que dominei no Indicador.Agradeço ao autorAlexey Volchanskiy!

[Alexsandr San]

Alexsandr San:

Mudou a função de Lucro e Perda #propriedade versão "1.013"

quando alcançado, fechará e excluirá tudo, e mudará todas as janelas abertas para o padrão especificado

#propriedade versão "1.014

Ainda assim, o Lucro do Saldo é uma característica necessária - quando um Expert Advisor, trabalha em vários pares.

redesenhou os Lucros e Perdas para fechar em um determinado par sem afetar outros pares

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

Lucros e perdas, escreva o valor (por exemplo 1 unidade de sua moeda) no cenário 1000000 - até que seja necessário um milhão desuamoeda, ela não fechará a posição

[Alexsandr San]

Alexsandr San:

#propriedade versão "1.014

Ainda assim, o Lucro do Saldo é uma característica necessária - quando um Expert Advisor trabalha em vários pares.

redesenhado Lucros e Perdas para fechar este par e não afetar outros pares

Afunção P&L define o valor (por exemplo, 1 unidade de sua moeda) para 1000000 - não fecha a posição até que tome um milhão dasua moeda

#propriedade versão "1.015"

um pouco fixa, esta função(Lucro e Perda) - porque em um par, você pode abrir várias posições, de uma forma - agora fechará o valor total, uma posição pode estar no mais e a outra no negativo, mas o valor total é igual ao valor especificado nas configurações.

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

aqui está uma função(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:

#propriedade versão "1.015"

Fixado(Lucro & Perda) - pode-se abrir várias posições para um par de moedas e ele fechará sobre o valor total, uma posição pode ser lucrativa e outra - negativa, mas o valor total é igual ao valor especificado em configurações.

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

Aqui está uma função(Lucro e Perda)

Eu tentei em uma conta real, eu queria um pequeno lucro de duas posições abertas. Eu a tinha fixado em 160 e pensei que fecharia a maior posição menos, mas não fechou.

Pensei que fecharia a maior posição perdedora, mas não fechou. Fechou a que obteve 160 de lucro e fechou ambas as posições e eu sou um otário. Acontece que tenho que calcular a partir da primeira posição aberta, adicionando a posição menos

[Alexsandr San]

Alexsandr San:

#propriedade versão "1.015

Fixou esta função(Lucro & Perda) um pouco- porque em um par, você pode abrir várias posições, de uma forma - agora fechará sobre o valor total, uma posição pode estar no mais e a outra no negativo, mas o valor total é igual ao valor especificado nas configurações.

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

aqui está a função(Lucro & Perda)

#propriedade versão "1.016"

Eu tentei de maneiras diferentes, mas parece ser a única maneira. Se eu definir imediatamente a quantia, abri muitas posições - fecha a quantia exata.

Aqui está a função, um pouco diferente

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

#propriedade versão "1.016"

Já tentei de todas as formas, mas é a única maneira de ser. Se eu fixar a quantia de uma vez, abri muitas posições - fecha exatamente essa quantia.

Aqui está uma função, um pouco diferente

Verifiquei esta função no testador - defini um lucro de 300, um prejuízo de 10000. A abertura veio do indicador (LeMan_BrainTrend1Sig) no EURUSD H1 com um saldo de 100 alavancagem 100 com lote 0,01

função Lucro Perda em moeda - COMPRAR e VENDER tem seu próprio lucro no mesmo par, (por exemplo, seCOMPRAR tiver feito lucro, fechará suas posições, VENDER não fechará até que tenha feito lucro)

[Alexsandr San]

Alexsandr San:

Verifiquei esta função no testador - defini lucro 300, perda 10000. A abertura foi realizada usando o indicador (LeMan_BrainTrend1Sig) no EURUSD H1 com saldo 100, alavancagem 100 com lote 0,01

Função Perda de lucro em moeda - COMPRAR e VENDER tem seu próprio lucro no mesmo par, (por exemplo, seCOMPRAR tiver feito lucro, fechará suas posições, VENDER não fechará, até que atinjam seu próprio lucro)

Uma função a mais foi acrescentada. Só preciso verificá-lo em tempo real no terminal.

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

Esta versão é como esta - No Testador

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