Надеюсь, что вы помогли мне с кодированием индикатора в советник - MQL4 и MetaTrader 4

traderduke 2016.10.14 12:20 #6921

mladen:

Рэй

Попробуйте сейчас

Младен

По-прежнему никаких изменений. Можем ли мы попробовать еще раз?

Это все, что я сделал для 2MA;

double fastMA = iMA(NULL,0,FastMa,FastMaShift,FastMaMethod,FastMaPrice,i);
double slowMA = iMA(NULL,0,SlowMa,SlowMaShift,SlowMaMethod,SlowMaPrice,i);

UpH[i] = EMPTY_VALUE;
DnH[i] = EMPTY_VALUE;
trend[i] = trend[i+1];

double diffu = (fastMA - slowMA);

double diffd = (slowMA - fastMA);

если (diffu > diff_Level ) trend[i] = 1;
if (diffd > diff_Level ) trend[i] = -1;

Спасибо

Луч

вопрос по советнику Запрет торговли в одном Любой вопрос новичка, чтоб

Mladen Rakic 2016.10.14 12:30 #6922

traderduke:

Младен

По-прежнему никаких изменений. Можем ли мы попробовать еще раз?

Это все, что я сделал для 2MA;

double fastMA = iMA(NULL,0,FastMa,FastMaShift,FastMaMethod,FastMaPrice,i);
double slowMA = iMA(NULL,0,SlowMa,SlowMaShift,SlowMaMethod,SlowMaPrice,i);

UpH[i] = EMPTY_VALUE;
DnH[i] = EMPTY_VALUE;
trend[i] = trend[i+1];

double diffu = (fastMA - slowMA);

double diffd = (slowMA - fastMA);

если (diffu > diff_Level ) trend[i] = 1;
if (diffd > diff_Level ) trend[i] = -1;

Спасибо

Луч

Вот что я получаю, когда пробую режим мультитаймфрейма (индикатор из сообщения выше).

Насколько я вижу, все работает так, как и должно работать

traderduke 2016.10.14 15:54 #6923

mladen:

Вот что я получаю, когда пробую режим мультитаймфрейма (индикатор из поста выше).

ВНИМАНИЕ: Видео должно быть перезагружено

Насколько я вижу, все работает так, как и должно работать

Mladen

Я прошу прощения за то, что не представил свою проблему с ясностью. Вы правы в том, что diff_Levelms 0.0 работает правильно, но добавление diff_Levelms было сделано для того, чтобы позволить незначительным изменениям, таким как диапазон, быть отброшенными, например, .0002 для EURUSD или .02 для USDJPY. Очевидно, мой расчет diff не используется расчетом trend1.

double diffums = (ma2[i]-ma3[i]); //med-slow Видимо мой расчет
double diffdms = (ma3[i]-ma2[i]);//slow - med Видимо, мой расчет

если (ma1[i]>ma2[i]) trendfm[i] =1;
если (ma1[i]<ma2[i]) trendfm[i] =-1;
если (ma1[i]>ma3[i]) trendfs[i] =1;
если (ma1[i]<ma3[i]) trendfs[i] =-1;
if (ma2[i]>ma3[i] && diffums > diff_Levelms) trendms[i] =1; не используется для расчета тренда1
if (ma2[i]<ma3[i] && diffdms > diff_Levelms) trendms[i] =-1; не используется при расчете тренда1

Спасибо

ray

Динамическая сетка Фибоначчи, валютная Элитные показатели :) Помогите перейти на MetaTrader

peter22 2016.10.14 21:11 #6924

индикатор не обновляется

Я скачал прилагаемый индикатор "Outsidebar Trendline V2", но по какой-то причине он не обновляется на

следующем баре/свече. При переключении таймфреймов он работает хорошо, но на следующем баре на этом таймфрейме уже нет.

Не мог бы кто-нибудь из ваших экспертов помочь, чтобы индикатор обновлялся и на следующих барах?

Большое спасибо

Lea

Файлы:

OutsideBar TrendLine v2.mq4 28 kb

Скользящая средняя Элитные показатели :) EA для BBands_stop_v1

