← К каталогу
Исходный код · ID 4784

Trend Flow Strategy

trendflowstrategy.mq5

Похожие материалы по тегам

ea12sd.mq4MQL4 / MetaTrader 4 · 1 общих теговindicator market map for tradingview.pineTradingView · 1 общих теговconfluenceforge_pro.mq5TradingView · 1 общих теговvolatility_gold_master.mq5MQL5 / MetaTrader 5 · 1 общих теговhamster scalping v 21.0.mq5MQL5 / MetaTrader 5 · 1 общих теговqqe of rsi(oma)(on chart).mq5MQL5 / MetaTrader 5 · 1 общих тегов
Вы автор или правообладатель?

Сообщите нам, если считаете, что материал размещён без разрешения.

Краткий обзор

О программе

«Trend Flow Strategy» — это Expert Advisor для MetaTrader 5, портированный с индикатора TradingView Pine Script v5. Советник реализует систему торговли на основе 20 различных стилей входа в позицию, включая стратегии на основе скользящих средних, RSI, MACD, полос Боллинджера, SuperTrend, стохастика и других технических индикаторов.

Перед открытием позиции советник применяет набор фильтров: фильтр объёма, фильтр ADX, фильтр VWAP и ограничение по временному окну. Это позволяет гибко настраивать условия формирования торговых сигналов.

Управление выходом из позиции поддерживает два режима: фиксированный стоп-лосс и тейк-профит на основе ATR, либо трейлинг-стоп с возможностью активации по дистанции от входа. При включённом трейлинге тейк-профит отключается.

Сигналы пересчитываются на каждом тике с использованием данных текущей формирующейся свечи, ордера исполняются по рыночной цене фиксированным лотом. Это обеспечивает близкое к оригиналу поведение стратегии с моментальной реакцией на изменения рынка.

Настройки программы

НастройкаОписание
InpTradeMode Выбор стиля входа в позицию из 20 доступных вариантов: пересечение EMA, сторона EMA, двойное пересечение EMA, RSI, MACD, Bollinger, SuperTrend, стохастик, Ишимоку, CMF, Parabolic SAR, Squeeze, уровни С/Р, Фибоначчи, VPVR, Weis Wave и Confluence Score.
InpEmaFast Период быстрой экспоненциальной скользящей средней EMA, используемой в стратегиях на основе EMA.
InpEmaSlow Период медленной экспоненциальной скользящей средней EMA, используемой в стратегиях на основе EMA.
InpRsiPeriod Период расчёта индикатора RSI, используемого в стратегиях на основе RSI.
InpAtrPeriod Период расчёта ATR, используемый для измерения волатильности и определения расстояния стоп-лосса и тейк-профита.
InpVolFilter Порог фильтра объёма: текущий объём должен превышать SMA20 объёма, умноженный на это значение, для прохождения фильтра.
InpUseAdx Включение или отключение фильтра по индикатору ADX. При выключенном фильтре ADX не влияет на генерацию сигналов.
InpAdxPeriod Период расчёта индикатора ADX, определяющий усреднение трендовой силы.
InpAdxMin Минимальное значение ADX, при котором фильтр считается пройденным; если ADX ниже этого порога, сигналы блокируются (при включённом фильтре).
InpVwapMode Режим применения VWAP как фильтра: выключен, по стороне (цена относительно VWAP) или по пересечению.
InpLookbackDays Ограничение времени для сигналов: сигналы генерируются только в последние N дней. Значение 0 означает все доступные данные.
InpStopMult Множитель ATR для расчёта расстояния стоп-лосса от цены входа.
InpTpMult Множитель ATR для расчёта тейк-профита. Используется только когда трейлинг-стоп отключён.
InpTrailMult Множитель ATR для определения дистанции трейлинг-стопа от текущей цены.
InpUseTrail Включение трейлинг-стопа. При активном трейлинге тейк-профит не выставляется; при выключенном трейлинге используются фиксированные стоп-лосс и тейк-профит.
InpMacdF Быстрая длина для расчёта линии MACD.
InpMacdS Медленная длина для расчёта линии MACD.
InpMacdSig Период сглаживания сигнальной линии MACD.
InpBbLen Период расчёта средней полосы Боллинджера.
InpBbWidth Множитель стандартного отклонения для ширины полос Боллинджера.
InpStochLen Период расчёта raw %K стохастика.
InpStochSm Период сглаживания линии %D стохастика (SMA от raw %K).
InpSuperLen Период ATR, используемый для расчёта индикатора SuperTrend.
InpSuperMult Множитель ATR для расчёта дистанции SuperTrend от цены.
InpSrLen Глубина поиска максимумов и минимумов для определения уровней поддержки и сопротивления.
InpVpvrLen Глубина расчёта VPVR (Volume Profile Visible Range) на основе объёмно-взвешенной средней цены.
InpFibLen Глубина диапазона для расчёта уровней Фибоначчи, используемых в стратегии отскока.
InpLots Размер лота для каждого ордера, фиксированный для всех сделок.
InpMagic Магический номер, идентифицирующий ордера, открытые данным советником, для управления и закрытия позиций.
InpDeviationPts Максимальное допустимое отклонение цены ордера от запрашиваемой в пунктах (скользжение).

