Cómo armo mi asesor por ensayo y error - página 53

[[Eliminado]]

Alexsandr San:

#versión de la propiedad "1.012"

Mejora ligeramente la función

cuando se activa, la línea horizontal VENTA abre una posición y muestra una línea horizontal COMPRA y viceversa.

Además, la línea se establece desde "0" y la distancia se establecepor Obj: Trailing Step MACD

o desde la línea horizontal"LOW".

FromTimer "LOW Up" "LOW Down" igual, sólose establece la distancia (input ushort InpObjTrailingStepCS = 5;// Obj: Trailing Step, en pips (1.00045-1.00055=1 pips)

Cómo saber la distancia de la línea horizontal en el indicadorLow_Macd_Line.mq5 para establecer en el rastro (en cada par, una distancia diferente)

Copiar y pegar en la configuración de la Utilidad

en la imagen de "0" a la COMPRA horizontal 0.0064 y cuando toque la BAJA horizontal, se pondrá la VENTA horizontal (sólo por debajo de"0"-0.0064)

IMPORTANTE!!! No poner menos ( - ) delante de las cifras, que escribimos en la utilidad.

Una de las variantes, cómo funciona esta función

Modificación de la función de pérdidas y ganancias #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)

si se alcanza, cerrará y borrará todo, y cambiará todas las ventanas abiertas al patrón especificado

[[Eliminado]]

La función abre una posición, desde Ganancias o Pérdidas

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

[[Eliminado]]

Alexsandr San:

He hecho un indicador de asistente en UtilityCommand.mq5, las líneas se mueven y es posible establecer comandos desde ellas. Lo construí conSEM

Encontré https://www.mql5.com/ru/code/16269 Resulta ser un script mt4 Agradezco al autorAlexey Volchanskiy.

[[Eliminado]]

Alexsandr San:

He buscado en https://www.mql5.com/ru/code/16269 Resulta que este script de mt4 ¡Gracias al autorAlexey Volchanskiy!

Hay una secuencia de comandos no sólo para mt4, sino también para mt5https://www.mql5.com/ru/code/16262 lo he dominado en el Indicador.Agradezco al autorAlexey Volchanskiy!

[[Eliminado]]

Alexsandr San:

Modificación de la función de pérdidas y ganancias #property version "1.013"

cuando se alcance, cerrará y borrará todo, y cambiará todas las ventanas abiertas al patrón especificado

#versión de la propiedad "1.014"

Aún así, el Beneficio del Balance es una característica necesaria - cuando un Asesor Experto, trabaja en varios pares.

ha rediseñado Ganancias y Pérdidas para cerrar en un par determinado sin afectar a otros 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;           // Убыток на паре в валюте

Ganancias y Pérdidas, escriba la cantidad (por ejemplo 1 unidad de su moneda) en el ajuste 1000000 - hasta que no tome un millón desumoneda, no cerrará la posición

[[Eliminado]]

Alexsandr San:

#versión de la propiedad "1.014"

Aún así, el Beneficio del Balance es una característica necesaria - cuando un Asesor Experto trabaja en varios pares.

rediseñado Ganancias y Pérdidas para cerrar en este par y no afectar a otros pares

Lafunción P&L establece la cantidad (por ejemplo, 1 unidad de su moneda) a 1000000 - no cierra la posición hasta que toma un millón desu moneda

#versión de la propiedad "1.015"

un poco fijo, esta función(Ganancias y Pérdidas) - porque en un par, puede abrir varias posiciones, una manera - ahora se cerrará la cantidad total, una posición puede estar en el más y el otro en el negativo, pero la cantidad total es igual a la cantidad especificada en la configuración.

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

aquí hay una función(Ganancias y Pérdidas)

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

[[Eliminado]]

Alexsandr San:

#versión de la propiedad "1.015"

Fijo(Profit & Loss) - uno puede abrir varias posiciones para un par de divisas y se cerrará en la cantidad total, una posición puede ser rentable y otra - negativa, pero la cantidad total es igual a la cantidad especificada en la configuración.

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

Esta es una función(Ganancias y Pérdidas)

Lo probé en una cuenta real, quería un pequeño beneficio de dos posiciones abiertas, lo había puesto a 160 y pensé que cerraría la posición más grande de menos, pero no lo hizo.

Pensé que cerraría la posición más perdedora pero no lo hizo, cerró la que obtuvo 160 de beneficio y cerró las dos posiciones y yo soy un pringado. Resulta que tengo que calcular a partir de la primera posición abierta, añadiendo la posición negativa

[[Eliminado]]

Alexsandr San:

#versión de la propiedad "1.015"

Corregido un poco esta función(Profit & Loss) - porque en un par, puede abrir varias posiciones, de una manera - ahora se cerrará en la cantidad total, una posición puede estar en el plus y la otra en el negativo, pero la cantidad total es igual a la cantidad especificada en la configuración.

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

esta es la función(Ganancias y Pérdidas)

#versión de la propiedad "1.016"

He probado diferentes formas pero parece que es la única manera. Si inmediatamente establezco la cantidad, abrí un montón de posiciones - cierra la cantidad exacta.

Esta es la función, un poco 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);
  }
//+------------------------------------------------------------------+

[[Eliminado]]

Alexsandr San:

#versión de la propiedad "1.016"

He intentado todo tipo de cosas, pero es la única manera que debe ser. Si establezco la cantidad de una vez, abrió muchas posiciones - se cierra exactamente esa cantidad.

Aquí hay una función, un poco diferente

He comprobado esta función en el probador - he establecido un beneficio de 300, una pérdida de 10000. La apertura vino del indicador (LeMan_BrainTrend1Sig) en el EURUSD H1 con un balance de 100 apalancamiento 100 con 0.01 lote

función Beneficio Pérdida en moneda - la COMPRA y la VENTA tienen su propio beneficio en el mismo par, (por ejemplo, sila COMPRA ha obtenido un beneficio, cerrará sus posiciones, la VENTA no cerrará hasta que haya obtenido un beneficio)

[[Eliminado]]

Alexsandr San:

He comprobado esta función en el probador - he establecido el beneficio 300, la pérdida 10000. La apertura se realizó utilizando el indicador (LeMan_BrainTrend1Sig) en EURUSD H1 con el balance 100, el apalancamiento 100 con 0.01 lote

Función Beneficio Pérdida en divisas - la COMPRA y la VENTA tienen su propio beneficio en el mismo par, (por ejemplo, sila COMPRA ha obtenido un beneficio, cerrará sus posiciones, la VENTA no cerrará, hasta que alcance su propio beneficio)

Se ha añadido una función más. Sólo tengo que comprobarlo en tiempo real en el terminal.

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

Esta versión es así - En el probador

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