[Удален] 2016.10.15 07:09 #6925

mladen,

Мой друг написал этот советник на основе индикатора vertex, мы не смогли запустить бэктест после того, как он его создал. Пожалуйста, не могли бы вы помочь мне исправить ошибку, из-за которой он не может провести бэктест. но он требует много обновлений, как только он будет очищен.

Спасибо и смиренно благодарю

// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
#include <stdlib.mqh>
#include <stderror.mqh> 



#property copyright "reddevil"
#property link ""
#property version "3.0";
// 19-09 minimum of 4 periods before the next order.
// v1.2 check alternate timeframe for spike
// v2.0 uses 3.01a indicator with alternate timeframe
//v3.0 red crossing blue as entry
// trailing after line cross
// ------------------------------------------------------------------------------------------------
// VARIABLES EXTERNAS
// ------------------------------------------------------------------------------------------------
//
// check for candle 

extern int magic = 668899;
 string progName="VertexPro3";
 string key = "vertex 3.0";
// Configuration

extern string CommonSettings = "---------------------------------------------";
extern int user_slippage = 2; 
extern double max_spread = 3.0;
extern int user_tp = 0; // min TP
extern int user_sl = 50; // max SL
//extern int AlternateTF = 30 ; // 30 mins
extern double Entry_line =10; // 10 sell, -10 buy
// extern double Entry_pips = 10; // from highest high or lowest low
extern string TakeProfit_trigger ="------------------------------------------";
extern int TPdefault_line =25;
extern double BBvalue1 =10.0;
extern int BBTP_line =15;

//extern bool DailyFilter=true;
extern bool NewsFilter=false;
extern int MinsBeforeNews=1440;
extern int MinsAfterNews=60;
extern int maxOrders=3; //max 3
extern string Trailing = "----------------------------------------------------";
extern int UseTrailing=2 ; // 0 - no trailing, 1- normal; 2-trail after TP line

extern int TrailStartPips=8;
extern int Trailpips=5;
extern int TrailStepPips=3;
extern string MoneyManagementSettings = "---------------------------------------------";
// Money Management
extern bool money_management = false;
extern double min_lots = 0.1;
extern int risk=1;
extern int progression = 0; // 0=none | 1:ascending | 2:martingale


extern int GMToffset=2;
int arrLgt=3;
int buy_magic[3];
int sell_magic[3];
int buy_tickets[3];
int sell_tickets[3];
// Lots
double buy_lots[3];
double sell_lots[3];
// Current Profit
double buy_profit[3];
double sell_profit[3];
//SL
double sell_sl[3];
double buy_sl[3];
//TP
double sell_tp[3];
double buy_tp[3];
// Open Price
double buy_price[3];
double sell_price[3];

datetime buy_time; // last buytime
datetime sell_time;
// Indicator
double rsi=0;
// Number of orders
int buys = 0;
int sells = 0;
double total_buy_profit=0,total_sell_profit=0;
double total_buy_lots=0, total_sell_lots=0;
double buy_max_profit=0, buy_close_profit=0;
double sell_max_profit=0, sell_close_profit=0;
// Indicator


// ------------------------------------------------------------------------------------------------
// VARIABLES GLOBALES
// ------------------------------------------------------------------------------------------------



// indicadores

// Cantidad de ordenes;
int orders = 0;
int direction= 0;
double max_profit=0, close_profit=0;
double last_order_profit=0, last_order_lots=0;
// Colores
color c=Black;
// Cuenta
double balance, equity;
int slippage=0;
// OrderReliable




int OldHist=0;
double SL,PT,_spread;
int newMagic1,newMagic2;
int curMagic;
int Tframe = PERIOD_H1;
datetime  OldTime;
int _DSTtime=0;
int pendingTicket=-1;
bool NoNews=true;
int mBefore, mAfter;

