三均线交叉信号EA 3MACross EA.mq5-MT5 EA-峰汇在线
诚信为本
量力而为
当前位置:峰汇在线 > MetaTrader 5 > MT5 EA > 正文

三均线交叉信号EA 3MACross EA.mq5

3MACross EA是根据均线交叉指标价格通道指标的信号进行自动交易。需要把两个指标也放置于MT5自定义指标文件夹。

源码:

//+------------------------------------------------------------------+
//|                         3MACross EA(barabashkakvn's edition).mq5 |
//|                                  Copyright © 2007, Forex-Experts |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, Forex-Experts"
#property link      "http://www.125808047.com"
#property version   "1.001"
//---
#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>  
#include <Trade\AccountInfo.mqh>
#include <Expert\Money\MoneyFixedMargin.mqh>
CPositionInfo  m_position;                   // trade position object
CTrade         m_trade;                      // trading object
CSymbolInfo    m_symbol;                     // symbol info object
CAccountInfo   m_account;                    // account info wrapper
CMoneyFixedMargin m_money;

#define COMMENT "3MaCross_EA"

sinput string        _0_                  = "Trade parameters:";
input double         InpLots              = 0.1;         // Lots (if <=0 -> use risk from a free margin)
input ushort         InpStopLoss          = 0;           // Stop Loss (in pips)
input ushort         InpTakeProfit        = 145;         // Take Profit (in pips)
input ushort         InpTrailingStop      = 0;           // Trailing Stop (in pips)
ushort               InpTrailingStep      = 5;           // Trailing Step (in pips)
input double         Risk                 = 10;          // Risk in percent for a deal from a free margin
input bool           InpAutoSLTP          = false;       // Auto SL/TP (only if "Trailing Stop" == 0)
input bool           InpTradeAtCloseBar   = true;        // Trade at close bar
input ushort         InpBreakEven         = 15;          // BreakEven (only if "Trailing Stop"==0 and "Auto SL/TP"==false)
input int            InpMaxOpenPositions  = 5;           // Max open positions
sinput string        _1_                  = "MA Cross 3MACross Alert WarnSig:";
sinput string        _2_                  = "Parameters of the first Moving Average";
input int            InpMAPeriodFirst     = 23;          // Period of the first Moving Average
input int            InpMAShiftFirst      = 0;           // Shift of the first Moving Average
input ENUM_MA_METHOD InpMAMethodFirst     = MODE_SMMA;   // Method of the first Moving Average
sinput string        _3_                  = "Parameters of the second Moving Average";
input int            InpMAPeriodSecond    = 61;          // Period of the second Moving Average
input int            InpMAShiftSecond     = 0;           // Shift of the second Moving Average
input ENUM_MA_METHOD InpMAMethodSecond    = MODE_SMMA;   // Method of the second Moving Average
sinput string        _4_                  = "Parameters of the Third Moving Average";
input int            InpMAPeriodThird     = 122;         // Period of the third Moving Average
input int            InpMAShiftThird      = 0;           // Shift of the third Moving Average
input ENUM_MA_METHOD InpMAMethodThird     = MODE_SMMA;   // Method of the third Moving Average
input bool           crossesOnCurrent     = true;
input bool           alertsOn             = true;
input bool           alertsMessage        = true;
input bool           alertsSound          = false;
input bool           alertsEmail          = false;
sinput string        _5_                  = "Price Channel:";
input int            InpChannelPeriod     = 15;

ulong                m_ticket;
ulong                m_magic=15489;                // magic number
ulong                m_slippage=30;                // slippage

double               ExtStopLoss=0.0;
double               ExtTakeProfit=0.0;
double               ExtTrailingStop=0.0;
double               ExtTrailingStep=0.0;
double               ExtBreakEven=0.0;

