你好楼主能不能把这个转换成EA 一下  谢谢+------------------------------------------------------------------+
//|                                                   ChanlunPro.mq4 |
//|                        Copyright 2024, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "2.00"
#property strict
#property indicator_chart_window

// 输入参数
input int    MaxBars       = 2000;      // 最大分析柱数
input int    SegmentBars   = 5;         // 波段最小K线数
input double MinHeight     = 0.0003;    // 中枢最小高度(点)
input double OverlapRatio  = 0.5;       // 波段重叠比例(0-1)
input int    FractalBars   = 2;         // 分型验证K线数
input color  ZS1Color      = clrGray;   // 一级中枢颜色
input color  ZS2Color      = C'100,100,255'; // 二级中枢颜色
input color  Buy1Color     = clrLime;   // 一买颜色
input color  Buy2Color     = clrDodgerBlue; // 二买颜色
input color  Buy3Color     = clrCyan;   // 三买颜色
input color  Sell1Color    = clrRed;    // 一卖颜色
input color  Sell2Color    = C'255,100,0'; // 二卖颜色
input color  Sell3Color    = clrMagenta;// 三卖颜色
input int    ArrowSize     = 2;         // 箭头尺寸
input bool   ShowLabels    = true;      // 显示中枢标签

// 全局变量
struct ZhongShu { double high,low; datetime start,end; int level; };
ZhongShu zsArray[];                     // 中枢存储数组
int lastProcessedBar = 0;               // 最后处理K线索引

//+------------------------------------------------------------------+
//| 初始化指标                                                       |
//+------------------------------------------------------------------+
int OnInit()
{
   IndicatorBuffers(0);
   ArrayResize(zsArray, 100);
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| 主计算函数                                                       |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
   // 设置系列数组
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(time, true);
   
   // 确定计算范围
   int startBar = (prev_calculated == 0) ?
        MathMin(rates_total-1, MaxBars-1) :
        MathMin(rates_total - prev_calculated + 5, rates_total-1);
        
   // 删除新K线范围内的旧对象
   DeleteObjectsInRange(time[startBar]);
   
   // 识别中枢和买卖点
   for(int i = startBar; i >= SegmentBars*3+1; i--)
   {
      ZhongShu newZS;
      if(FindZhongshu(i, high, low, time, newZS))
      {
         // 检查是否新中枢
         bool isNew = true;
         for(int j = 0; j < ArraySize(zsArray); j++)
         {
            if(zsArray[j].start == newZS.start &&
               zsArray[j].end == newZS.end)
            {
               isNew = false;
               break;
            }
         }
         
         if(isNew)
         {
            // 保存中枢并绘制
            SaveAndDrawZS(newZS, time);
         }
      }
      
      // 识别买卖点
      IdentifyPoints(i, high, low, close, time);
   }
   
   lastProcessedBar = rates_total - 1;
   return(rates_total);
}

//+------------------------------------------------------------------+
//| 删除指定时间后的对象                                             |
//+------------------------------------------------------------------+
void DeleteObjectsInRange(datetime afterTime)
{
   for(int i = ObjectsTotal()-1; i >= 0; i--)
   {
      string name = ObjectName(i);
      datetime objTime = (datetime)ObjectGetInteger(0, name, OBJPROP_TIME);
      
      if(StringFind(name, "ZS_") == 0 ||
         StringFind(name, "B") == 0 ||
         StringFind(name, "S") == 0)
      {
         if(objTime >= afterTime) ObjectDelete(name);
      }
   }
}

