Kodlama yardımı - sayfa 693

Yeni yorum
 
mladen :

Işın

şimdi dene

Mladen

Hala bir değişiklik yok. Tekrar deneyebilir miyiz?

2MA için yaptığım tek şey bu;

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] = BOŞ_DEĞER;
trend[i] = trend[i+1];

çift diffu = (fastMA - slowMA);

çift fark = (slowMA - fastMA);

if (diffu > diff_Level ) trend[i] = 1;
if (diffd > diff_Level ) trend[i] = -1;


teşekkürler

Işın

 
traderduke :

Mladen

Hala bir değişiklik yok. Tekrar deneyebilir miyiz?

2MA için yaptığım tek şey bu;

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] = BOŞ_DEĞER;
trend[i] = trend[i+1];

çift diffu = (fastMA - slowMA);

çift fark = (slowMA - fastMA);

if (diffu > diff_Level ) trend[i] = 1;
if (diffd > diff_Level ) trend[i] = -1;


teşekkürler

Işın

Çoklu zaman çerçevesi modunu denediğimde aldığım şey bu (yukarıdaki gönderideki gösterge)


Gördüğüm kadarıyla her şey olması gerektiği gibi çalışıyor

 
mladen :

Çoklu zaman çerçevesi modunu denediğimde aldığım şey bu (yukarıdaki gönderideki gösterge)

DİKKAT: Video yeniden yüklenmelidir

DİKKAT: Video yeniden yüklenmelidir
Gördüğüm kadarıyla her şey olması gerektiği gibi çalışıyor

Mladen

Sorunumu net bir şekilde sunamadığım için özür dilerim. diff_Levelms 0.0'ın düzgün çalıştığı konusunda haklısınız, ancak diff_Levelms'in eklenmesi, EURUSD için .0002 veya USDJPY için .02 gibi aralıkların çıkarılması gibi küçük değişikliklere izin vermekti. Görünüşe göre fark hesaplamam trend1 hesaplaması tarafından kullanılmıyor

çift fark = (ma2[i]-ma3[i]); // orta-yavaş Görünüşe göre benim hesaplamam
çift fark = (ma3[i]-ma2[i]); //yavaş - med Görünüşe göre benim hesaplamam

if (ma1[i]>ma2[i]) trendfm[i] = 1 ;
if (ma1[i]<ma2[i]) trendfm[i] = - 1 ;
if (ma1[i]>ma3[i]) trendfs[i] = 1 ;
if (ma1[i]<ma3[i]) trendfs[i] = - 1 ;
if (ma2[i]>ma3[i] && diffums > diff_Levelms) trendms[i] = 1 ; trend1 hesaplaması tarafından kullanılmıyor
if (ma2[i]<ma3[i] && diffdms > diff_Levelms) trendms[i] = - 1 ; trend1 hesaplaması tarafından kullanılmıyor


Teşekkür ederim

ışın


 

gösterge güncellenmiyor


Ekli "Outsidebar Trendline V2" göstergesini indirdim ancak nedense güncellenmiyor

sonraki çubuk/mum. Zaman dilimlerini değiştirirken iyi çalışıyor, ancak aşağıdaki çubukta o zaman diliminde artık çalışmıyor.

Bir uzmanınız, göstergenin sonraki çubuklarda da kendini yenilemesi için lütfen yardımcı olabilir mi?

Çok teşekkürler

Lea

Dosyalar:
OutsideBar TrendLine v2.mq4  28 kb
 

mladen,

Arkadaşım bu EA'yı köşe göstergesine dayanarak yazdı, onu oluşturduktan sonra geriye dönük bir test yapamadık. Lütfen arkaya yaslanmasını engelleyen hatayı düzeltmeme yardım eder misiniz? ancak temizlendikten sonra çok fazla güncelleme gerektirir

Teşekkürler ve alçakgönüllülükle

// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
#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;
}
 

Ve bu devamı

 // ------------------------------------------------------------------------------------------------
// 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();
         
      }           
  }
  
  
 
MECMAN :

Ve bu devamı

Lütfen mq4 dosyasını ekleyin - bu şekilde kullanıcılar dosyayı kolayca test edemezler ve size yardımcı olamazlar.
 

hey Mladen

Bu sitede yeniyim ve iyi çalışmalarını görebiliyorum, böyle devam et kardeşim. Ancak, bir göstergeyi EA'ya dönüştürmek için bazı kodlamalarda bana yardımcı olmanızı dilerim.

Gerçekten ihtiyacım olan tek şey, sinyal göründüğünde EA'nın satın alması veya satması.

Fikir, daha yüksek bir zaman dilimine, 4 saat tf'ye gitmek ve piyasanın trendini bulmak (sadece trendi bilmek için) ve daha düşük tf'de (15-5 dakika) işlem yapmaktır. Bu nedenle, kısaysa, yalnızca trendin değişmesine ve daha yüksek zaman dilimine kadar kısayız.

Şimdiden teşekkürler.

 
mladen :
Lütfen mq4 dosyasını ekleyin - bu şekilde kullanıcılar dosyayı kolayca test edemezler ve size yardımcı olamazlar.
Yüklendi, lütfen herkes bu koda bakabilir ve neden testin geri alınamadığını öğrenebilir, sonuçlar karlı olmayabilir ama minnettar olacağım.
Dosyalar:
VPro3.mq4  21 kb
 
MECMAN :
Yüklendi, lütfen herkes bu koda bakabilir ve neden testin geri alınamadığını öğrenebilir, sonuçlar karlı olmayabilir ama minnettar olacağım.

Çalışıyor (göstergeler klasöründe "vertex_mod_3.01" göstergesine sahip olduğunuz sürece)


1...686687688689690691692693694695696697698699700...786
Yeni yorum