// ------------------------------------------------------------------------------------------------
// START
//
void init()
{
    if (Digits==4 || Digits==2)
  {
    slippage = user_slippage;
    PT=Point;
  }
  else if (Digits==5 || Digits==3)
  {
      slippage = 10*user_slippage;
      PT=Point*10;
  }
  
        
 
  if(maxOrders > 3)  maxOrders=3;
  
      
  newMagic1 = StrToInteger(IntegerToString(TPdefault_line) + IntegerToString(magic));
  newMagic2 = StrToInteger(IntegerToString(BBTP_line) + IntegerToString(magic)); 
}
int start()
{  
  double point = MarketInfo(Symbol(), MODE_POINT);
  double dd=0;
  
  string DST = "Yes";
  
  bool  encontrada;
  balance=AccountBalance();
  equity=AccountEquity();
  
  if(TimeCurrent() - OldTime > 25)
      {
         RefreshRates();
         OldTime=TimeCurrent();
      }

  _spread =  NormalizeDouble(MathAbs(Ask-Bid)/PT,2);
  
  if(IsTradeAllowed() == false) 
  {
    Comment("nTrade not allowed.");
    return(0);  
  }
  /*if(StringLen(DoubleToStr(TPdefault_line)) > 3 || StringLen(DoubleToStr(BBTP_line)) > 3)
  {
       Comment("nTPdefault or BBTP too long");
       return(1);
  } */
  if(BBTP_line > TPdefault_line)
   {
      Comment("nBBTP must be less than TPdefault");
      return(1);
   }
  /*if(!IsTesting())
   if (Period() != Tframe) 
   {
      Comment("\n ERROR :: Invalid Timeframe, Please Switch to "+ IntegerToString(Tframe));
      return(0);
   } */
  if(TimeDaylightSavings()==0)
    {
      DST="No";
    }
   else _DSTtime=1;
   if(!IsTesting())
   {
     
       //Comment(StringConcatenate("\nLSMA02a is running.\nNext order lots: ",CalcularVolumen(),"\nTake profit ($): ",CalcularVolumen()*10*user_tp,"\nStop loss ($): ",CalcularVolumen()*10*user_sl,"\nSpread: ",_spread, "\nDST: ",DST));
         Comment(StringConcatenate("\n",progName," is running.\nNext order lots: ",CalcularVolumen(),
           
            "\nTake profit ($): ",CalcularVolumen()*10*user_tp,
            "\nStop loss ($): ",CalcularVolumen()*10*user_sl,
            "\nSpread: ",_spread, 
            "\nDST: ",DST,
            "\nMax Orders: ",maxOrders,
           // "\nDailyFilter ",DailyFilter,
            "\nNewsFilter: ",NewsFilter,
            "\nMins Before News: ",mBefore,
            "\nMins After News: ",mAfter));
          
  }
  // Actualizamos el estado actual
  InitBuy();
  InitSell();
  UpdateVars();
 
  
  encontrada=FALSE;
  
  
  point = Point;

  Robot();
  
  return(0);
}
void InitBuy()
{
  // Reset number of buy/sell orders
  buys=0;
  
  // Reset arrays
  for(int i=0; i<arrLgt; i++)
  {
    buy_tickets[i] = 0;
    buy_lots[i] = 0;
    buy_profit[i] = 0;
    buy_price[i] = 0;
    buy_sl[i]=0;
    buy_tp[i]=0;
    buy_magic[i]=0;
    
   
      
  }
}
void InitSell()
{
  // Reset number of buy/sell orders
 
  sells=0;
  // Reset arrays
  for(int i=0; i<arrLgt; i++)
  {
   
    sell_tickets[i] = 0;
    sell_lots[i] = 0;
    sell_profit[i] = 0;
    sell_price[i] = 0;
    sell_sl[i]=0;
    sell_tp[i]=0;
    sell_magic[i]=0;
      
  }
}
void UpdateVars()
{
  int aux_buys=0, aux_sells=0;
  double aux_total_buy_profit=0, aux_total_sell_profit=0;
  double aux_total_buy_lots=0, aux_total_sell_lots=0;
  buy_time=0;
  sell_time=0;
  datetime oTime;
  // We are going to introduce data from opened orders in arrays  
  for(int i=0; i<OrdersTotal(); i++)
  {
    if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES) == true)
     if(OrderSymbol() == Symbol() && (OrderMagicNumber() == newMagic1 ||OrderMagicNumber() == newMagic2)   )
      {
         if( OrderType() == OP_BUY)
         {
           buy_tickets[aux_buys] = OrderTicket();
           buy_lots[aux_buys] = OrderLots();
           buy_profit[aux_buys] = OrderProfit()+OrderCommission()+OrderSwap();
           buy_price[aux_buys] = OrderOpenPrice();
           buy_sl[aux_buys] = OrderStopLoss();
           buy_tp[aux_buys] = OrderTakeProfit();
           aux_total_buy_profit = aux_total_buy_profit + buy_profit[aux_buys];
           aux_total_buy_lots = aux_total_buy_lots + OrderLots();
           oTime =OrderOpenTime();
           buy_magic[aux_buys]=OrderMagicNumber();
           if(oTime > buy_time)
               buy_time = oTime;
           
            aux_buys++;
         }
        else if( OrderType() == OP_SELL)
         {
           sell_tickets[aux_sells] = OrderTicket();
           sell_lots[aux_sells] = OrderLots();
           sell_profit[aux_sells] = OrderProfit()+OrderCommission()+OrderSwap();
           sell_price[aux_sells] = OrderOpenPrice();
           sell_sl[aux_sells] = OrderStopLoss();
           sell_tp[aux_sells] = OrderTakeProfit();
           aux_total_sell_profit = aux_total_sell_profit + sell_profit[aux_sells];
           aux_total_sell_lots = aux_total_sell_lots + OrderLots();
            oTime =OrderOpenTime();
            sell_magic[aux_sells]=OrderMagicNumber();
            if(oTime > sell_time)
               sell_time = oTime;
           aux_sells++;
         }
    }
  }
  
  // Update global vars
  buys = aux_buys;
  sells = aux_sells;
  total_buy_profit = aux_total_buy_profit;
  total_sell_profit = aux_total_sell_profit;
  total_buy_lots = aux_total_buy_lots;
  total_sell_lots = aux_total_sell_lots;
}