//+------------------------------------------------------------------+
//| 识别中枢（增强版）                                               |
//+------------------------------------------------------------------+
bool FindZhongshu(int startIdx, const double &high[], const double &low[],
                 const datetime &time[], ZhongShu &outZS)
{
   // 查找三个波段
   int peaks[6];
   peaks[0] = FindPeak(startIdx, MODE_HIGH, SegmentBars, high, low); // 第一段高点
   peaks[1] = FindPeak(peaks[0], MODE_LOW, SegmentBars, high, low);  // 第一段低点
   peaks[2] = FindPeak(peaks[1], MODE_HIGH, SegmentBars, high, low); // 第二段高点
   peaks[3] = FindPeak(peaks[2], MODE_LOW, SegmentBars, high, low);  // 第二段低点
   peaks[4] = FindPeak(peaks[3], MODE_HIGH, SegmentBars, high, low); // 第三段高点
   peaks[5] = FindPeak(peaks[4], MODE_LOW, SegmentBars, high, low);  // 第三段低点

   // 验证所有极点有效
   for(int i = 0; i < 6; i++)
      if(peaks[i] < 0) return false;
   
   // 计算波段区间
   double segHigh[3], segLow[3];
   segHigh[0] = HighMax(peaks[0], peaks[1], high);
   segLow[0]  = LowMin(peaks[0], peaks[1], low);
   segHigh[1] = HighMax(peaks[2], peaks[3], high);
   segLow[1]  = LowMin(peaks[2], peaks[3], low);
   segHigh[2] = HighMax(peaks[4], peaks[5], high);
   segLow[2]  = LowMin(peaks[4], peaks[5], low);
   
   // 计算中枢区间
   double zsHigh = MathMin(segHigh[0], MathMin(segHigh[1], segHigh[2]));
   double zsLow  = MathMax(segLow[0], MathMax(segLow[1], segLow[2]));
   
   // 验证中枢有效性
   if(zsHigh <= zsLow) return false;
   if((zsHigh - zsLow) < MinHeight * Point) return false;
   
   // 验证重叠比例
   double overlap1 = (MathMin(segHigh[0], segHigh[1]) - MathMax(segLow[0], segLow[1]));
   double overlap2 = (MathMin(segHigh[1], segHigh[2]) - MathMax(segLow[1], segLow[2]));
   double minRange = MathMin(zsHigh - zsLow, MathMin(segHigh[0]-segLow[0], segHigh[1]-segLow[1]));
   
   if(overlap1/minRange < OverlapRatio || overlap2/minRange < OverlapRatio)
      return false;
   
   // 确定中枢级别（基于持续时间）
   int duration = (int)((time[peaks[0]] - time[peaks[5]]) / PeriodSeconds());
   outZS.level = (duration > SegmentBars*20) ? 2 : 1;
   outZS.high = zsHigh;
   outZS.low = zsLow;
   outZS.start = time[peaks[5]];
   outZS.end = time[peaks[0]];
   
   return true;
}

//+------------------------------------------------------------------+
//| 保存并绘制中枢                                                   |
//+------------------------------------------------------------------+
void SaveAndDrawZS(ZhongShu &zs, const datetime &time[])
{
   // 保存到数组
   int size = ArraySize(zsArray);
   for(int i = 0; i < size; i++)
   {
      if(zsArray[i].start == 0)
      {
         zsArray[i] = zs;
         break;
      }
   }
   
   // 绘制中枢
   string zsName = "ZS_" + IntegerToString(zs.start) + "_" + IntegerToString(zs.end);
   color zsColor = (zs.level == 1) ? ZS1Color : ZS2Color;
   
   ObjectCreate(0, zsName, OBJ_RECTANGLE, 0, zs.start, zs.low, zs.end, zs.high);
   ObjectSetInteger(0, zsName, OBJPROP_COLOR, zsColor);
   ObjectSetInteger(0, zsName, OBJPROP_BACK, true);
   ObjectSetInteger(0, zsName, OBJPROP_WIDTH, 1);
   ObjectSetInteger(0, zsName, OBJPROP_STYLE, STYLE_SOLID);
   ObjectSetInteger(0, zsName, OBJPROP_FILL, true);
   ObjectSetInteger(0, zsName, OBJPROP_SELECTABLE, false);
   
   // 添加中枢标签
   if(ShowLabels)
   {
      string labelName = "LBL_" + zsName;
      string text = StringFormat("ZS#%d\n%.5f-%.5f", zs.level, zs.low, zs.high);
      datetime labelTime = zs.start + (zs.end - zs.start)/2;
      double labelPrice = (zs.low + zs.high)/2;
      
      ObjectCreate(0, labelName, OBJ_TEXT, 0, labelTime, labelPrice);
      ObjectSetString(0, labelName, OBJPROP_TEXT, text);
      ObjectSetInteger(0, labelName, OBJPROP_COLOR, clrWhite);
      ObjectSetInteger(0, labelName, OBJPROP_FONTSIZE, 8);
      ObjectSetInteger(0, labelName, OBJPROP_BACK, true);
   }
}