Поиск по коду файла

#property version     "1.00"
#property description "Full MQL5 port of the TradingView Pine v5 'Trend Flow Strategy'."
#property description "Every-tick signal engine, fixed lots, Pine-faithful exits."

#include <Trade\Trade.mqh>

enum ENUM_ENTRY_MODE
  {
   EM_EMA_CROSS = 0,        // ema_cross
   EM_EMA_SIDE,             // ema_side
   EM_DUAL_EMA_CROSS,       // dual_ema_cross
   EM_RSI_REVERSAL,         // rsi_reversal
   EM_RSI_TREND,            // rsi_trend
   EM_MACD_CROSS,           // macd_cross
   EM_BB_REVERSION,         // bb_reversion
   EM_BB_BREAKOUT,          // bb_breakout
   EM_SUPERTREND_FLIP,      // supertrend_flip
   EM_SUPERTREND_EMA,       // supertrend_ema
   EM_STOCH_REVERSAL,       // stoch_reversal
   EM_ICHIMOKU_BREAKOUT,    // ichimoku_breakout
   EM_CMF_EMA,              // cmf_ema
   EM_PSAR_FLIP,            // psar_flip
   EM_SQUEEZE_BREAKOUT,     // squeeze_breakout
   EM_SR_BREAKOUT,          // sr_breakout
   EM_FIB_BOUNCE,           // fib_bounce
   EM_VPVR_BREAKOUT,        // vpvr_breakout
   EM_WEIS_WAVE_TREND,      // weis_wave_trend
   EM_CONFLUENCE_SCORE      // confluence_score
  };

enum ENUM_VWAP_MODE
  {
   VWAP_OFF   = 0,          // off
   VWAP_SIDE  = 1,          // side
   VWAP_CROSS = 2           // cross
  };

input group "====== Entry Style & Filters (Pine inputs) ======"
input ENUM_ENTRY_MODE InpTradeMode     = EM_EMA_CROSS; // trade_mode - Entry Style
input int             InpEmaFast       = 5;            // ema_fast - Fast EMA
input int             InpEmaSlow       = 21;           // ema_slow - Slow EMA
input int             InpRsiPeriod     = 21;           // rsi_period - RSI Period
input int             InpAtrPeriod     = 7;            // atr_period - ATR Period
input double          InpVolFilter     = 0.35;         // vol_filter - Volume Filter (x SMA20 of volume)
input bool            InpUseAdx        = true;         // use_adx - Use ADX Filter
input int             InpAdxPeriod     = 21;           // adx_period - ADX Period
input int             InpAdxMin        = 0;            // adx_min - ADX Minimum
input ENUM_VWAP_MODE  InpVwapMode      = VWAP_OFF;     // vwap_style - VWAP Mode
input int             InpLookbackDays  = 0;            // lookback_days - Limit signals to recent N days (0=all)

input group "====== Exits ======"
input double          InpStopMult      = 2.0;          // stop_mult - Stop Loss (x ATR)
input double          InpTpMult        = 1.25;         // tp_mult - Take Profit (x ATR, only when trailing OFF)
input double          InpTrailMult     = 0.02;         // trail_mult - Trail Distance (x ATR)
input bool            InpUseTrail      = true;         // use_trail - Use Trailing Stop (no TP while ON)

