多周期多指标共振自动交易 EA

#property copyright   "XAUOF 指标工坊"
#property version     "1.00"
#property strict

#include <Trade\Trade.mqh>

//--- 输入参数
input group "========== 均线参数 =========="
input int      Fast_Period = 7;           // 快速均线周期（EMA 7）
input int      Slow_Period = 63;          // 慢速均线周期（EMA 63）

input group "========== 多周期设置 =========="
input bool     Use_M1 = true;             // 启用 1 分钟周期
input bool     Use_M5 = true;             // 启用 5 分钟周期
input bool     Use_M15 = true;            // 启用 15 分钟周期
input int      Min_Timeframes = 2;        // 最少共振周期数（1～3）
input bool     Require_Cross = false;     // 要求至少一个周期出现均线交叉

input group "========== RSI 参数 =========="
input int      RSI_Period = 14;           // RSI 周期
input double   RSI_Level = 50.0;          // RSI 强弱分界线
input ENUM_TIMEFRAMES RSI_Timeframe = PERIOD_M5;  // RSI 使用的周期

input group "========== MACD 参数 =========="
input int      MACD_Fast = 12;            // MACD 快线周期
input int      MACD_Slow = 26;            // MACD 慢线周期
input int      MACD_Signal = 9;           // MACD 信号线周期
input ENUM_TIMEFRAMES MACD_Timeframe = PERIOD_M5; // MACD 使用的周期

input group "========== 交易参数 =========="
input double   Lot_Size = 0.1;            // 固定手数
input int      Stop_Loss = 300;           // 止损点数（0=不设止损）
input int      Take_Profit = 600;         // 止盈点数（0=不设止盈）
input bool     Close_On_Opposite = true;  // 反向信号平仓
input ulong    Magic_Number = 777777;     // 魔术号
input string   Trade_Comment = "多周期共振"; // 订单备注

//--- 全局变量
CTrade         trade;

// M1 均线句柄
int            handleM1_Fast, handleM1_Slow;
double         m1_fast[], m1_slow[];

// M5 均线句柄
int            handleM5_Fast, handleM5_Slow;
double         m5_fast[], m5_slow[];

// M15 均线句柄
int            handleM15_Fast, handleM15_Slow;
double         m15_fast[], m15_slow[];

// RSI 句柄
int            handleRSI;
double         rsiBuffer[];

// MACD 句柄
int            handleMACD;
double         macdMain[], macdSignal[];

datetime       lastBarTime = 0;