//+------------------------------------------------------------------+
//| 识别全系列买卖点                                                 |
//+------------------------------------------------------------------+
void IdentifyPoints(int idx, const double &high[], const double &low[],
                   const double &close[], const datetime &time[])
{
   // 查找有效中枢
   for(int i = 0; i < ArraySize(zsArray); i++)
   {
      if(zsArray[i].start == 0) continue;
      
      double zsHigh = zsArray[i].high;
      double zsLow = zsArray[i].low;
      datetime zsEnd = zsArray[i].end;
      
      // 忽略未完成中枢
      if(time[idx] < zsEnd) continue;
      
      // 1. 一买点：中枢下方底分型
      if(close[idx] < zsLow && IsBottomFractal(idx, low, FractalBars))
      {
         string name = "B1_" + IntegerToString(idx);
         CreateArrow(name, time[idx], low[idx]-10*Point, Buy1Color, SYMBOL_ARROWUP);
      }
      
      // 2. 一卖点：中枢上方顶分型
      if(close[idx] > zsHigh && IsTopFractal(idx, high, FractalBars))
      {
         string name = "S1_" + IntegerToString(idx);
         CreateArrow(name, time[idx], high[idx]+10*Point, Sell1Color, SYMBOL_ARROWDOWN);
      }
      
      // 3. 二买点：回调不破前低
      if(close[idx] > zsLow && close[idx] < zsHigh &&
         IsBottomFractal(idx, low, FractalBars) &&
         IsHigherLow(idx, 10, low)) // 10周期内低点抬高
      {
         string name = "B2_" + IntegerToString(idx);
         CreateArrow(name, time[idx], low[idx]-10*Point, Buy2Color, SYMBOL_ARROWUP);
      }
      
      // 4. 二卖点：反弹不破前高
      if(close[idx] < zsHigh && close[idx] > zsLow &&
         IsTopFractal(idx, high, FractalBars) &&
         IsLowerHigh(idx, 10, high)) // 10周期内高点降低
      {
         string name = "S2_" + IntegerToString(idx);
         CreateArrow(name, time[idx], high[idx]+10*Point, Sell2Color, SYMBOL_ARROWDOWN);
      }
      
      // 5. 三买点：突破后回踩不破中枢
      if(close[idx] > zsHigh &&
         IsPullbackToZS(idx, 10, zsHigh, low) && // 回踩中枢上方
         IsBottomFractal(idx, low, FractalBars))
      {
         string name = "B3_" + IntegerToString(idx);
         CreateArrow(name, time[idx], low[idx]-10*Point, Buy3Color, SYMBOL_ARROWUP);
      }
      
      // 6. 三卖点：跌破后回抽不破中枢
      if(close[idx] < zsLow &&
         IsPullbackToZS(idx, 10, zsLow, high) && // 回抽中枢下方
         IsTopFractal(idx, high, FractalBars))
      {
         string name = "S3_" + IntegerToString(idx);
         CreateArrow(name, time[idx], high[idx]+10*Point, Sell3Color, SYMBOL_ARROWDOWN);
      }
   }
}