input group "====== MACD ======"
input int             InpMacdF         = 12;           // Fast Length
input int             InpMacdS         = 26;           // Slow Length
input int             InpMacdSig       = 9;            // Signal Length

input group "====== Bollinger ======"
input int             InpBbLen         = 14;           // BB Length
input double          InpBbWidth       = 2.0;          // BB Std Dev

input group "====== Stochastic ======"
input int             InpStochLen      = 9;            // Stoch Length
input int             InpStochSm       = 3;            // Stoch Smoothing (%D)

input group "====== SuperTrend ======"
input int             InpSuperLen      = 14;           // SuperTrend ATR Length
input double          InpSuperMult     = 3.0;          // SuperTrend Multiplier

input group "====== S/R - VPVR - Fibonacci ======"
input int             InpSrLen         = 40;           // sr_len - S/R Lookback
input int             InpVpvrLen       = 120;          // vpvr_len - VPVR Lookback (volume-weighted MA)
input int             InpFibLen        = 120;          // fib_len - Fibonacci Lookback

input group "====== Execution ======"
input double          InpLots          = 0.02;         // Order size in lots (Pine: fixed 2,000 units)
input long            InpMagic         = 526260;       // Magic number
input int             InpDeviationPts  = 20;           // Max deviation in points (Pine slippage=20 ticks)

CTrade   trade;

int      hEmaFast = INVALID_HANDLE;
int      hEmaSlow = INVALID_HANDLE;
int      hAtr     = INVALID_HANDLE;   // ATR(atr_period) - exits
int      hAtr20   = INVALID_HANDLE;   // ATR(20)         - squeeze
int      hAtrST   = INVALID_HANDLE;   // ATR(super_len)  - supertrend
int      hRsi     = INVALID_HANDLE;
int      hAdx     = INVALID_HANDLE;
int      hSar     = INVALID_HANDLE;

MqlRates g_r[];
double   g_emaF[], g_emaS[];
double   g_atr[], g_atr20[], g_atrST[];
double   g_rsi[], g_adx[], g_sar[];
double   g_macd[], g_sig[];

int      g_bars    = 1500;             // rolling window (bars)
double   g_atr0    = 0.0;              // live ATR(atr_period)
double   g_stDir0  = 0.0, g_stDir1 = 0.0;
double   g_ww0     = 0.0, g_ww1   = 0.0;
bool     g_goLong  = false;
bool     g_goShort = false;

int OnInit()
  {
      // код доступен только после оплаты
   }

void OnDeinit(const int reason)
  {
   if(hEmaFast != INVALID_HANDLE) IndicatorRelease(hEmaFast);
   if(hEmaSlow != INVALID_HANDLE) IndicatorRelease(hEmaSlow);
   if(hAtr     != INVALID_HANDLE) IndicatorRelease(hAtr);
   if(hAtr20   != INVALID_HANDLE) IndicatorRelease(hAtr20);
   if(hAtrST   != INVALID_HANDLE) IndicatorRelease(hAtrST);
   if(hRsi     != INVALID_HANDLE) IndicatorRelease(hRsi);
   if(hAdx     != INVALID_HANDLE) IndicatorRelease(hAdx);
   if(hSar     != INVALID_HANDLE) IndicatorRelease(hSar);
  }

void OnTick()
  {
      // код доступен только после оплаты
   }

