Hilfe bei der Codierung

traderduke 2016.10.14 14:20 #6921

mladen:

Ray

Probieren Sie es jetzt aus

Mladen

Immer noch keine Änderung. Können wir es noch einmal versuchen?

Das ist alles, was ich für die 2MA gemacht habe;

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

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

double diffu = (fastMA - slowMA);

double diffd = (slowMA - fastMA);

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

Danke

Strahl

Coding help Any rookie question, so Jede Anfängerfrage, um das

Mladen Rakic 2016.10.14 14:30 #6922

traderduke:

Mladen

Immer noch keine Änderung. Können wir es noch einmal versuchen?

Das ist alles, was ich für die 2MA gemacht habe;

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

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

double diffu = (fastMA - slowMA);

double diffd = (slowMA - fastMA);

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

Danke

Strahl

Das erhalte ich, wenn ich den Multi-Zeitrahmen-Modus ausprobiere (der Indikator aus dem obigen Beitrag)

Soweit ich sehe, funktioniert alles so, wie es funktionieren soll

traderduke 2016.10.14 17:54 #6923

mladen:

So sieht es aus, wenn ich den Multi-Time-Frame-Modus ausprobiere (der Indikator aus dem obigen Beitrag)

ACHTUNG: Video sollte neu hochgeladen werden

ATTENTION: Video sollte neu hochgeladen werden

Soweit ich sehe, funktioniert alles so, wie es funktionieren soll

Mladen

Ich entschuldige mich dafür, dass ich mein Problem nicht klar dargestellt habe. Sie haben recht, dass diff_Levelms 0.0 richtig funktioniert, aber die Hinzufügung von diff_Levelms sollte es ermöglichen, dass kleinere Änderungen wie z.B. die Schwankungsbreite von .0002 für EURUSD oder .02 für USDJPY nicht berücksichtigt werden. Offenbar wird meine diff-Berechnung nicht von der trend1-Berechnung verwendet.

double diffums = (ma2[i]-ma3[i]); //med-slow Anscheinend meine Berechnung
double diffdms = (ma3[i]-ma2[i]);//slow - med Offensichtlich meine Berechnung

wenn (ma1[i]>ma2[i]) trendfm[i] =1;
wenn (ma1[i]<ma2[i]) trendfm[i] =-1;
wenn (ma1[i]>ma3[i]) trendfs[i] =1;
wenn (ma1[i]<ma3[i]) trendfs[i] =-1;
if (ma2[i]>ma3[i] && diffums > diff_Levelms) trendms[i] =1; wird nicht von der trend1-Berechnung verwendet
if (ma2[i]<ma3[i] && diffdms > diff_Levelms) trendms[i] =-1; wird nicht von der trend1-Berechnung verwendet

Vielen Dank an

ray

Coding help Elite-Indikatoren :) Dynamisches Fibonacci-Gitter, Fx Money

peter22 2016.10.14 23:11 #6924

Indikator lässt sich nicht aktualisieren

Ich habe den beigefügten "Outsidebar Trendline V2"-Indikator heruntergeladen, aber aus irgendeinem Grund aktualisiert er sich nicht beim

nächsten Balken/Kerze. Beim Wechsel des Zeitrahmens funktioniert er gut, aber auf dem folgenden Balken in diesem Zeitrahmen nicht mehr.

Könnte ein Experte von Ihnen bitte helfen, damit sich der Indikator auch auf den nächsten Balken aktualisiert?

Vielen Dank!

Lea

Dateien:

OutsideBar TrendLine v2.mq4 28 kb

Wie programmiert man? T3 Multi-Timeframe-Indikatoren

[Gelöscht] 2016.10.15 09:09 #6925

mladen,

Mein Freund hat diesen EA auf der Grundlage des Vertex-Indikators geschrieben, wir waren nicht in der Lage, einen Backtest durchzuführen, nachdem er ihn erstellt hatte. Bitte können Sie mir helfen, beheben Sie den Fehler, der verhindert, dass es in der Lage, backrest. aber es erfordert eine Menge von Update, sobald es bereinigt ist

Vielen Dank und demütig apprciate

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

Indikatoren: STD Trend Envelopes Volatilität Qualitätsindex Multi-Timeframe-Indikatoren

[Gelöscht] 2016.10.15 09:10 #6926

Und das ist die Fortsetzung

 // ------------------------------------------------------------------------------------------------
// 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 10:20 #6927

MECMAN:

Und dies ist die Fortsetzung

Bitte fügen Sie die mq4-Datei an - auf diese Weise können die Benutzer es nicht leicht testen und können Ihnen dann nicht helfen

[Gelöscht] 2016.10.15 10:36 #6928

HEY MLADEN

Ich bin neu auf dieser Website, und ich kann sehen, Ihre gute Arbeit, keep it up bro. Allerdings wünschte ich, Sie können mir helfen, mit einigen Codierung auf Drehen eines Indikators in einen EA.

Alles, was ich wirklich brauche, ist für die EA zu kaufen oder zu verkaufen, wenn Signal erscheint.

Idee ist es, zu einem höheren Zeitrahmen, 4hrs tf zu gehen und den Trend des Marktes zu finden (nur um den Trend zu kennen) und Handel auf niedrigeren tf (15-5mins). Also, wenn es kurz, wir nur kurz, bis die Änderung der Trend der höheren Zeitrahmen.

Vielen Dank im Voraus.

Dateien:

3D_Oscilator_Crossover_Signal_alert_email.ex4 16 kb

Multi-Timeframe-Indikatoren Wie programmiert man? Ich schreibe kostenlos einen

[Gelöscht] 2016.10.16 05:18 #6929

mladen:
Bitte fügen Sie die mq4-Datei - auf diese Weise können Benutzer nicht testen es leicht und dann können sie nicht helfen Sie

Hochgeladen, bitte kann jemand in diesen Code schauen, um zu wissen, warum es nicht zurück testen kann, die Ergebnisse können nicht profitabel sein, aber ich werde dankbar sein

Dateien:

VPro3.mq4 21 kb

Mladen Rakic 2016.10.16 10:28 #6930

MECMAN:
Hochgeladen, bitte kann jemand Blick in diesen Code zu wissen, warum es nicht zurück testen, die Ergebnisse können nicht profitabel sein, aber ich werde dankbar sein

Es funktioniert (solange Sie den Indikator "vertex_mod_3.01" im Indikatorenordner haben)

Hilfe bei der Codierung - Seite 693