東京時間はおとなしいのに、ロンドン時間に入った瞬間だけ急に動き出す。

そんな通貨ペアのクセを、値幅(レンジ)の比率で自動的に判定して、

人がチャートに張り付かなくてもエントリーできるようにしたい。

この記事では、既刊の「セッション別値幅比較インジケーター」が行っていた、

東京・ロンドン・NYそれぞれのセッションの平均値幅(pips)を計算するロジックを、

表示用ではなく発注条件としてEAに転用します。

今のセッションの値幅が過去の平均を大きく上回ったときだけブレイクアウトとして順張りし、

逆に値幅が小さすぎるセッションはボラティリティフィルターとして見送る、

2つの役割を1つの比率で実現する設計です。

この記事で分かること: 既刊インジケーターの計算ロジックを

発注条件に転用する方法が分かります。

「過去の完了済みセッションの平均」と、

「現在進行中のセッションの値幅」を分けて計算する方法が分かります。

値幅の比率でブレイクアウトと見送りの両方を判定する方法が分かります。

損切り必須、ポジション重複防止、

同一セッション内の再エントリー防止の実装方法が分かります。

  1. 設計思想:セッション別値幅比較インジケーターの計算ロジックをEAの発注条件に転用する
    1. 既刊インジケーターとの関係
    2. EA化にあたっての簡略化:対象シンボルを1つに絞る理由
    3. 既刊ATRボラティリティフィルターEAとの判定対象の違い
  2. 3つのセッションの定義とセッション判定
    1. 日付をまたぐセッションの判定
    2. 現在どのセッション中かを判定する
    3. サーバー時間のズレに関する注意
  3. 過去の平均値幅と「現在進行中のセッションの値幅」を別々に計算する
    1. 現在進行中のセッションのバー本数を数える
    2. 過去の完了済みセッションだけで平均値幅を計算する
    3. 現在進行中のセッションの値幅だけを計算する
  4. 値幅の比率でブレイクアウト・見送りを判定する
    1. 比率が低すぎる場合は見送る(ボラティリティフィルター)
    2. 比率が一定を超えたらブレイクアウト候補とする
    3. ブレイクアウトの方向(買い/売り)をどう決めるか
  5. 損切り必須・ポジション重複防止・同一セッション内の再エントリー防止
    1. 固定pipsの損切りを必ず設定する
    2. マジックナンバーで同一EAのポジション重複を防ぐ
    3. 同じセッション内で2回エントリーしない仕組み
  6. 実際に動くコード全体
  7. MetaEditorでのコンパイル・バックテスト手順
  8. よくある質問
    1. このEAは複数の通貨ペアを同時に監視できますか?
    2. 適用直後にエントリーが起きないときに確認すること
    3. ブレイクアウト方向と逆に動いたらどうなりますか?
    4. 既刊ATRボラティリティフィルターEAと組み合わせて使えますか?
  9. 【MQL4】セッション別値幅比較インジケーターの計算ロジックをEAに転用。値幅のブレイクアウトで順張りし、動きが乏しいセッションは見送るEAの作り方:まとめ
    1. 関連記事

設計思想:セッション別値幅比較インジケーターの計算ロジックをEAの発注条件に転用する

まず、このEAが何を計算し、何を判定するのかを整理します。

既刊インジケーターとの関係

セッション別値幅比較インジケーターの記事では、東京・ロンドン・NYの各セッションの平均値幅(pips)を、

複数の通貨ペアで横並びに比較表示するところまでを扱いました。

この記事は、あくまで「確認用」のインジケーターで、発注は一切行いません。

本記事では、その計算ロジックをそのまま使い、

「今のセッションの値幅が普段と比べて大きいか・小さいか」を、

実際のエントリー判断に変える方法を解説します。

EA化にあたっての簡略化:対象シンボルを1つに絞る理由

簡略化の判断: 既刊インジケーターは、チャートに表示していない