//+------------------------------------------------------------------+
//| 创建箭头对象                                                     |
//+------------------------------------------------------------------+
void CreateArrow(string name, datetime time, double price, color clr, int code)
{
   ObjectCreate(0, name, OBJ_ARROW, 0, time, price);
   ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
   ObjectSetInteger(0, name, OBJPROP_ARROWCODE, code);
   ObjectSetInteger(0, name, OBJPROP_WIDTH, ArrowSize);
   ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
}

//+------------------------------------------------------------------+
//| 辅助函数: 查找波段极点                                           |
//+------------------------------------------------------------------+
int FindPeak(int startIdx, int mode, int minBars, const double &high[], const double &low[])
{
   int peakIdx = startIdx;
   int endIdx = MathMax(startIdx - minBars, 0);
   
   for(int i = startIdx; i >= endIdx; i--)
   {
      if(mode == MODE_HIGH)
      {
         if(high[i] > high[peakIdx]) peakIdx = i;
      }
      else
      {
         if(low[i] < low[peakIdx]) peakIdx = i;
      }
   }
   return peakIdx;
}

//+------------------------------------------------------------------+
//| 辅助函数: 计算区间最高价                                         |
//+------------------------------------------------------------------+
double HighMax(int start, int end, const double &high[])
{
   double val = high[start];
   int step = (start < end) ? 1 : -1;
   for(int i = start; i != end; i += step)
      if(high[i] > val) val = high[i];
   return val;
}

//+------------------------------------------------------------------+
//| 辅助函数: 计算区间最低价                                         |
//+------------------------------------------------------------------+
double LowMin(int start, int end, const double &low[])
{
   double val = low[start];
   int step = (start < end) ? 1 : -1;
   for(int i = start; i != end; i += step)
      if(low[i] < val) val = low[i];
   return val;
}

//+------------------------------------------------------------------+
//| 判断底分型（增强版）                                             |
//+------------------------------------------------------------------+
bool IsBottomFractal(int idx, const double &low[], int verifyBars)
{
   // 中心点必须是低点
   if(low[idx] > low[idx-1] || low[idx] > low[idx+1])
      return false;
   
   // 左侧验证
   for(int i = 1; i <= verifyBars; i++)
   {
      if(low[idx-i] < low[idx] || low[idx+i] < low[idx])
         return false;
   }
   return true;
}

//+------------------------------------------------------------------+
//| 判断顶分型（增强版）                                             |
//+------------------------------------------------------------------+
bool IsTopFractal(int idx, const double &high[], int verifyBars)
{
   // 中心点必须是高点
   if(high[idx] < high[idx-1] || high[idx] < high[idx+1])
      return false;
   
   // 左侧验证
   for(int i = 1; i <= verifyBars; i++)
   {
      if(high[idx-i] > high[idx] || high[idx+i] > high[idx])
         return false;
   }
   return true;
}

//+------------------------------------------------------------------+
//| 判断低点是否抬高                                                 |
//+------------------------------------------------------------------+
bool IsHigherLow(int idx, int period, const double &low[])
{
   double currentLow = low[idx];
   for(int i = 1; i <= period; i++)
   {
      if(low[idx+i] < currentLow) return false;
      if(low[idx-i] < currentLow) return false;
   }
   return true;
}

//+------------------------------------------------------------------+
//| 判断高点是否降低                                                 |
//+------------------------------------------------------------------+
bool IsLowerHigh(int idx, int period, const double &high[])
{
   double currentHigh = high[idx];
   for(int i = 1; i <= period; i++)
   {
      if(high[idx+i] > currentHigh) return false;
      if(high[idx-i] > currentHigh) return false;
   }
   return true;
}

//+------------------------------------------------------------------+
//| 判断回踩中枢支撑                                                 |
//+------------------------------------------------------------------+
bool IsPullbackToZS(int idx, int period, double zsLevel, const double &price[])
{
   for(int i = 0; i < period; i++)
   {
      if(price[idx-i] <= zsLevel) return true;
   }
   return false;
}
//+------------------------------------------------------------------+