int                  TradeBar=0;
int                  handle_iCustom_3MACross;      // variable for storing the handle of the iCustom indicator 
int                  handle_iCustom_PriceChannel;  // variable for storing the handle of the iCustom indicator 
double               m_adjusted_point;             // point value adjusted for 3 or 5 points
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(InpAutoSLTP && InpTrailingStop!=0)
     {
      Print("It is necessary to choose only one parameter: either \"Trailing Stop\" or \"Auto SL/TP\"");
      return(INIT_PARAMETERS_INCORRECT);
     }
   if(InpBreakEven>0 && (InpTrailingStop!=0 || InpAutoSLTP))
     {
      Print("It is necessary to choose only one parameter: either \"Trailing Stop\" or \"Auto SL/TP\" or \"BreakEven\"");
      return(INIT_PARAMETERS_INCORRECT);
     }

   if(InpTradeAtCloseBar)
      TradeBar=1;
   else
      TradeBar=0;

   if(!m_symbol.Name(Symbol())) // sets symbol name
      return(INIT_FAILED);
   RefreshRates();

   string err_text="";
   if(InpLots>0.0)
      if(!CheckVolumeValue(InpLots,err_text))
        {
         Print(err_text);
         return(INIT_PARAMETERS_INCORRECT);
        }

   m_trade.SetExpertMagicNumber(m_magic);

   if(IsFillingTypeAllowed(SYMBOL_FILLING_FOK))
      m_trade.SetTypeFilling(ORDER_FILLING_FOK);
   else if(IsFillingTypeAllowed(SYMBOL_FILLING_IOC))
      m_trade.SetTypeFilling(ORDER_FILLING_IOC);
   else
      m_trade.SetTypeFilling(ORDER_FILLING_RETURN);

   m_trade.SetDeviationInPoints(m_slippage);

   int digits_adjust=1;
   if(m_symbol.Digits()==3 || m_symbol.Digits()==5)
      digits_adjust=10;
   m_adjusted_point=m_symbol.Point()*digits_adjust;

   ExtStopLoss=InpStopLoss*m_adjusted_point;
   ExtTakeProfit=InpTakeProfit*m_adjusted_point;
   ExtTrailingStop=InpTrailingStop*m_adjusted_point;
   ExtTrailingStep=InpTrailingStep*m_adjusted_point;
   ExtBreakEven=InpBreakEven*m_adjusted_point;

   if(InpLots<=0.0)
     {
      if(!m_money.Init(GetPointer(m_symbol),Period(),m_symbol.Point()*digits_adjust))
         return(INIT_FAILED);
      m_money.Percent(Risk);
     }
   handle_iCustom_3MACross=iCustom(m_symbol.Name(),Period(),"MA Cross 3MACross Alert WarnSig",
                                   "Parameters of the first Moving Average",
                                   InpMAPeriodFirst,
                                   InpMAShiftFirst,
                                   InpMAMethodFirst,
                                   "Parameters of the second Moving Average",
                                   InpMAPeriodSecond,
                                   InpMAShiftSecond,
                                   InpMAMethodSecond,
                                   "Parameters of the Third Moving Average",
                                   InpMAPeriodThird,
                                   InpMAShiftThird,
                                   InpMAMethodThird);
   if(handle_iCustom_3MACross==INVALID_HANDLE)
     {
      PrintFormat("Failed to create handle of the iCustom indicator for the symbol %s/%s, error code %d",
                  m_symbol.Name(),
                  EnumToString(Period()),
                  GetLastError());
      return(INIT_FAILED);
     }
   handle_iCustom_PriceChannel=iCustom(m_symbol.Name(),Period(),"price_channel",InpChannelPeriod);
   if(handle_iCustom_PriceChannel==INVALID_HANDLE)
     {
      PrintFormat("Failed to create handle of the iCustom indicator for the symbol %s/%s, error code %d",
                  m_symbol.Name(),
                  EnumToString(Period()),
                  GetLastError());
      return(INIT_FAILED);
     }
    Comment("www.125808047.com");
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   static datetime PrevBars=0;
   datetime time_0=iTime(0);
   if(time_0==PrevBars)
      return;
   PrevBars=time_0;

   double sig_buy = iCustomGet(handle_iCustom_3MACross,0,TradeBar);     // 0 -> "Cross Up" buffer
   double sig_sell= iCustomGet(handle_iCustom_3MACross,1,TradeBar);     // 1 -> "Cross Down"  buffer
   double ch_up   = iCustomGet(handle_iCustom_PriceChannel,0,TradeBar); // 0 -> "Channel upper"  buffer
   double ch_dn   = iCustomGet(handle_iCustom_PriceChannel,1,TradeBar); // 1 -> "Channel lower"  buffer
   if(sig_buy==0.0 || sig_sell==0.0 || ch_up==0.0 || ch_dn==0.0)
     {
      PrevBars=iTime(1);
      return;
     }
   if(!RefreshRates())
     {
      PrevBars=iTime(1);
      return;
     }

   int count_buys=0;
   int count_sells=0;
   CalculatePositions(count_buys,count_sells);

   if(sig_buy!=EMPTY_VALUE)
     {
      if(count_sells>0)
         ClosePositions(POSITION_TYPE_SELL);
      if(count_buys<InpMaxOpenPositions)
        {
         double sl=0.0;
         double tp=0.0;
         if(!InpAutoSLTP)
           {
            sl=(InpStopLoss==0)?0.0:m_symbol.Ask()-ExtStopLoss;
            tp=(InpTakeProfit==0)?0.0:m_symbol.Ask()+ExtTakeProfit;
           }
         else
           {
            sl=(ch_dn<m_symbol.Ask()-ExtBreakEven)?ch_dn:m_symbol.Ask()-ExtBreakEven;
            tp=(ch_up>m_symbol.Ask()+ExtBreakEven)?ch_up:m_symbol.Ask()+ExtBreakEven;
           }
         OpenBuy(sl,tp);
        }
     }
   if(sig_sell!=EMPTY_VALUE)
     {
      if(count_buys>0)
         ClosePositions(POSITION_TYPE_BUY);
      if(count_sells<InpMaxOpenPositions)
        {
         double sl=0.0;
         double tp=0.0;
         if(!InpAutoSLTP)
           {
            sl=(InpStopLoss==0)?0.0:m_symbol.Bid()+ExtStopLoss;
            tp=(InpTakeProfit==0)?0.0:m_symbol.Bid()-ExtTakeProfit;
           }
         else
           {
            sl=(ch_up>m_symbol.Bid()+ExtBreakEven)?ch_up:m_symbol.Bid()+ExtBreakEven;
            tp=(ch_dn<m_symbol.Bid()-ExtBreakEven)?ch_dn:m_symbol.Bid()-ExtBreakEven;
           }
         OpenSell(sl,tp);
        }
     }

   if(InpTrailingStop==0)
      return;
   for(int i=PositionsTotal()-1;i>=0;i--) // returns the number of open positions
      if(m_position.SelectByIndex(i))
         if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==m_magic)
           {
            if(m_position.PositionType()==POSITION_TYPE_BUY)
              {
               if(InpTrailingStop>0)
                 {
                  if(m_position.PriceCurrent()-m_position.PriceOpen()>ExtTrailingStop+ExtTrailingStep)
                     if(m_position.StopLoss()<m_position.PriceCurrent()-(ExtTrailingStop+ExtTrailingStep))
                       {
                        if(!m_trade.PositionModify(m_position.Ticket(),
                           m_symbol.NormalizePrice(m_position.PriceCurrent()-ExtTrailingStop),
                           m_position.TakeProfit()))
                           Print("Trailing modify ",m_position.Ticket(),
                                 " Position -> false. Result Retcode: ",m_trade.ResultRetcode(),
                                 ", description of result: ",m_trade.ResultRetcodeDescription());
                        continue;
                       }
                 }
               else if(InpAutoSLTP)
                 {
                  if(!CompareDoubles(m_position.StopLoss(),ch_dn) && ch_dn>m_position.StopLoss())
                    {
                     if(!m_trade.PositionModify(m_position.Ticket(),
                        m_symbol.NormalizePrice(ch_dn),
                        m_position.TakeProfit()))
                        Print("Auto SL/TP modify ",m_position.Ticket(),
                              " Position -> false. Result Retcode: ",m_trade.ResultRetcode(),
                              ", description of result: ",m_trade.ResultRetcodeDescription());
                     continue;
                    }
                 }
               else if(InpBreakEven>0)
                 {
                  if(m_position.PriceCurrent()-m_position.PriceOpen()>ExtBreakEven+ExtTrailingStep)
                     if(!CompareDoubles(m_position.StopLoss(),m_position.PriceOpen()+ExtBreakEven))
                       {
                        if(!m_trade.PositionModify(m_position.Ticket(),
                           m_symbol.NormalizePrice(m_position.PriceOpen()+ExtBreakEven),
                           m_position.TakeProfit()))
                           Print("BreakEven modify ",m_position.Ticket(),
                                 " Position -> false. Result Retcode: ",m_trade.ResultRetcode(),
                                 ", description of result: ",m_trade.ResultRetcodeDescription());
                        continue;
                       }
                 }
              }
            else
              {
               if(InpTrailingStop>0)
                 {
                  if(m_position.PriceOpen()-m_position.PriceCurrent()>ExtTrailingStop+ExtTrailingStep)
                     if((m_position.StopLoss()>(m_position.PriceCurrent()+(ExtTrailingStop+ExtTrailingStep))) || 
                        (m_position.StopLoss()==0))
                       {
                        if(!m_trade.PositionModify(m_position.Ticket(),
                           m_symbol.NormalizePrice(m_position.PriceCurrent()+ExtTrailingStop),
                           m_position.TakeProfit()))
                           Print("Trailing modify ",m_position.Ticket(),
                                 " Position -> false. Result Retcode: ",m_trade.ResultRetcode(),
                                 ", description of result: ",m_trade.ResultRetcodeDescription());
                        return;
                       }
                 }
               else if(InpAutoSLTP)
                 {
                  if(!CompareDoubles(m_position.StopLoss(),ch_up) && ch_up<m_position.StopLoss())
                    {
                     if(!m_trade.PositionModify(m_position.Ticket(),
                        m_symbol.NormalizePrice(ch_up),
                        m_position.TakeProfit()))
                        Print("Auto SL/TP modify ",m_position.Ticket(),
                              " Position -> false. Result Retcode: ",m_trade.ResultRetcode(),
                              ", description of result: ",m_trade.ResultRetcodeDescription());
                     continue;
                    }
                 }
               else if(InpBreakEven>0)
                 {
                  if(m_position.PriceOpen()-m_position.PriceCurrent()>ExtBreakEven+ExtTrailingStep)
                     if(!CompareDoubles(m_position.StopLoss(),m_position.PriceOpen()-ExtBreakEven))
                       {
                        if(!m_trade.PositionModify(m_position.Ticket(),
                           m_symbol.NormalizePrice(m_position.PriceOpen()-ExtBreakEven),
                           m_position.TakeProfit()))
                           Print("BreakEven modify ",m_position.Ticket(),
                                 " Position -> false. Result Retcode: ",m_trade.ResultRetcode(),
                                 ", description of result: ",m_trade.ResultRetcodeDescription());
                        continue;
                       }
                 }
              }
           }
   return;
  }