通貨ペアもSymbolSelectで取得し、

複数ペアを横並びに比較する設計でした。

一方、EAは基本的に1つのチャート(1つのシンボル)に対して発注するものです。

そのため本記事のEAは、チャートに適用されたシンボル(`_Symbol`)

1つだけを対象にし、複数ペアの比較機能は持たせません。

複数ペアを同時に監視したい場合は、

同じEAを別のシンボルのチャートにもう1つ適用してください。

既刊ATRボラティリティフィルターEAとの判定対象の違い

このサイトには、ATRの比率でボラティリティが低い相場のエントリーを見送るフィルターEAの記事も既にあります。

どちらも「値動きの大きさを比率で判定する」という点は同じですが、

判定対象がまったく異なります。

既刊ATRボラティリティフィルターEA 本記事のセッション値幅ブレイクアウトEA
判定対象 ATR(真の値幅)の直近平均 ÷ 長期平均 セッション(東京・ロンドン・NY)ごとの値幅 ÷ 同じセッションの過去平均
時間帯の意味 時間帯を区別せず、常に同じ基準で判定する 「今のセッションは、同じ時間帯の普段と比べてどうか」を判定する
発注での役割 別のエントリーロジック(MAクロス)にかける『フィルター』専用 比率そのものを『発注のきっかけ(ブレイクアウト)』と『見送り判定(フィルター)』の両方に使う

ATR比率は「相場全体が今どれくらい動きやすいか」を見るのに向いていますが、

セッション値幅比率は「東京時間なのにロンドン時間並みに動いている」

といった、時間帯特有のクセのズレを捉えるのに向いています。

3つのセッションの定義とセッション判定

既刊インジケーターと同じ、東京・ロンドン・NYのセッション定義を使います。

日付をまたぐセッションの判定

bool IsInSession(int hour, int startHour, int endHour)
  {
   if(startHour < endHour)
      return(hour >= startHour && hour < endHour);
   else
      return(hour >= startHour || hour < endHour); // 日付をまたぐ場合(NY等)
  }

開始時刻が終了時刻より大きい場合(21時〜5時等)は、日付をまたぐセッションとして、

OR条件で判定します。

既刊インジケーターのIsInSession()を1文字も変えずに再利用しています。

現在どのセッション中かを判定する

bool GetCurrentSessionHours(int &startHour, int &endHour)
  {
   int hour = TimeHour(TimeCurrent());

   if(IsInSession(hour, InpTokyoStart, InpTokyoEnd))
     {
      startHour = InpTokyoStart;
      endHour   = InpTokyoEnd;
      return(true);
     }
   if(IsInSession(hour, InpLondonStart, InpLondonEnd))
     {
      startHour = InpLondonStart;
      endHour   = InpLondonEnd;
      return(true);
     }
   if(IsInSession(hour, InpNYStart, InpNYEnd))
     {
      startHour = InpNYStart;
      endHour   = InpNYEnd;
      return(true);
     }
   return(false);
  }

東京・ロンドン・NYのどの時間帯にも当てはまらない場合はfalseを返し、

その間はエントリー判定そのものを行いません。

サーバー時間のズレに関する注意

注意: この時間帯はブローカーのサーバー時間を基準にした一例です。

サーバーのGMTオフセットはブローカーごとに異なるため、

実際の東京、ロンドン、NY時間とズレる場合があります。

入力パラメータ(InpTokyoStart等)で、

必ず自分のブローカーに合わせて調整してください。

過去の平均値幅と「現在進行中のセッションの値幅」を別々に計算する

本記事の核となる部分です。

既刊インジケーターは1つの計算で済ませていましたが、EAでは「比較する基準」

と「比較される対象」を分けて計算する必要があります。

現在進行中のセッションのバー本数を数える