//+------------------------------------------------------------------+
//| 初始化函数                                                        |
//+------------------------------------------------------------------+
int OnInit()
{
   trade.SetExpertMagicNumber(Magic_Number);
   trade.SetDeviationInPoints(20);
   
   // 创建 M1 均线句柄
   if(Use_M1)
   {
      handleM1_Fast = iMA(_Symbol, PERIOD_M1, Fast_Period, 0, MODE_EMA, PRICE_CLOSE);
      handleM1_Slow = iMA(_Symbol, PERIOD_M1, Slow_Period, 0, MODE_EMA, PRICE_CLOSE);
      if(handleM1_Fast == INVALID_HANDLE || handleM1_Slow == INVALID_HANDLE)
      {
         Print("创建 M1 均线句柄失败");
         return INIT_FAILED;
      }
      ArraySetAsSeries(m1_fast, true);
      ArraySetAsSeries(m1_slow, true);
   }
   
   // 创建 M5 均线句柄
   if(Use_M5)
   {
      handleM5_Fast = iMA(_Symbol, PERIOD_M5, Fast_Period, 0, MODE_EMA, PRICE_CLOSE);
      handleM5_Slow = iMA(_Symbol, PERIOD_M5, Slow_Period, 0, MODE_EMA, PRICE_CLOSE);
      if(handleM5_Fast == INVALID_HANDLE || handleM5_Slow == INVALID_HANDLE)
      {
         Print("创建 M5 均线句柄失败");
         return INIT_FAILED;
      }
      ArraySetAsSeries(m5_fast, true);
      ArraySetAsSeries(m5_slow, true);
   }
   
   // 创建 M15 均线句柄
   if(Use_M15)
   {
      handleM15_Fast = iMA(_Symbol, PERIOD_M15, Fast_Period, 0, MODE_EMA, PRICE_CLOSE);
      handleM15_Slow = iMA(_Symbol, PERIOD_M15, Slow_Period, 0, MODE_EMA, PRICE_CLOSE);
      if(handleM15_Fast == INVALID_HANDLE || handleM15_Slow == INVALID_HANDLE)
      {
         Print("创建 M15 均线句柄失败");
         return INIT_FAILED;
      }
      ArraySetAsSeries(m15_fast, true);
      ArraySetAsSeries(m15_slow, true);
   }
   
   // 创建 RSI 句柄
   handleRSI = iRSI(_Symbol, RSI_Timeframe, RSI_Period, PRICE_CLOSE);
   if(handleRSI == INVALID_HANDLE)
   {
      Print("创建 RSI 句柄失败");
      return INIT_FAILED;
   }
   ArraySetAsSeries(rsiBuffer, true);
   
   // 创建 MACD 句柄
   handleMACD = iMACD(_Symbol, MACD_Timeframe, MACD_Fast, MACD_Slow, MACD_Signal, PRICE_CLOSE);
   if(handleMACD == INVALID_HANDLE)
   {
      Print("创建 MACD 句柄失败");
      return INIT_FAILED;
   }
   ArraySetAsSeries(macdMain, true);
   ArraySetAsSeries(macdSignal, true);
   
   Print("========== 多周期多指标共振 EA 初始化成功 ==========");
   Print("均线参数：快线 EMA", Fast_Period, "  慢线 EMA", Slow_Period);
   Print("监控周期：M1=", Use_M1, "  M5=", Use_M5, "  M15=", Use_M15);
   Print("最少共振周期数：", Min_Timeframes, "  要求交叉：", Require_Cross);
   Print("RSI 周期：", RSI_Period, "  分界线：", RSI_Level, "  周期：", EnumToString(RSI_Timeframe));
   Print("MACD 参数：", MACD_Fast, "/", MACD_Slow, "/", MACD_Signal, "  周期：", EnumToString(MACD_Timeframe));
   Print("手数：", Lot_Size, "  止损：", Stop_Loss, "  止盈：", Take_Profit);
   
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| 清理函数                                                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   if(Use_M1)
   {
      if(handleM1_Fast != INVALID_HANDLE) IndicatorRelease(handleM1_Fast);
      if(handleM1_Slow != INVALID_HANDLE) IndicatorRelease(handleM1_Slow);
   }
   if(Use_M5)
   {
      if(handleM5_Fast != INVALID_HANDLE) IndicatorRelease(handleM5_Fast);
      if(handleM5_Slow != INVALID_HANDLE) IndicatorRelease(handleM5_Slow);
   }
   if(Use_M15)
   {
      if(handleM15_Fast != INVALID_HANDLE) IndicatorRelease(handleM15_Fast);
      if(handleM15_Slow != INVALID_HANDLE) IndicatorRelease(handleM15_Slow);
   }
   if(handleRSI != INVALID_HANDLE) IndicatorRelease(handleRSI);
   if(handleMACD != INVALID_HANDLE) IndicatorRelease(handleMACD);
   
   Print("========== 多周期多指标共振 EA 已停止 ==========");
}