//+------------------------------------------------------------------+ 
//| Get Time for specified bar index                                 | 
//+------------------------------------------------------------------+ 
datetime iTime(const int index,string symbol=NULL,ENUM_TIMEFRAMES timeframe=PERIOD_CURRENT)
  {
   if(symbol==NULL)
      symbol=Symbol();
   if(timeframe==0)
      timeframe=Period();
   datetime Time[1];
   datetime time=0;
   int copied=CopyTime(symbol,timeframe,index,1,Time);
   if(copied>0) time=Time[0];
   return(time);
  }
//+------------------------------------------------------------------+
//| Refreshes the symbol quotes data                                 |
//+------------------------------------------------------------------+
bool RefreshRates(void)
  {
   if(!m_symbol.RefreshRates())
     {
      Print("RefreshRates error");
      return(false);
     }
   if(m_symbol.Ask()==0 || m_symbol.Bid()==0)
      return(false);
   return(true);
  }
//+------------------------------------------------------------------+
//| Check the correctness of the order volume                        |
//+------------------------------------------------------------------+
bool CheckVolumeValue(double volume,string &error_description)
  {
   double min_volume=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
   if(volume<min_volume)
     {
      error_description=StringFormat("Volume is less than the minimal allowed SYMBOL_VOLUME_MIN=%.2f",min_volume);
      return(false);
     }
   double max_volume=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
   if(volume>max_volume)
     {
      error_description=StringFormat("Volume is greater than the maximal allowed SYMBOL_VOLUME_MAX=%.2f",max_volume);
      return(false);
     }
   double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);

   int ratio=(int)MathRound(volume/volume_step);
   if(MathAbs(ratio*volume_step-volume)>0.0000001)
     {
      error_description=StringFormat("Volume is not a multiple of the minimal step SYMBOL_VOLUME_STEP=%.2f, the closest correct volume is %.2f",
                                     volume_step,ratio*volume_step);
      return(false);
     }
   error_description="Correct volume value";
   return(true);
  }