int CountCurrentSessionBars(int startHour, int endHour)
  {
   int totalBars = iBars(_Symbol, PERIOD_H1);
   if(!IsInSession(TimeHour(iTime(_Symbol, PERIOD_H1, 0)), startHour, endHour))
      return(0);

   int i = 0;
   while(i < totalBars && IsInSession(TimeHour(iTime(_Symbol, PERIOD_H1, i)), startHour, endHour))
      i++;
   return(i); // 現在のセッションのバー本数(index 0〜i-1)
  }

直近のバー(index0)から数えて、同じセッションが何本連続しているかを数えます。

この本数が、後の2つの計算を分けるための境界線になります。

過去の完了済みセッションだけで平均値幅を計算する

double ComputeAverageSessionRange(int startHour, int endHour, int lookbackDays, int skipBars)
  {
   double point = PointAdjust();
   int totalBars = iBars(_Symbol, PERIOD_H1);
   double sumRange = 0;
   int dayCount = 0;

   int i = skipBars;
   while(i < totalBars && dayCount < lookbackDays)
     {
      int hour = TimeHour(iTime(_Symbol, PERIOD_H1, i));

      if(IsInSession(hour, startHour, endHour))
        {
         double sessionHigh = iHigh(_Symbol, PERIOD_H1, i);
         double sessionLow  = iLow(_Symbol, PERIOD_H1, i);
         int j = i;
         while(j < totalBars && IsInSession(TimeHour(iTime(_Symbol, PERIOD_H1, j)), startHour, endHour))
           {
            sessionHigh = MathMax(sessionHigh, iHigh(_Symbol, PERIOD_H1, j));
            sessionLow  = MathMin(sessionLow,  iLow(_Symbol, PERIOD_H1, j));
            j++;
           }
         sumRange += (sessionHigh - sessionLow) / point;
         dayCount++;
         i = j;
        }
      else
        {
         i++;
        }
     }

   if(dayCount == 0)
      return(0);
   return(sumRange / dayCount);
  }

既刊インジケーターのComputeAverageSessionRange()と、

ほぼ同じですが、先頭から`skipBars`本だけ読み飛ばしてから、

計算を始める点が異なります。

この読み飛ばしによって、「現在進行中で、まだ確定していないセッション」

を、平均の計算対象から除外できます。

現在進行中のセッションの値幅だけを計算する

double CurrentSessionRangeSoFar(int sessionBars)
  {
   double point = PointAdjust();
   double high = iHigh(_Symbol, PERIOD_H1, 0);
   double low  = iLow(_Symbol, PERIOD_H1, 0);

   for(int i = 1; i < sessionBars; i++)
     {
      high = MathMax(high, iHigh(_Symbol, PERIOD_H1, i));
      low  = MathMin(low,  iLow(_Symbol, PERIOD_H1, i));
     }
   return((high - low) / point);
  }

先ほど数えた`sessionBars`本の範囲だけで、

高値・安値を追跡して値幅を計算します。

これが「今のセッションが、ここまでどれだけ動いたか」を示す値になります。

値幅の比率でブレイクアウト・見送りを判定する

2つの値幅が計算できたら、その比率で3種類の状態に分けます。

比率が低すぎる場合は見送る(ボラティリティフィルター)

double ratio = curRange / avgRange;

if(ratio < InpMinRangeRatio)
   return; // 値幅が小さすぎるセッション:ボラティリティフィルターで見送る

今のセッションの値幅が、過去の平均に対して小さすぎる場合は、

「動きが乏しいセッション」と判断してエントリーを見送ります。

これは既刊ATRボラティリティフィルターEAと同じ考え方の『見送り』機能です。

比率が一定を超えたらブレイクアウト候補とする

if(ratio < InpBreakoutRatio)
   return; // まだブレイクアウトの基準に達していない

比率が`InpMinRangeRatio`以上でも、

`InpBreakoutRatio`(初期値1.3)に達していなければ、

「普段通りのセッション」としてまだエントリーしません。