ICWR в качестве эксперта? Элитные показатели :) Торговая система "Математика Мурри

[Удален] 2016.10.15 07:10 #6926

А это продолжение

 // ------------------------------------------------------------------------------------------------
// INICIALIZAR VARIABLES
// ------------------------------------------------------------------------------------------------


// ------------------------------------------------------------------------------------------------
// ACTUALIZAR ORDENES
// ------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------
// CALCULAR VOLUMEN
// ------------------------------------------------------------------------------------------------
double CalcularVolumen()
{ 
   double aux= 0 ; 
   int n;
  
   if (money_management== 0 )
  {
    aux=min_lots;
  }
   else
  {    
     if (progression== 0 ) 
    { 
      aux = risk* AccountFreeMargin ();
      aux= aux/ 100000 ;
      n = ( int ) MathFloor (aux/min_lots);
      
      aux = n*min_lots;                   
    }  
  
     if (progression== 1 )
    {
       if (last_order_profit< 0 )
      {
        aux = last_order_lots+min_lots;
      }
       else 
      {
        aux = last_order_lots-min_lots;
      }  
    }        
    
     if (progression== 2 )
    {
       if (last_order_profit< 0 )
      {
        aux = last_order_lots* 2 ;
      }
       else 
      {
         aux = risk* AccountFreeMargin ();
         aux= aux/ 100000 ;
         n = ( int ) MathFloor (aux/min_lots);
         
         aux = n*min_lots;         
      }  
    }     
    
     if (aux<min_lots)
        aux=min_lots;
     
     if (aux> MarketInfo ( Symbol (), MODE_MAXLOT ))
      aux= MarketInfo ( Symbol (), MODE_MAXLOT );
      
     if (aux< MarketInfo ( Symbol (), MODE_MINLOT ))
      aux= MarketInfo ( Symbol (), MODE_MINLOT );
  }
  
   return (aux);
}