bool UpdateData()
  {
   int avail = Bars(_Symbol, _Period);
   if(avail < 300)
      return(false);
   g_bars = MathMin(1500, avail);

   if(CopyRates (_Symbol, _Period, 0, g_bars, g_r)    != g_bars) return(false);
   if(CopyBuffer(hEmaFast, 0, 0, g_bars, g_emaF)      != g_bars) return(false);
   if(CopyBuffer(hEmaSlow, 0, 0, g_bars, g_emaS)      != g_bars) return(false);
   if(CopyBuffer(hAtr,     0, 0, g_bars, g_atr)       != g_bars) return(false);
   if(CopyBuffer(hAtr20,   0, 0, g_bars, g_atr20)     != g_bars) return(false);
   if(CopyBuffer(hAtrST,   0, 0, g_bars, g_atrST)     != g_bars) return(false);
   if(CopyBuffer(hRsi,     0, 0, g_bars, g_rsi)       != g_bars) return(false);
   if(CopyBuffer(hAdx,     0, 0, g_bars, g_adx)       != g_bars) return(false);
   if(CopyBuffer(hSar,     0, 0, g_bars, g_sar)       != g_bars) return(false);

   Sanitize(g_emaF);
   Sanitize(g_emaS);
   Sanitize(g_atr);
   Sanitize(g_atr20);
   Sanitize(g_atrST);
   Sanitize(g_rsi);
   Sanitize(g_adx);
   Sanitize(g_sar);

   ArrayResize(g_macd, g_bars);
   ArrayResize(g_sig,  g_bars);
   for(int k = 0; k < g_bars; k++)
      g_macd[k] = g_emaF[k] - g_emaS[k];
   double alpha = 2.0 / (InpMacdSig + 1.0);
   g_sig[g_bars - 1] = g_macd[g_bars - 1];
   for(int k = g_bars - 2; k >= 0; k--)
      g_sig[k] = alpha * g_macd[k] + (1.0 - alpha) * g_sig[k + 1];

   ComputeSuperTrendDirs(InpSuperMult, g_stDir0, g_stDir1);
   ComputeWeis(g_ww0, g_ww1);

   return(true);
  }