//+------------------------------------------------------------------+ 
//| Checks if the specified filling mode is allowed                  | 
//+------------------------------------------------------------------+ 
bool IsFillingTypeAllowed(int fill_type)
  {
   int filling=m_symbol.TradeFillFlags();
   return((filling & fill_type)==fill_type);
  }
//+------------------------------------------------------------------+
//| Get value of buffers for the iCustom                             |
//|  the buffer numbers are the following:                           |
//+------------------------------------------------------------------+
double iCustomGet(int handle,const int buffer,const int index)
  {
   double Custom[1];
   ResetLastError();
   if(CopyBuffer(handle,buffer,index,1,Custom)<0)
     {
      PrintFormat("Failed to copy data from the iCustom indicator, error code %d",GetLastError());
      return(0.0);
     }
   return(Custom[0]);
  }
//+------------------------------------------------------------------+
//| Calculate positions Buy and Sell                                 |
//+------------------------------------------------------------------+
void CalculatePositions(int &count_buys,int &count_sells)
  {
   count_buys=0.0;
   count_sells=0.0;

   for(int i=PositionsTotal()-1;i>=0;i--)
      if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties
         if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==m_magic)
           {
            if(m_position.PositionType()==POSITION_TYPE_BUY)
               count_buys++;

            if(m_position.PositionType()==POSITION_TYPE_SELL)
               count_sells++;
           }
   return;
  }