// ------------------------------------------------------------------------------------------------
// CALCULA VALOR PIP
// ------------------------------------------------------------------------------------------------
double CalculaValorPip( double lotes)
{ 
   double aux_mm_valor= 0 ;
   
   double aux_mm_tick_value = MarketInfo ( Symbol (), MODE_TICKVALUE );
   double aux_mm_tick_size = MarketInfo ( Symbol (), MODE_TICKSIZE );
   int aux_mm_digits = ( int ) Digits ;   
   double aux_mm_veces_lots = 1 /lotes;
      
   if (aux_mm_digits== 5 )
   {
     aux_mm_valor=aux_mm_tick_value* 10 ;
   }
   else if (aux_mm_digits== 4 )
   {
     aux_mm_valor = aux_mm_tick_value;
   }
   
   if (aux_mm_digits== 3 )
   {
     aux_mm_valor=aux_mm_tick_value* 10 ;
   }
   else if (aux_mm_digits== 2 )
   {
     aux_mm_valor = aux_mm_tick_value;
   }
   
   aux_mm_valor = aux_mm_valor/aux_mm_veces_lots;
   
   return (aux_mm_valor);
}


// ------------------------------------------------------------------------------------------------
// CALCULA SIGNAL
// ------------------------------------------------------------------------------------------------


int CalculaSignal()
{
   int aux= 0 ;
 
   if ( MathAbs ( Bid - Ask )/PT > max_spread)
       return (aux);
   double v1 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 0 , 1 );
   double v2 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 0 , 2 );
   double v3 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 0 , 3 );
   double v4 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 0 , 4 );
   double b1 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 1 , 1 );
   double b2 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 1 , 2 );
  
      
   
   double bb;
   int stCount= 0 ;
  
  
   if (v2 > Entry_line && v2 > b2 && v1 < b1)
   {
      stCount= 2 ;
   
   }
   else if (v3 > Entry_line && (  v2 > b2 && v1 < b1) )
      {
      stCount= 3 ;
      
    }
 
   else if (v4 > Entry_line && (  v2 > b2 && v1 < b1) )
      stCount= 4 ;  
   if (stCount > 0 )
  {
     
         
               aux= 2 ;
              
               bb = iCustom ( NULL , 0 , "vertex_mod_3.01" , 2 ,stCount);
               if (bb > BBvalue1)
                  curMagic=newMagic2;
               else
                  curMagic=newMagic1;
               
            
      
  }
   else
  {
     
     if (v2 < Entry_line*(- 1 ) &&  v2 < b2 && v1 > b1)
       {
         stCount= 2 ;
         
       }
     else if (v3 < Entry_line*(- 1 ) &&  v2 < b2 && v1 > b1)
       {
         stCount= 3 ;
       }
     else if (v4 < Entry_line*(- 1 ) &&  v2 < b2 && v1 > b1)
         stCount= 4 ; 
         
         
     if (stCount > 0 )
      {
             
                  
              aux= 1 ;
              
               bb = iCustom ( NULL , 0 , "vertex_mod_3.01" , 3 ,stCount);
               if (bb < BBvalue1 *(- 1 ))
                  curMagic=newMagic2;
               else
                  curMagic=newMagic1;
           
                 
         
       }
   }
    
   
     
   
   return (aux);  
}

// ------------------------------------------------------------------------------------------------
// ROBOT
// ------------------------------------------------------------------------------------------------