//+------------------------------------------------------------------+
//| 主循环函数                                                        |
//+------------------------------------------------------------------+
void OnTick()
{
   // 以 M1 为基准判断新 K 线
   datetime currentBarTime = iTime(_Symbol, PERIOD_M1, 0);
   if(currentBarTime == lastBarTime)
      return;
   lastBarTime = currentBarTime;
   
   // 等待 RSI 和 MACD 数据准备就绪
   if(BarsCalculated(handleRSI) < 2 || BarsCalculated(handleMACD) < 2)
      return;
   
   // 复制 RSI 和 MACD 数据
   if(CopyBuffer(handleRSI, 0, 0, 3, rsiBuffer) < 3) return;
   if(CopyBuffer(handleMACD, 0, 0, 3, macdMain) < 3) return;
   if(CopyBuffer(handleMACD, 1, 0, 3, macdSignal) < 3) return;
   
   // 统计多头、空头、交叉信号的周期数
   int bullCount = 0;
   int bearCount = 0;
   bool hasBullCross = false;
   bool hasBearCross = false;
   
   // 判断各个时间周期的均线排列
   if(Use_M1 && CheckTimeframe(PERIOD_M1, handleM1_Fast, handleM1_Slow, m1_fast, m1_slow,
                                bullCount, bearCount, hasBullCross, hasBearCross) == false)
      return;
   
   if(Use_M5 && CheckTimeframe(PERIOD_M5, handleM5_Fast, handleM5_Slow, m5_fast, m5_slow,
                                bullCount, bearCount, hasBullCross, hasBearCross) == false)
      return;
   
   if(Use_M15 && CheckTimeframe(PERIOD_M15, handleM15_Fast, handleM15_Slow, m15_fast, m15_slow,
                                 bullCount, bearCount, hasBullCross, hasBearCross) == false)
      return;
   
   // 判断开仓信号
   bool buySignal = false;
   bool sellSignal = false;
   
   // 多头信号：多周期均线共振 + RSI > 50 + MACD 主线 > 信号线
   if(bullCount >= Min_Timeframes &&
      rsiBuffer[0] > RSI_Level &&
      macdMain[0] > macdSignal[0])
   {
      // 如果要求交叉信号
      if(Require_Cross)
      {
         if(hasBullCross) buySignal = true;
      }
      else
      {
         buySignal = true;
      }
   }
   
   // 空头信号：多周期均线共振 + RSI < 50 + MACD 主线 < 信号线
   if(bearCount >= Min_Timeframes &&
      rsiBuffer[0] < RSI_Level &&
      macdMain[0] < macdSignal[0])
   {
      // 如果要求交叉信号
      if(Require_Cross)
      {
         if(hasBearCross) sellSignal = true;
      }
      else
      {
         sellSignal = true;
      }
   }
   
   // 检查当前持仓
   bool hasPosition = false;
   int positionType = -1;
   
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket > 0 && PositionGetString(POSITION_SYMBOL) == _Symbol &&
         PositionGetInteger(POSITION_MAGIC) == Magic_Number)
      {
         hasPosition = true;
         positionType = (int)PositionGetInteger(POSITION_TYPE);
         
         // 反向信号平仓
         if(Close_On_Opposite)
         {
            if(positionType == POSITION_TYPE_BUY && sellSignal)
            {
               trade.PositionClose(ticket);
               Print("反向信号触发，平多单，票号：", ticket);
            }
            else if(positionType == POSITION_TYPE_SELL && buySignal)
            {
               trade.PositionClose(ticket);
               Print("反向信号触发，平空单，票号：", ticket);
            }
         }
         break;
      }
   }
   
   // 如果没有持仓，根据信号开仓
   if(!hasPosition)
   {
      double price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      double sl = 0, tp = 0;
      
      if(buySignal)
      {
         if(Stop_Loss > 0)
            sl = NormalizeDouble(price - Stop_Loss * _Point, _Digits);
         if(Take_Profit > 0)
            tp = NormalizeDouble(price + Take_Profit * _Point, _Digits);
         
         if(trade.Buy(Lot_Size, _Symbol, price, sl, tp, Trade_Comment))
         {
            Print("========== 多周期多指标共振开多单 ==========");
            Print("多头周期数：", bullCount, "  有金叉：", hasBullCross);
            Print("RSI：", NormalizeDouble(rsiBuffer[0], 2), "  MACD主线：", NormalizeDouble(macdMain[0], 5));
            Print("价格：", price, "  止损：", sl, "  止盈：", tp);
         }
         else
         {
            Print("开多单失败，错误代码：", GetLastError());
         }
      }
      else if(sellSignal)
      {
         price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
         
         if(Stop_Loss > 0)
            sl = NormalizeDouble(price + Stop_Loss * _Point, _Digits);
         if(Take_Profit > 0)
            tp = NormalizeDouble(price - Take_Profit * _Point, _Digits);
         
         if(trade.Sell(Lot_Size, _Symbol, price, sl, tp, Trade_Comment))
         {
            Print("========== 多周期多指标共振开空单 ==========");
            Print("空头周期数：", bearCount, "  有死叉：", hasBearCross);
            Print("RSI：", NormalizeDouble(rsiBuffer[0], 2), "  MACD主线：", NormalizeDouble(macdMain[0], 5));
            Print("价格：", price, "  止损：", sl, "  止盈：", tp);
         }
         else
         {
            Print("开空单失败，错误代码：", GetLastError());
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 检查单个时间周期的均线状态                                         |
//+------------------------------------------------------------------+
bool CheckTimeframe(ENUM_TIMEFRAMES period, int handleFast, int handleSlow,
                    double &fastBuf[], double &slowBuf[],
                    int &bullCount, int &bearCount,
                    bool &hasBullCross, bool &hasBearCross)
{
   // 等待指标计算完成
   if(BarsCalculated(handleFast) < 2 || BarsCalculated(handleSlow) < 2)
      return false;
   
   // 复制最近 3 根 K 线的数据
   if(CopyBuffer(handleFast, 0, 0, 3, fastBuf) < 3) return false;
   if(CopyBuffer(handleSlow, 0, 0, 3, slowBuf) < 3) return false;
   
   // 判断当前排列（索引 0 = 最新 K 线）
   bool isBull = (fastBuf[0] > slowBuf[0]);
   bool isBear = (fastBuf[0] < slowBuf[0]);
   
   if(isBull) bullCount++;
   if(isBear) bearCount++;
   
   // 判断是否出现交叉（前一根关系相反）
   if(isBull && fastBuf[1] <= slowBuf[1])
      hasBullCross = true;  // 金叉
   
   if(isBear && fastBuf[1] >= slowBuf[1])
      hasBearCross = true;  // 死叉
   
   return true;
}