//+------------------------------------------------------------------+
//| Close positions                                                  |
//+------------------------------------------------------------------+
void ClosePositions(const ENUM_POSITION_TYPE pos_type)
  {
   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()==Symbol() && m_position.Magic()==m_magic)
            if(m_position.PositionType()==pos_type) // gets the position type
               m_trade.PositionClose(m_position.Ticket()); // close a position by the specified symbol
  }
//+------------------------------------------------------------------+
//| Open Buy position                                                |
//+------------------------------------------------------------------+
void OpenBuy(double sl,double tp)
  {
   sl=m_symbol.NormalizePrice(sl);
   tp=m_symbol.NormalizePrice(tp);

   double check_open_long_lot=0.0;

   if(InpLots<=0.0)
     {
      check_open_long_lot=m_money.CheckOpenLong(m_symbol.Ask(),sl);
      Print("sl=",DoubleToString(sl,m_symbol.Digits()),
            ", CheckOpenLong: ",DoubleToString(check_open_long_lot,2),
            ", Balance: ",    DoubleToString(m_account.Balance(),2),
            ", Equity: ",     DoubleToString(m_account.Equity(),2),
            ", FreeMargin: ", DoubleToString(m_account.FreeMargin(),2));
      if(check_open_long_lot==0.0)
         return;
     }
   else
      check_open_long_lot=InpLots;
   double check_volume_lot=m_trade.CheckVolume(m_symbol.Name(),2.0*check_open_long_lot,m_symbol.Ask(),ORDER_TYPE_BUY);

   if(check_volume_lot!=0.0)
      if(check_volume_lot>=check_open_long_lot)
        {
         if(m_trade.Buy(check_open_long_lot,NULL,m_symbol.Ask(),sl,tp))
           {
            if(m_trade.ResultDeal()==0)
              {
               Print("#1 Buy -> false. Result Retcode: ",m_trade.ResultRetcode(),
                     ", description of result: ",m_trade.ResultRetcodeDescription());
               PrintResult(m_trade,m_symbol);
              }
            else
              {
               Print("#2 Buy -> true. Result Retcode: ",m_trade.ResultRetcode(),
                     ", description of result: ",m_trade.ResultRetcodeDescription());
               PrintResult(m_trade,m_symbol);
              }
           }
         else
           {
            Print("#3 Buy -> false. Result Retcode: ",m_trade.ResultRetcode(),
                  ", description of result: ",m_trade.ResultRetcodeDescription());
            PrintResult(m_trade,m_symbol);
           }
        }
  }
