Average True Range: Measuring Market Volatility

// ATR indicator handle
int atrHandle;
double atrBuffer[];
 
int OnInit()
{
   // Create ATR indicator: 14-period on the current symbol/timeframe
   atrHandle = iATR(_Symbol, PERIOD_CURRENT, 14);
   
   if(atrHandle == INVALID_HANDLE)
   {
      Print("Error creating ATR handle: ", GetLastError());
      return INIT_FAILED;
   }
   
   ArraySetAsSeries(atrBuffer, true);
   return INIT_SUCCEEDED;
}
 
double GetATR()
{
   // Copy the last 3 ATR values into the buffer
   if(CopyBuffer(atrHandle, 0, 0, 3, atrBuffer) < 0)
   {
      Print("Error copying ATR buffer: ", GetLastError());
      return 0.0;
   }
   // Return the most recently completed candle's ATR (index 1)
   return atrBuffer[1];
}
 
void PlaceATROrder(ENUM_ORDER_TYPE orderType)
{
   double atrValue    = GetATR();
   double entryPrice  = (orderType == ORDER_TYPE_BUY) 
                           ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) 
                           : SymbolInfoDouble(_Symbol, SYMBOL_BID);
   
   // Stop-loss: 1.5× ATR from entry
   double stopLoss = (orderType == ORDER_TYPE_BUY)
                        ? entryPrice - (1.5 * atrValue)
                        : entryPrice + (1.5 * atrValue);
   
   // Take-profit: 2.5× ATR from entry
   double takeProfit = (orderType == ORDER_TYPE_BUY)
                          ? entryPrice + (2.5 * atrValue)
                          : entryPrice - (2.5 * atrValue);
   
   MqlTradeRequest request = {};
   MqlTradeResult  result  = {};
   
   request.action    = TRADE_ACTION_DEAL;
   request.symbol    = _Symbol;
   request.volume    = 0.1;
   request.type      = orderType;
   request.price     = entryPrice;
   request.sl        = NormalizeDouble(stopLoss,  _Digits);
   request.tp        = NormalizeDouble(takeProfit, _Digits);
   request.comment   = "ATR SL/TP";
   
   if(!OrderSend(request, result))
      Print("OrderSend failed: ", result.retcode);
   else
      Print("Order placed | ATR: ", atrValue, 
            " | SL: ", stopLoss, " | TP: ", takeProfit);
}
 
void OnDeinit(const int reason)
{
   IndicatorRelease(atrHandle);
}

// ─── Inputs ───────────────────────────────────────────────────────────────────
input double InpRiskPercent   = 1.0;   // Risk per trade as % of account balance
input double InpATRMultiplier = 1.5;   // Stop distance in ATR multiples
input int    InpATRPeriod     = 14;    // ATR lookback period
 
// ─── ATR handle (initialised in OnInit) ───────────────────────────────────────
int    g_atrHandle;
double g_atrBuffer[];
 
int OnInit()
{
   g_atrHandle = iATR(_Symbol, PERIOD_CURRENT, InpATRPeriod);
   if(g_atrHandle == INVALID_HANDLE) return INIT_FAILED;
   ArraySetAsSeries(g_atrBuffer, true);
   return INIT_SUCCEEDED;
}
 
// ─── Get current ATR value ─────────────────────────────────────────────────────
double GetCurrentATR()
{
   if(CopyBuffer(g_atrHandle, 0, 1, 1, g_atrBuffer) < 1) return 0.0;
   return g_atrBuffer[0];
}
 
// ─── Calculate lot size from ATR + risk parameters ────────────────────────────
double CalculateLotSize(double atrValue)
{
   if(atrValue <= 0.0) return 0.0;
 
   double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
   double riskAmount     = accountBalance * (InpRiskPercent / 100.0);
   double stopPips       = (atrValue / _Point) * InpATRMultiplier;
 
   // Pip value per lot in account currency
   double pipValuePerLot = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE)
                           / SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE)
                           * _Point;
 
   if(pipValuePerLot <= 0.0) return 0.0;
 
   double rawLots = riskAmount / (stopPips * pipValuePerLot);
 
   // Clamp to broker lot constraints
   double minLot  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxLot  = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   double lots    = MathFloor(rawLots / lotStep) * lotStep;
 
   lots = MathMax(minLot, MathMin(maxLot, lots));
 
   Print("ATR: ", atrValue,
         " | Stop: ", stopPips, " pips",
         " | Risk $: ", riskAmount,
         " | Lots: ", lots);
 
   return lots;
}
 
