日本語 JA
GitHub で見る

CCIT3 Zero Cross Strategy

Overview

The CCIT3 Zero Cross strategy is a StockSharp port of the MetaTrader 5 expert advisor that trades zero-line reversals of the CCIT3 oscillator. The indicator is built by applying the Tillson T3 smoothing chain to a Commodity Channel Index (CCI). Whenever the smoothed oscillator switches sign the strategy either opens a new position in the direction of the flip or, if configured, closes the current position and reverses it.

Trading logic

  • Calculate the CCI using the selected applied price and period.
  • Smooth the oscillator with a Tillson T3 pipeline. Two calculation modes are provided:
    • Simple – persistent six-stage smoothing that behaves like the original recalculating MetaTrader indicator.
    • NoRecalc – evaluates the T3 polynomial only for the most recent bar, recreating the lightweight “no recalculation” version from the source code.
  • When the CCIT3 value crosses from positive to negative, open a long position (or reverse a short if Trade Overturn is enabled).
  • When the CCIT3 value crosses from negative to positive, open a short position (or reverse a long if Trade Overturn is enabled).
  • Optional take-profit, stop-loss and trailing stop levels are managed through StockSharp’s StartProtection helper.

Indicators and calculations

  • Commodity Channel Index (CCI) – runs on the configurable applied price (close, open, high, low, median, typical, weighted) and period.
  • Tillson T3 smoothing – implemented exactly as in the MQL5 indicator with the B volume factor. The Simple mode keeps stateful EMA chains across bars, while NoRecalc recomputes the polynomial from the latest raw CCI reading.
  • Zero-cross detection – trades are triggered strictly on finished candles, mirroring the original new-bar checks in the expert advisor.

Risk and position management

  • Take Profit (pts) and Stop Loss (pts) convert into absolute price distances using the instrument’s PriceStep.
  • Trailing Stop (pts) activates StockSharp’s trailing engine with the same point distance.
  • Max Drawdown Target rescales the base order volume using the current or initial portfolio value (volume = OrderVolume * balance / target). Leave the parameter at zero to keep a fixed lot size.
  • Trade Overturn enables full reversal – the current position is closed first and then a new one is opened in the opposite direction.

Parameters

Name Default Description
Volume 1 Base order volume before any drawdown scaling.
Take Profit (pts) 1750 Take-profit distance in points.
Stop Loss (pts) 0 Stop-loss distance in points.
Trailing Stop (pts) 0 Trailing stop distance in points (0 disables trailing).
Trade Overturn false Reverse the position on opposite CCIT3 signals.
CCI Period 285 Lookback period for the CCI indicator.
CCI Price Typical Applied price used to feed the CCI.
T3 Period 60 Tillson T3 smoothing length.
T3 Volume Factor 0.618 Tillson T3 B coefficient.
Mode Simple CCIT3 calculation mode (Simple or NoRecalc).
Candle Type 1 hour time frame Timeframe used for candle subscriptions.
Max Drawdown Target 0 Balance divisor for adaptive volume sizing (0 disables scaling).

Implementation notes

  • The strategy subscribes to a single candle source specified by Candle Type and processes only completed candles.
  • All volume values are aligned to the security’s volume step and bounded by VolumeMin/VolumeMax.
  • Default parameters replicate the published MT5 configuration: CCIT3 Simple mode with a 285-period CCI, T3 length 60, and 0.618 volume factor.
  • Switching to NoRecalc keeps the original indicator’s behaviour of reacting instantly to the raw CCI sign while still producing positive/negative signals.
using System;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// CCIT3 Zero Cross: EMA crossover with RSI filter and ATR stops.
/// </summary>
public class Ccit3ZeroCrossStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _fastEmaLength;
	private readonly StrategyParam<int> _slowEmaLength;
	private readonly StrategyParam<int> _rsiLength;
	private readonly StrategyParam<int> _atrLength;

	private decimal _prevFast;
	private decimal _prevSlow;
	private decimal _entryPrice;

	public Ccit3ZeroCrossStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe.", "General");
		_fastEmaLength = Param(nameof(FastEmaLength), 9)
			.SetDisplay("Fast EMA Length", "Fast EMA period.", "Indicators");
		_slowEmaLength = Param(nameof(SlowEmaLength), 21)
			.SetDisplay("Slow EMA Length", "Slow EMA period.", "Indicators");
		_rsiLength = Param(nameof(RsiLength), 14)
			.SetDisplay("RSI Length", "RSI period.", "Indicators");
		_atrLength = Param(nameof(AtrLength), 14)
			.SetDisplay("ATR Length", "ATR period.", "Indicators");
	}

	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }
	public int FastEmaLength { get => _fastEmaLength.Value; set => _fastEmaLength.Value = value; }
	public int SlowEmaLength { get => _slowEmaLength.Value; set => _slowEmaLength.Value = value; }
	public int RsiLength { get => _rsiLength.Value; set => _rsiLength.Value = value; }
	public int AtrLength { get => _atrLength.Value; set => _atrLength.Value = value; }

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();

		_prevFast = 0; _prevSlow = 0; _entryPrice = 0;
	}

		protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		_prevFast = 0; _prevSlow = 0; _entryPrice = 0;
		var fastEma = new ExponentialMovingAverage { Length = FastEmaLength };
		var slowEma = new ExponentialMovingAverage { Length = SlowEmaLength };
		var rsi = new RelativeStrengthIndex { Length = RsiLength };
		var atr = new AverageTrueRange { Length = AtrLength };
		var subscription = SubscribeCandles(CandleType);
		subscription.Bind(fastEma, slowEma, rsi, atr, ProcessCandle).Start();
		var area = CreateChartArea();
		if (area != null) { DrawCandles(area, subscription); DrawIndicator(area, fastEma); DrawIndicator(area, slowEma); DrawOwnTrades(area); }
	}

	private void ProcessCandle(ICandleMessage candle, decimal fastVal, decimal slowVal, decimal rsiVal, decimal atrVal)
	{
		if (candle.State != CandleStates.Finished) return;
		if (_prevFast == 0 || _prevSlow == 0 || atrVal <= 0) { _prevFast = fastVal; _prevSlow = slowVal; return; }
		var close = candle.ClosePrice;

		if (Position > 0)
		{
			if ((fastVal < slowVal && _prevFast >= _prevSlow) || close <= _entryPrice - atrVal * 2m) { SellMarket(); _entryPrice = 0; }
		}
		else if (Position < 0)
		{
			if ((fastVal > slowVal && _prevFast <= _prevSlow) || close >= _entryPrice + atrVal * 2m) { BuyMarket(); _entryPrice = 0; }
		}

		if (Position == 0)
		{
			if (fastVal > slowVal && _prevFast <= _prevSlow && rsiVal > 50) { _entryPrice = close; BuyMarket(); }
			else if (fastVal < slowVal && _prevFast >= _prevSlow && rsiVal < 50) { _entryPrice = close; SellMarket(); }
		}
		_prevFast = fastVal; _prevSlow = slowVal;
	}
}