ブレイクアウトの方向(買い/売り)をどう決めるか

double priorHigh = iHigh(_Symbol, PERIOD_H1, 1);
double priorLow  = iLow(_Symbol, PERIOD_H1, 1);
for(int k = 2; k < sessionBars; k++)
  {
   priorHigh = MathMax(priorHigh, iHigh(_Symbol, PERIOD_H1, k));
   priorLow  = MathMin(priorLow,  iLow(_Symbol, PERIOD_H1, k));
  }

値幅の比率が基準を超えたら、今のセッション内で「まだ確定している」

バー(index1以降)だけの高値・安値を求めます。

現在値(Bid)がこの高値を上回っていれば買い、安値を下回っていれば売り、

というシンプルな順張りルールにしています。

損切り必須・ポジション重複防止・同一セッション内の再エントリー防止

発注まわりの安全策を、既刊EA群の標準パターンに沿って実装します。

固定pipsの損切りを必ず設定する

double sl = Ask - InpStopLossPips * point; //買いの場合
double sl = Bid + InpStopLossPips * point; //売りの場合

OrderSendのstoploss引数に必ず値を渡すようにし、

損切りを設定しないまま発注することはありません。

マジックナンバーで同一EAのポジション重複を防ぐ

bool HasOpenPosition()
  {
   for(int i = 0; i < OrdersTotal(); i++)
     {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
         if(OrderSymbol() == _Symbol && OrderMagicNumber() == InpMagicNumber)
            return(true);
        }
     }
   return(false);
  }

同じシンボル・同じマジックナンバーの保有ポジションが1つでもあれば、

新規のエントリー判定そのものを行いません。

同じセッション内で2回エントリーしない仕組み

datetime sessionStartTime = iTime(_Symbol, PERIOD_H1, sessionBars - 1);
if(sessionStartTime == lastTradedSessionStart)
   return; // このセッションでは既にエントリー済み

ポジション決済後にもう一度条件を満たしてしまうと、

同じブレイクアウトに対して何度もエントリーしてしまう可能性があります。

今のセッションの開始時刻を記録しておき、

同じセッション開始時刻であれば再エントリーしないようにしています。

実際に動くコード全体

ここまでの要素をまとめた、実際にMetaEditorでコンパイルできるコードです。

//+------------------------------------------------------------------+
//|                                   SessionRangeBreakoutEA.mq4      |
//|                     Copyright 2026, FX-EA System Project Creator |
//|                        https://creator.fx-ea-system-project.com/ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, FX-EA System Project Creator"
#property link      "https://creator.fx-ea-system-project.com/"
#property version   "1.00"
#property strict

input int    InpLookbackDays     = 10;    //過去何回分のセッションを平均に使うか
input double InpMinRangeRatio    = 0.5;   //この比率未満ならエントリーを見送る(フィルター)
input double InpBreakoutRatio    = 1.3;   //この比率を超えたらブレイクアウトとみなす
input int    InpTokyoStart       = 9;     //東京セッション開始(サーバー時間)
input int    InpTokyoEnd         = 15;    //東京セッション終了(サーバー時間)
input int    InpLondonStart      = 16;    //ロンドンセッション開始(サーバー時間)
input int    InpLondonEnd        = 24;    //ロンドンセッション終了(サーバー時間)
input int    InpNYStart          = 21;    //NYセッション開始(サーバー時間、日付をまたぐ)
input int    InpNYEnd            = 5;     //NYセッション終了(サーバー時間、日付をまたぐ)
input int    InpStopLossPips     = 30;    //損切り(pips)
input double InpLots             = 0.1;   //注文ロット数
input int    InpMagicNumber      = 20261116; //マジックナンバー

datetime lastTradedSessionStart = 0;

//+------------------------------------------------------------------+
//| 単一シンボルのみを対象にするため_Point/_Digitsで桁数を調整する          |
//+------------------------------------------------------------------+
double PointAdjust()
  {
   double point = _Point;
   if(_Digits == 3 || _Digits == 5)
      point *= 10;
   return(point);
  }