帮忙转换一下

Y1709833 发表于 2025-9-16 03:49
帮忙转换一下

   不会弄EA     谢谢

哇塞，大佬人太好了

这个指标加载出来特别乱，你试试吧。

Y1709833 发表于 2025-9-16 03:49
帮忙转换一下

你好，86楼自行下载。
把txt的文档转换了一个.mq4，一个.ex4文件，.mq4的就是源码。
不过在MT4里面加载的时候特别乱，你可以看看图片或者自己试试。

xinsanban186 发表于 2025-9-15 20:54
那算什么形态，你形容一下

阴K，开盘价大于均线，收盘价小于均线，均线与K交叉
阳K，开盘价小于均线，收盘价大于均线，均线与K交叉

yb_fox 发表于 2025-9-16 11:17
阴K，开盘价大于均线，收盘价小于均线，均线与K交叉
阳K，开盘价小于均线，收盘价大于均线，均线与K交叉 ...

有点乱了，最近写的有点多。
你重新整理一下整体思路吧，不要用你自己做单的思维，用程序能懂的思维，比如搜索，只能向左搜索，不能向右搜索。

xinsanban186 发表于 2025-9-16 12:28
有点乱了，最近写的有点多。
你重新整理一下整体思路吧，不要用你自己做单的思维，用程序能懂的思维，比 ...

买多：
打开EA当前阳K。向左搜索阴K（阴K满足开盘价大于均线，收盘价小于均线，并且均线与阴K交叉形态）
阳K收盘价大于此阴K最高价。MACD大于0轴线。
卖空：
打开EA当前阴K。向左搜索阳K（阳K满足开盘价小于均线，收盘价大于均线，并且均线与阳K交叉形态）
阴K收盘价小于阳K最低价。MACD小于0轴线。
止盈，止损，平保、移损。

修改后逻辑：
“多单建仓：
打开EA当前为阳线。向左搜索N根K线，找到一条K线满足阴线，开盘价大于均线，收盘价小于均线，并且均线与K线交叉形态，记录该条K线的最高价最低价，当前阳线收盘价大于记录的这根K线的最高价，并且MACD大于0轴线，多单进场“。
“空单建仓：
打开EA当前为阴线。向左搜索N根K线，找到一条K线满足阳线，开盘价小于均线，收盘价大于均线，并且均线与K线交叉形态，记录该条K线的最高价最低价，当前阴线收盘价小于阳K最低价。MACD小于0轴线，空单进场”

yb_fox 发表于 2025-9-16 14:47
买多：
打开EA当前阳K。向左搜索阴K（阴K满足开盘价大于均线，收盘价小于均线，并且均线与阴K交叉形态）
...

你好，91楼自行下载测试。

xinsanban186 发表于 2025-9-17 10:38
你好，91楼自行下载测试。

入场没问题，怎么加代码。同方向只做一单，现在一个K线一单，最后一单把前面利润又亏回去了

yb_fox 发表于 2025-9-17 18:38
入场没问题，怎么加代码。同方向只做一单，现在一个K线一单，最后一单把前面利润又亏回去了 ...

加个限制参数，同向单最大持仓单数

xinsanban186 发表于 2025-9-16 09:19
你好，86楼自行下载。
把txt的文档转换了一个.mq4，一个.ex4文件，.mq4的就是源码。
不过在MT4里面加载的 ...

好的  谢谢

NiuXdeID 发表于 2025-9-9 13:30
楼主效率很高啊，我找个时间测试看看，有什么想法再和你联系，谢谢

只要不是一美金震荡这个还是行得通的，利润也可以

dy008524 发表于 2025-9-20 12:12
只要不是一美金震荡这个还是行得通的，利润也可以

怕震荡，震荡久了还是会爆仓，个人感觉收益比不上马丁，风险一点也不比马丁小，我已放弃