void ComputeSignals()
  {
   g_goLong  = false;
   g_goShort = false;
   if(g_bars < 3)
      return;

   g_atr0 = g_atr[0];
   if(g_atr0 <= 0.0)
      return;

   double c0 = g_r[0].close;      // live bar (Pine 'close' on every tick)
   double o0 = g_r[0].open;
   double h0 = g_r[0].high;
   double l0 = g_r[0].low;
   double c1 = g_r[1].close;
   bool   up = c0 > o0;
   bool   dn = c0 < o0;

   double ef0 = g_emaF[0], ef1 = g_emaF[1];
   double es0 = g_emaS[0], es1 = g_emaS[1];
   double rsi0 = g_rsi[0], rsi1 = g_rsi[1];
   double adx0 = g_adx[0];
   double sar0 = g_sar[0], sar1 = g_sar[1];
   int    psD0 = (c0 > sar0) ? 1 : -1;
   int    psD1 = (c1 > sar1) ? 1 : -1;
   double m0 = g_macd[0], m1 = g_macd[1];
   double s0 = g_sig[0],  s1 = g_sig[1];

   double bu0 = SmaC(0, InpBbLen) + InpBbWidth * SdC(0, InpBbLen);
   double bl0 = SmaC(0, InpBbLen) - InpBbWidth * SdC(0, InpBbLen);
   double bu1 = SmaC(1, InpBbLen) + InpBbWidth * SdC(1, InpBbLen);
   double bl1 = SmaC(1, InpBbLen) - InpBbWidth * SdC(1, InpBbLen);

   double k0 = RawK(0, InpStochLen), k1 = RawK(1, InpStochLen);
   double d0 = StochD(0),            d1 = StochD(1);

   double tnk0 = (Hi(0, 9)  + Lo(0, 9))  * 0.5;
   double kjn0 = (Hi(0, 26) + Lo(0, 26)) * 0.5;

   double cmf0 = ComputeCmf0();
   bool   sqz0 = SqueezeAt(0);
   bool   sqz1 = SqueezeAt(1);
   double mom0 = SqueezeMom0();
   double r1_1 = Hi(1, InpSrLen);
   double s1_1 = Lo(1, InpSrLen);
   double fhh  = Hi(0, InpFibLen);
   double fll  = Lo(0, InpFibLen);
   double frr  = fhh - fll;
   double f382 = fhh - frr * 0.382;
   double f618 = fhh - frr * 0.618;
   double poc0 = VwmaC(0, InpVpvrLen);
   double poc1 = VwmaC(1, InpVpvrLen);

   bool buy = false, sell = false;
   switch(InpTradeMode)
     {
      case EM_EMA_CROSS:
         buy  = up && CrossUp(c1, c0, ef1, ef0);
         sell = dn && CrossDn(c1, c0, ef1, ef0);
         break;
      case EM_EMA_SIDE:
         buy  = up && c0 > ef0;
         sell = dn && c0 < ef0;
         break;
      case EM_DUAL_EMA_CROSS:
         buy  = up && CrossUp(ef1, ef0, es1, es0);
         sell = dn && CrossDn(ef1, ef0, es1, es0);
         break;
      case EM_RSI_REVERSAL:
         buy  = rsi1 <= 30.0 && rsi0 > 30.0;
         sell = rsi1 >= 70.0 && rsi0 < 70.0;
         break;
      case EM_RSI_TREND:
         buy  = c0 > ef0 && rsi0 > 55.0;
         sell = c0 < ef0 && rsi0 < 45.0;
         break;
      case EM_MACD_CROSS:
         buy  = CrossUp(m1, m0, s1, s0);
         sell = CrossDn(m1, m0, s1, s0);
         break;
      case EM_BB_REVERSION:
         buy  = c1 < bl1 && c0 > bl0;
         sell = c1 > bu1 && c0 < bu0;
         break;
      case EM_BB_BREAKOUT:
         buy  = c0 > bu0 && up;
         sell = c0 < bl0 && dn;
         break;
      case EM_SUPERTREND_FLIP:

         buy  = g_stDir0 > 0.0 && g_stDir1 < 0.0;
         sell = g_stDir0 < 0.0 && g_stDir1 > 0.0;
         break;
      case EM_SUPERTREND_EMA:

         buy  = g_stDir0 > 0.0 && c0 > ef0;
         sell = g_stDir0 < 0.0 && c0 < ef0;
         break;
      case EM_STOCH_REVERSAL:
         buy  = k1 < 20.0 && CrossUp(k1, k0, d1, d0);
         sell = k1 > 80.0 && CrossDn(k1, k0, d1, d0);
         break;
      case EM_ICHIMOKU_BREAKOUT:
         buy  = c0 > MathMax(tnk0, kjn0) && tnk0 > kjn0;
         sell = c0 < MathMin(tnk0, kjn0) && tnk0 < kjn0;
         break;
      case EM_CMF_EMA:
         buy  = c0 > ef0 && cmf0 > 0.05;
         sell = c0 < ef0 && cmf0 < -0.05;
         break;
      case EM_PSAR_FLIP:
         buy  = psD0 > 0 && psD1 < 0;
         sell = psD0 < 0 && psD1 > 0;
         break;
      case EM_SQUEEZE_BREAKOUT:
         buy  = sqz1 && !sqz0 && mom0 > 0.0;
         sell = sqz1 && !sqz0 && mom0 < 0.0;
         break;
      case EM_SR_BREAKOUT:
         buy  = c0 > r1_1 && up;
         sell = c0 < s1_1 && dn;
         break;
      case EM_FIB_BOUNCE:
         buy  = l0 <= f618 && c0 > f382 && c0 > ef0;
         sell = h0 >= f382 && c0 < f618 && c0 < ef0;
         break;
      case EM_VPVR_BREAKOUT:
         buy  = CrossUp(c1, c0, poc1, poc0) && c0 > ef0;
         sell = CrossDn(c1, c0, poc1, poc0) && c0 < ef0;
         break;
      case EM_WEIS_WAVE_TREND:
         buy  = g_ww0 > g_ww1 && c0 > ef0;
         sell = g_ww0 < g_ww1 && c0 < ef0;
         break;
      case EM_CONFLUENCE_SCORE:
        {

         int v1 = (c0 > ef0 ? 1 : 0) + (rsi0 > 55.0 ? 1 : 0) +
                  ((m0 - s0) > 0.0 ? 1 : 0) + (g_stDir0 > 0.0 ? 1 : 0) +
                  (cmf0 > 0.0 ? 1 : 0);
         int v2 = (c0 < ef0 ? 1 : 0) + (rsi0 < 45.0 ? 1 : 0) +
                  ((m0 - s0) < 0.0 ? 1 : 0) + (g_stDir0 < 0.0 ? 1 : 0) +
                  (cmf0 < 0.0 ? 1 : 0);
         buy  = v1 >= 4 && v1 > v2 && up;
         sell = v2 >= 4 && v2 > v1 && dn;
         break;
        }
      default:
         break;
     }

   bool volGood = (double)g_r[0].tick_volume > SmaV(0, 20) * InpVolFilter;
   bool adxGood = !InpUseAdx || adx0 >= (double)InpAdxMin;

   double vwap0 = VwapAt(0);
   double vwap

Показано первые 50% кода (символов: 18181)