//+------------------------------------------------------------------+
//| 日付をまたぐセッションも判定できる時間帯チェック                        |
//+------------------------------------------------------------------+
bool IsInSession(int hour, int startHour, int endHour)
  {
   if(startHour < endHour)
      return(hour >= startHour && hour < endHour);
   else
      return(hour >= startHour || hour < endHour);
  }

//+------------------------------------------------------------------+
//| 現在のサーバー時間がどのセッションかを判定し、開始・終了時刻を返す         |
//+------------------------------------------------------------------+
bool GetCurrentSessionHours(int &startHour, int &endHour)
  {
   int hour = TimeHour(TimeCurrent());

   if(IsInSession(hour, InpTokyoStart, InpTokyoEnd))
     {
      startHour = InpTokyoStart;
      endHour   = InpTokyoEnd;
      return(true);
     }
   if(IsInSession(hour, InpLondonStart, InpLondonEnd))
     {
      startHour = InpLondonStart;
      endHour   = InpLondonEnd;
      return(true);
     }
   if(IsInSession(hour, InpNYStart, InpNYEnd))
     {
      startHour = InpNYStart;
      endHour   = InpNYEnd;
      return(true);
     }
   return(false);
  }

//+------------------------------------------------------------------+
//| バーindex0から、現在進行中のセッションのバーが何本連続しているかを返す     |
//+------------------------------------------------------------------+
int CountCurrentSessionBars(int startHour, int endHour)
  {
   int totalBars = iBars(_Symbol, PERIOD_H1);
   if(!IsInSession(TimeHour(iTime(_Symbol, PERIOD_H1, 0)), startHour, endHour))
      return(0);

   int i = 0;
   while(i < totalBars && IsInSession(TimeHour(iTime(_Symbol, PERIOD_H1, i)), startHour, endHour))
      i++;
   return(i);
  }

//+------------------------------------------------------------------+
//| 過去の完了済みセッションだけを対象に平均値幅(pips)を計算する              |
//| (既刊session-range-comparison-indicator-mt4.mdのロジックを転用、     |
//|  skipBars本だけ先頭から読み飛ばして現在進行中のセッションを除外する)      |
//+------------------------------------------------------------------+
double ComputeAverageSessionRange(int startHour, int endHour, int lookbackDays, int skipBars)
  {
   double point = PointAdjust();
   int totalBars = iBars(_Symbol, PERIOD_H1);
   double sumRange = 0;
   int dayCount = 0;

   int i = skipBars;
   while(i < totalBars && dayCount < lookbackDays)
     {
      int hour = TimeHour(iTime(_Symbol, PERIOD_H1, i));

      if(IsInSession(hour, startHour, endHour))
        {
         double sessionHigh = iHigh(_Symbol, PERIOD_H1, i);
         double sessionLow  = iLow(_Symbol, PERIOD_H1, i);
         int j = i;
         while(j < totalBars && IsInSession(TimeHour(iTime(_Symbol, PERIOD_H1, j)), startHour, endHour))
           {
            sessionHigh = MathMax(sessionHigh, iHigh(_Symbol, PERIOD_H1, j));
            sessionLow  = MathMin(sessionLow,  iLow(_Symbol, PERIOD_H1, j));
            j++;
           }
         sumRange += (sessionHigh - sessionLow) / point;
         dayCount++;
         i = j;
        }
      else
        {
         i++;
        }
     }

   if(dayCount == 0)
      return(0);
   return(sumRange / dayCount);
  }