//+------------------------------------------------------------------+
//| Open Sell position                                               |
//+------------------------------------------------------------------+
void OpenSell(double sl,double tp)
  {
   sl=m_symbol.NormalizePrice(sl);
   tp=m_symbol.NormalizePrice(tp);

   double check_open_short_lot=0.0;

   if(InpLots<=0.0)
     {
      check_open_short_lot=m_money.CheckOpenShort(m_symbol.Bid(),sl);
      Print("sl=",DoubleToString(sl,m_symbol.Digits()),
            ", CheckOpenLong: ",DoubleToString(check_open_short_lot,2),
            ", Balance: ",    DoubleToString(m_account.Balance(),2),
            ", Equity: ",     DoubleToString(m_account.Equity(),2),
            ", FreeMargin: ", DoubleToString(m_account.FreeMargin(),2));
      if(check_open_short_lot==0.0)
         return;
     }
   else
      check_open_short_lot=InpLots;
   double check_volume_lot=m_trade.CheckVolume(m_symbol.Name(),2.0*check_open_short_lot,m_symbol.Bid(),ORDER_TYPE_SELL);

   if(check_volume_lot!=0.0)
      if(check_volume_lot>=check_open_short_lot)
        {
         if(m_trade.Sell(check_open_short_lot,NULL,m_symbol.Bid(),sl,tp))
           {
            if(m_trade.ResultDeal()==0)
              {
               Print("#1 Sell -> false. Result Retcode: ",m_trade.ResultRetcode(),
                     ", description of result: ",m_trade.ResultRetcodeDescription());
               PrintResult(m_trade,m_symbol);
              }
            else
              {
               Print("#2 Sell -> true. Result Retcode: ",m_trade.ResultRetcode(),
                     ", description of result: ",m_trade.ResultRetcodeDescription());
               PrintResult(m_trade,m_symbol);
              }
           }
         else
           {
            Print("#3 Sell -> false. Result Retcode: ",m_trade.ResultRetcode(),
                  ", description of result: ",m_trade.ResultRetcodeDescription());
            PrintResult(m_trade,m_symbol);
           }
        }
  }
//+------------------------------------------------------------------+
//| Print CTrade result                                              |
//+------------------------------------------------------------------+
void PrintResult(CTrade &trade,CSymbolInfo &symbol)
  {
   Print("Code of request result: "+IntegerToString(trade.ResultRetcode()));
   Print("code of request result: "+trade.ResultRetcodeDescription());
   Print("deal ticket: "+IntegerToString(trade.ResultDeal()));
   Print("order ticket: "+IntegerToString(trade.ResultOrder()));
   Print("volume of deal or order: "+DoubleToString(trade.ResultVolume(),2));
   Print("price, confirmed by broker: "+DoubleToString(trade.ResultPrice(),symbol.Digits()));
   Print("current bid price: "+DoubleToString(trade.ResultBid(),symbol.Digits()));
   Print("current ask price: "+DoubleToString(trade.ResultAsk(),symbol.Digits()));
   Print("broker comment: "+trade.ResultComment());
  }
//+------------------------------------------------------------------+
//| Compare doubles                                                  |
//+------------------------------------------------------------------+
bool CompareDoubles(double number1,double number2)
  {
   if(NormalizeDouble(number1-number2,m_symbol.Digits())==0)
      return(true);
   else
      return(false);
  }
//+------------------------------------------------------------------+
//| TradeTransaction function                                        |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &result)
  {

  }
//+------------------------------------------------------------------+
打赏
版权所有转载请注明标题及链接:峰汇在线 » 三均线交叉信号EA 3MACross EA.mq5
上一篇:
下一篇:
分享到: 更多 (0)

如您觉得此文不错请扫码打赏!

支付宝扫一扫打赏

微信扫一扫打赏