// ─── Example usage in OnTick / signal logic ───────────────────────────────────
void OnTick()
{
   double atr  = GetCurrentATR();
   double lots = CalculateLotSize(atr);
   
   if(lots <= 0.0) return;
   
   // Use lots in your MqlTradeRequest as normal
   // request.volume = lots;
}

// ATR handles
int g_atrHandle;
int g_atrMaHandle;   // MA applied to ATR values
double g_atr[];
double g_atrMa[];
 
int OnInit()
{
   // 14-period ATR
   g_atrHandle = iATR(_Symbol, PERIOD_CURRENT, 14);
   
   // 20-period SMA of ATR — requires a custom indicator approach.
   // A common alternative: calculate ATR manually over two windows.
   // Here we use iMA on the CLOSE with the same logic as a proxy.
   // For production, apply iCustom or compute ATR SMA inline (see below).
   
   if(g_atrHandle == INVALID_HANDLE) return INIT_FAILED;
   ArraySetAsSeries(g_atr, true);
   return INIT_SUCCEEDED;
}
 
enum ENUM_MARKET_REGIME { REGIME_TRENDING, REGIME_RANGING, REGIME_UNKNOWN };
 
ENUM_MARKET_REGIME DetectRegime()
{
   // Copy 21 ATR values to compute a 20-bar simple average inline
   double atrValues[];
   ArraySetAsSeries(atrValues, true);
   
   if(CopyBuffer(g_atrHandle, 0, 1, 21, atrValues) < 21)
      return REGIME_UNKNOWN;
   
   double currentATR = atrValues[0];
   
   // Simple 20-period average of ATR (bars 1–20)
   double atrSum = 0.0;
   for(int i = 1; i <= 20; i++) atrSum += atrValues[i];
   double atrAvg = atrSum / 20.0;
   
   // Regime thresholds
   if(currentATR > atrAvg * 1.20)
      return REGIME_TRENDING;   // ATR 20% above average → expanding volatility
   if(currentATR < atrAvg * 0.80)
      return REGIME_RANGING;    // ATR 20% below average → compressing volatility
      
   return REGIME_UNKNOWN;       // Neutral / transitioning
}
 
void OnTick()
{
   ENUM_MARKET_REGIME regime = DetectRegime();
   
   double atrMultiplier;
   double tpMultiplier;
   
   switch(regime)
   {
      case REGIME_TRENDING:
         atrMultiplier = 2.0;   // Wider stop to ride the trend
         tpMultiplier  = 4.0;   // Extended target
         Print("Regime: TRENDING — wider stops, extended targets");
         break;
      case REGIME_RANGING:
         atrMultiplier = 1.0;   // Tight stop near range boundary
         tpMultiplier  = 1.5;   // Conservative target
         Print("Regime: RANGING — tight stops, conservative targets");
         break;
      default:
         atrMultiplier = 1.5;   // Default
         tpMultiplier  = 2.5;
         Print("Regime: NEUTRAL — standard parameters");
         break;
   }
   
   // Pass atrMultiplier into your stop/TP and lot size logic
}

input double InpATRMultiplier  = 1.5;    // Stop distance in ATR multiples
input double InpMinATRPips     = 20.0;   // Minimum ATR floor in pips
input double InpSpreadBuffer   = 1.5;    // Extra spread buffer multiplier
 
double GetSafeStopDistance(double atrValue)
{
   // Convert minimum ATR pips to price units
   double atrFloor = InpMinATRPips * _Point * 10; // adjust for 5-digit brokers
   
   // Use the larger of current ATR or the floor
   double effectiveATR = MathMax(atrValue, atrFloor);
   
   // Raw stop distance
   double stopDistance = effectiveATR * InpATRMultiplier;
   
   // Add spread buffer to prevent stop being within bid/ask spread
   double currentSpread = SymbolInfoInteger(_Symbol, SYMBOL_SPREAD) * _Point;
   stopDistance += currentSpread * InpSpreadBuffer;
   
   return NormalizeDouble(stopDistance, _Digits);
}
 
void OnTick()
{
   double atr  = GetCurrentATR(); // from earlier example
   double stop = GetSafeStopDistance(atr);
   
   double entryBuy = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double slBuy    = entryBuy - stop;
   double tpBuy    = entryBuy + (stop * (2.5 / InpATRMultiplier)); // maintain R:R
   
   Print("Effective stop: ", stop / _Point, " pips",
         " (ATR: ", atr / _Point, " pips, spread buffered)");
}