//+------------------------------------------------------------------+
//| 現在進行中のセッションの値幅(pips)を、確定しているバーの分だけ計算する    |
//+------------------------------------------------------------------+
double CurrentSessionRangeSoFar(int sessionBars)
  {
   double point = PointAdjust();
   double high = iHigh(_Symbol, PERIOD_H1, 0);
   double low  = iLow(_Symbol, PERIOD_H1, 0);

   for(int i = 1; i < sessionBars; i++)
     {
      high = MathMax(high, iHigh(_Symbol, PERIOD_H1, i));
      low  = MathMin(low,  iLow(_Symbol, PERIOD_H1, i));
     }
   return((high - low) / point);
  }

//+------------------------------------------------------------------+
//| 同じマジックナンバー・同じシンボルの保有ポジションが無いか確認する         |
//+------------------------------------------------------------------+
bool HasOpenPosition()
  {
   for(int i = 0; i < OrdersTotal(); i++)
     {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
         if(OrderSymbol() == _Symbol && OrderMagicNumber() == InpMagicNumber)
            return(true);
        }
     }
   return(false);
  }

//+------------------------------------------------------------------+
//| セッション別値幅ブレイクアウトを判定し、条件を満たせば発注する             |
//+------------------------------------------------------------------+
void CheckSessionBreakout()
  {
   if(HasOpenPosition())
      return;

   int startHour, endHour;
   if(!GetCurrentSessionHours(startHour, endHour))
      return; // 東京・ロンドン・NYいずれのセッションでもない時間帯

   int sessionBars = CountCurrentSessionBars(startHour, endHour);
   if(sessionBars < 2)
      return; // セッション開始直後で、比較対象の確定バーがまだ無い

   double avgRange = ComputeAverageSessionRange(startHour, endHour, InpLookbackDays, sessionBars);
   if(avgRange == 0)
      return; // 過去データ不足

   double curRange = CurrentSessionRangeSoFar(sessionBars);
   double ratio = curRange / avgRange;

   if(ratio < InpMinRangeRatio)
      return; // 値幅が小さすぎるセッション:ボラティリティフィルターで見送る

   if(ratio < InpBreakoutRatio)
      return; // まだブレイクアウトの基準に達していない

   datetime sessionStartTime = iTime(_Symbol, PERIOD_H1, sessionBars - 1);
   if(sessionStartTime == lastTradedSessionStart)
      return; // このセッションでは既にエントリー済み(重複防止)

   double priorHigh = iHigh(_Symbol, PERIOD_H1, 1);
   double priorLow  = iLow(_Symbol, PERIOD_H1, 1);
   for(int k = 2; k < sessionBars; k++)
     {
      priorHigh = MathMax(priorHigh, iHigh(_Symbol, PERIOD_H1, k));
      priorLow  = MathMin(priorLow,  iLow(_Symbol, PERIOD_H1, k));
     }

   double point = PointAdjust();

   if(Bid > priorHigh)
     {
      double sl = Ask - InpStopLossPips * point;
      int ticket = OrderSend(_Symbol, OP_BUY, InpLots, Ask, 3, sl, 0,
                              "SessionRangeBreakoutEA", InpMagicNumber, 0, clrBlue);
      if(ticket < 0)
         Print("買い発注に失敗しました。エラーコード: ", GetLastError());
      else
         lastTradedSessionStart = sessionStartTime;
     }
   else if(Bid < priorLow)
     {
      double sl = Bid + InpStopLossPips * point;
      int ticket = OrderSend(_Symbol, OP_SELL, InpLots, Bid, 3, sl, 0,
                              "SessionRangeBreakoutEA", InpMagicNumber, 0, clrRed);
      if(ticket < 0)
         Print("売り発注に失敗しました。エラーコード: ", GetLastError());
      else
         lastTradedSessionStart = sessionStartTime;
     }
  }

//+------------------------------------------------------------------+
//| Expert tick function                                              |
//+------------------------------------------------------------------+
void OnTick()
  {
   CheckSessionBreakout();
  }
//+------------------------------------------------------------------+

ブレイクアウト方向への順張りエントリーと、値幅が小さすぎるセッションの見送りを、