void Robot()
{
   int ticket=- 1 ;
   int signal= 0 ;
   double newSL= 0 ;
   double newTP= 0 ;
   int tpvalue;
   double v1,v2;
   bool clOrder= false ;
   bool setTrail= false ;
 
   int i;
  

 
 
             if (NoNews || NewsFilter== False )
            {
                   ObjectDelete ( "NFP" );
                  
                  signal = CalculaSignal();
             }
             else
            {
                     ObjectCreate ( "NFP" , OBJ_LABEL , 0 , 0 , 0 , 0 , 0 );      
                     ObjectSet ( "NFP" , OBJPROP_CORNER , 2 );      
                     ObjectSet ( "NFP" , OBJPROP_YDISTANCE , 45 );      
                     ObjectSet ( "NFP" , OBJPROP_XDISTANCE , 10 );      
                     ObjectSetText ( "NFP" , "NO trade News time" , 20 , "Tahoma" , Red); 
            }
    
   
     if (signal== 1 && buys < maxOrders)
          
    {
           
           if (user_tp > 0 )
               newTP = NormalizeDouble ( Ask + user_tp*PT, Digits );
          
             SL = NormalizeDouble ( Ask - (user_sl*PT), Digits );
             ticket = OrderSend ( Symbol (), OP_BUY ,CalcularVolumen(), Ask ,slippage,SL,newTP,key,curMagic, 0 ,Blue);
       
    }
    
     if (signal== 2 && sells < maxOrders)
      {
             
         
           if (user_tp> 0 )
             newTP = NormalizeDouble ( Bid - user_tp*PT, Digits );
          
            SL = NormalizeDouble ( Bid + (user_sl*PT), Digits );
            ticket = OrderSend ( Symbol (), OP_SELL ,CalcularVolumen(), Bid ,slippage,SL,newTP,key,curMagic, 0 ,Red);
       
               
      
      } 
      
      
      v2 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 0 , 1 );
       if (buys > 0   )
      {
         if (v2 > Entry_line )
         {
            CloseOrder( OP_BUY );
         }
         else
          {
             if (UseTrailing == 2 || UseTrailing== 0 )
             {
                v1 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 3 , 1 );
                 if (v1 > (- 1 )*TPdefault_line/ 10 || v1 > (- 1 )*BBTP_line/ 10 )
                 {
                     setTrail= false ;
                     for (i= 0 ;i<buys;i++)
                      {
                        clOrder= false ;
                        tpvalue = StringToInteger ( StringSubstr (buy_magic[i], 0 , 2 ));
                         if (tpvalue == BBTP_line && v1 > (- 1 )* BBTP_line/ 10 )
                           clOrder= true ;
                         else if (tpvalue == TPdefault_line && v1 > (- 1 )* TPdefault_line/ 10 )
                            clOrder= true ;
                            
                         if (clOrder)
                         {
                           if (UseTrailing== 0 )
                           ticket = OrderClose (buy_tickets[i],buy_lots[i], Bid ,user_slippage, clrBlue );
                           else
                           {
                              trailProc( OP_BUY ,i);
                           }
                         }
                       }
                 }
             }      
               if (UseTrailing== 1 )
               {
                   for ( i= 0 ; i< buys; i++)
                  {
                    trailProc( OP_BUY ,i);
                  }
                  
               }
          }
      }
     else if (sells > 0 )
     {
   
         if (v2 < Entry_line*(- 1 ))
         {
            CloseOrder( OP_SELL );
         }
       else
       {
           
           if (UseTrailing == 2 || UseTrailing== 0 )
            {  
             v1 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 2 , 1 );
                 if (v1 < TPdefault_line/ 10 || v1 < BBTP_line/ 10 )
                 {
                     setTrail= false ;
                     for (i= 0 ;i<sells;i++)
                      {
                        clOrder= false ;
                        tpvalue = StringToInteger ( StringSubstr (sell_magic[i], 0 , 2 ));
                         if (tpvalue == BBTP_line && v1 < BBTP_line/ 10 )
                           clOrder= true ;
                         else if (tpvalue == TPdefault_line && v1 < TPdefault_line/ 10 )
                            clOrder= true ;
                            
                         if (clOrder)
                        {
                           if (UseTrailing== 0 )
                           ticket = OrderClose (sell_tickets[i],sell_lots[i], Bid ,user_slippage, clrRed );
                           else
                          {
                              trailProc( OP_SELL ,i);
                          
                          }
                        
                       }
                      }
                } 
             }
               if (UseTrailing == 1 ) 
              { 
                   for ( i= 0 ; i< sells; i++)
                  {
                    trailProc( OP_SELL ,i);
                  }
              }
         }
      }
            
        
             
        
  }
  
   void trailProc( int _type, int i)
  {
   double newSL= 0 ;
   int ticket;
   if (_type == OP_BUY )
    {
                   newSL= 0 ;
                     if ( Bid - buy_price[i] > TrailStartPips*PT)
                    {
                     if ( Bid - buy_sl[i] > (Trailpips + TrailStepPips)*PT && buy_sl[i] > buy_price[i])
                      {
                        newSL = NormalizeDouble ( Bid - Trailpips*PT, Digits );
                      }
                     else if (buy_sl[i] < buy_price[i])
                      {
                        newSL = NormalizeDouble ( Bid - Trailpips*PT, Digits );
                      }
                      
                       if (newSL > 0 && newSL > buy_sl[i])
                        ticket = OrderModify (buy_tickets[i],buy_price[i],newSL,buy_tp[i], 0 , clrBlue );
                   }
    }
   else
    {
                  newSL= 0 ;
                     if ( sell_price[i] - Ask > TrailStartPips*PT)
                    {
                     if ( sell_sl[i] - Ask > (Trailpips + TrailStepPips)*PT && sell_sl[i] > sell_price[i])
                      {
                        newSL = NormalizeDouble ( Ask + Trailpips*PT, Digits );
                      }
                     else if (sell_sl[i] < sell_price[i])
                      {
                        newSL = NormalizeDouble ( Ask + Trailpips*PT, Digits );
                      }
                      
                       if (newSL > 0 && newSL < sell_sl[i])
                        ticket = OrderModify (sell_tickets[i],sell_price[i],newSL,sell_tp[i], 0 , clrBlue );
                    }
    
    
    } 
  
  }
   void CloseOrder( int _type)
  {
     int resp;
     int i;
       if (_type== OP_BUY )
      {
         for ( i= 0 ; i< buys; i++)
         {
         
            resp= OrderClose (buy_tickets[i],buy_lots[i], Bid , 2 , clrBlue );
         }
         InitBuy();
         
      }
     else    if (_type== OP_SELL )
      {
         for ( i= 0 ; i< sells; i++)
         {
         
            resp= OrderClose (sell_tickets[i],sell_lots[i], Ask , 2 , clrRed );
         }
         InitSell();
         
      }           
  }