xinsanban186 发表于 2025-9-2 17:43
布林带+斐波那契EA已完成，放在下面附件里了。

感谢老板！！
左上角的显示信息字有点小，这个能麻烦把字体调大一点吗？辛苦了

zhangyang123 发表于 2025-9-22 14:00
感谢老板！！
左上角的显示信息字有点小，这个能麻烦把字体调大一点吗？辛苦了 ...

你好，99楼自行下载，显示信息放大了1倍，足够清晰。

樓主大大
求您能幫我實現這個策略

一、策略名稱
純反轉策略

二、策略概念
此策略依據 K 線分型結構作為反轉訊號，提前於潛在反轉區間預掛 同方向4筆 Limit 掛單，以期捕捉價格回調後反彈／反壓後下跌的機會。

三、開倉邏輯
1. 進場訊號：
符合下列條件即判斷為「進場機會」：

使用設定時間框架（H4、H1）判斷是否出現 高點或低點分型（五根K線判斷：中間高於兩邊兩根為高點分型，低於為低點分型）。

當分型即將成形（可提前1根或等待成形條件達80%左右），即可執行掛單邏輯。

2. 掛單邏輯（以低點分型為例，掛多單 Buy Limit）
H4信號快成型或已成形時。用H1的現價的前一根K線價格掛單
H1信號快成型或已成形時。用M30的現價的前一根K線價格掛單

歷史掃描: EA啟動時掃描歷史分形並放置掛單

➤ 第一階段掛單（靠近現價）：
掛單1：前一根「陰線」的 Low

掛單2：前一根「陽線」的 Low

➤ 第二階段掛單（偏遠掛單）：
掛單3：前一根「陽線」的 High

掛單4：前一根「陰線」的 High

若為高點分型，則反向操作，掛 Sell Limit。

四、出場邏輯

使用固定止損與獲利（例如 SL/TP）統一止損 價格20美(2000點)/止盈價格20美(2000點)

加入追蹤止損/盈利保護機制（Trailing Stop）
價格移動2-3美時啟動，保護50%

五、掛單取消條件（必須實作）
1.新信號出現:取消舊信號的所有掛單

2.第二階段到期: 信號確認後若未進場，第3根K線時取消第二階段掛單

•H1策略: 3小時後

•H4策略: 12小時後


分型訊號被破壞（價格突破信號高低點）→則自動刪單、改用現價的前一條K線位置掛單，若未進場則掛至新進場信號出現


六、圖表顯示需求
畫出分型訊號（使用文字、箭頭等物件標示）

策略狀態: H1/H4

掛單統計: 各策略掛單數量統計

持倉統計: 各策略持倉數量統計

信號狀態: H1/H4信號方向和確認狀態(具開單還有幾%)

盈利統計: 各策略分別盈利和總盈利

虛擬止損監控: 追蹤訂單和保護狀態

成交量監控: 當前策略滿足度

七、EA 參數設定（可由用手動調整）
參數名稱        類型        說明
LotSize        double        單筆固定下單手數
Slippage        int        最大滑點容忍滑點
MagicNumber        int        用來區分訂單與其他策略
OrderExpiryBars        int        掛單的存活 K 棒數（逾期未成交則刪單）
UseFractalTimeframe        ENUM        使用哪個時間框架來偵測分型
OrderDistanceFilter        double        與前一次掛單價格的最小距離  5美(500點)（避免重複進場）
EnableBuy        bool        是否啟用多單策略
EnableSell        bool        是否啟用空單策略
MaxOrderCount        int        每方向最多同時掛幾筆單（建議上限4）
止盈止損位置(用點數表示)
盈利保護啟動位置(點數表示)

八、其他補充功能（開發建議）
記錄訊號觸發日誌（log output）方便除錯


可設定是否允許在同一根分型重複掛單（避免爆倉）

若有資金管理需求，可加入「自動手數」功能（依據帳戶餘額調整）