1つのratio(比率)の判定で同時に実現している構成です。

MetaEditorでのコンパイル・バックテスト手順

実際にMT4で動かすまでの手順です。

  1. MetaEditorで新規EA「SessionRangeBreakoutEA」を作成し、上のコードを貼り付けてコンパイルする
  2. 「0 error(s), 0 warning(s)」になることを確認する
  3. ストラテジーテスターでInpBreakoutRatioを極端に高い値(例: 99)にして一度バックテストし、エントリーが発生しないことを確認する
  4. InpBreakoutRatioを1.3前後に戻し、同じ期間で再度バックテストする
  5. 取引回数・損益・最大ドローダウンを比較し、InpMinRangeRatio・InpBreakoutRatioを通貨ペアごとに調整する

よくある質問

セッション値幅ブレイクアウトEAについて、よくある疑問に回答します。

このEAは複数の通貨ペアを同時に監視できますか?

このEA自体は単一シンボル(チャートに適用したシンボル)のみを対象にしています。

既刊インジケーターのように複数ペアを1画面で比較する機能は持っていません。

複数ペアを同時に監視したい場合は、

同じEAを別のシンボルのチャートにもう1つ適用してください。

その場合はInpMagicNumberをシンボルごとに変えておくと、

どのチャートの発注か区別しやすくなります。

適用直後にエントリーが起きないときに確認すること

セッション開始直後はCountCurrentSessionBars()が1以下になり、

比較対象の確定バーがまだありません。

この場合、CheckSessionBreakout()は、

何もせず終了します(正常な動作です)。

また、ヒストリカルデータが少ない場合は、

ComputeAverageSessionRange()が、

dayCount=0のまま0を返し、

avgRange==0でエントリー判定をスキップします。

数十分〜数時間待ち、

InpLookbackDays分のセッション履歴が揃っているか確認してください。

ブレイクアウト方向と逆に動いたらどうなりますか?

InpStopLossPipsで指定した値幅で、必ず損切りが設定されています。

ブレイクアウトが不成立(いわゆる「だまし」)だった場合は、

この損切りで決済されます。

本記事のコードはテイクプロフィットを設定していないため、

決済はこの損切りか、手動・別ロジックでの決済が前提です。

利益確定のロジックを追加したい場合は、

既刊ATRトレーリングストップEAの記事のような仕組みを組み合わせることを検討してください。

既刊ATRボラティリティフィルターEAと組み合わせて使えますか?

本記事のコードには組み込んでいませんが、考え方としては組み合わせ可能です。

CheckSessionBreakout()の中で、

既刊ATRボラティリティフィルターEAのIsVolatilityOK()も同時に呼び出し、

両方の条件を満たした場合だけエントリーする、という拡張ができます。

「時間帯特有のクセ」と「相場全体のボラティリティ」という、

異なる視点の条件を両方満たすことで、より厳しい絞り込みになります。

【MQL4】セッション別値幅比較インジケーターの計算ロジックをEAに転用。値幅のブレイクアウトで順張りし、動きが乏しいセッションは見送るEAの作り方:まとめ

この記事では、既刊のセッション別値幅比較インジケーターが行っていた、

東京・ロンドン・NYの平均値幅(pips)を計算するロジックを、

発注条件に転用する方法を解説しました。

「過去の完了済みセッションの平均」と、

「現在進行中のセッションの値幅」を分けて計算することで、

1つの比率でブレイクアウトの順張りと、

動きが乏しいセッションの見送りの両方を実現しています。

損切りを必ず設定し、マジックナンバーでの重複防止、

同一セッション内の再エントリー防止もあわせて実装しました。

既刊のATRボラティリティフィルターEAとは判定対象が異なるため、

両方の考え方を知っておくと、相場に応じて使い分けやすくなります。

くわしい自動化の開示方針は編集方針ページもご覧ください。

関連記事