Mladen Rakic 2016.10.15 08:20 #6927

MECMAN:

А это продолжение

Пожалуйста, приложите файл mq4 - так пользователи не смогут легко протестировать его и не смогут помочь вам.

[Удален] 2016.10.15 08:36 #6928

ЭЙ, МЛАДЕН

Я новичок на этом сайте, и я вижу ваши хорошие работы, продолжайте в том же духе, брат. Однако я хотел бы, чтобы вы помогли мне с кодированием индикатора в советник.

Все, что мне действительно нужно, это чтобы советник покупал или продавал, когда появляется сигнал.

Идея заключается в том, чтобы перейти на более высокий таймфрейм, 4-часовой tf и найти тренд рынка (просто чтобы знать тренд) и торговать на более низком tf (15-5 минут). Таким образом, если рынок короткий, мы торгуем только до смены тренда на более высоком таймфрейме.

Заранее спасибо.

Файлы:

3D_Oscilator_Crossover_Signal_alert_email.ex4 16 kb

Индекс качества волатильности Стоимость предыдущего тика помощь эксперта

[Удален] 2016.10.16 03:18 #6929

mladen:
Пожалуйста, прикрепите файл mq4 - так пользователи не смогут легко проверить его и тогда они не смогут вам помочь.

Загружено, пожалуйста, может ли кто-нибудь посмотреть на этот код, чтобы знать, почему он не может обратно проверить, результаты могут быть не выгодными, но я буду благодарен.

Файлы:

VPro3.mq4 21 kb

Mladen Rakic 2016.10.16 08:28 #6930

MECMAN:
Загружено, пожалуйста, может ли кто-нибудь посмотреть на этот код, чтобы знать, почему он не может обратно протестировать, результаты могут быть не прибыльными, но я буду благодарен.

Он работает (при условии, что у вас есть индикатор "vertex_mod_3.01" в папке indicators).

Помощь в кодировании - страница 693