Русский
Открыть на GitHub

Стратегия Hull Trend OSMA

Стратегия представляет собой конвертацию эксперта MetaTrader «Exp_HullTrendOSMA».

Описание

Используется индикатор Hull Trend OSMA, который вычисляет Hull Moving Average и его сглаженную версию. Разница между ними образует осциллятор. Если осциллятор растёт на двух подряд завершённых свечах, открывается длинная позиция. Если осциллятор падает на двух подряд завершённых свечах, открывается короткая позиция. При каждом сигнале закрываются позиции противоположного направления.

Параметры

  • Hull Period – период Hull Moving Average.
  • Signal Period – период сглаживающей скользящей средней осциллятора.
  • Take Profit – расстояние до тейк‑профита в ценовых единицах.
  • Stop Loss – расстояние до стоп‑лосса в ценовых единицах.
  • Candle Type – таймфрейм используемых свечей (по умолчанию 8 часов).

Примечания

  • Используется высокоуровневый API StockSharp с автоматической подпиской на свечи.
  • Входы и выходы выполняются рыночными заявками.
  • Защитные стоп и тейк‑профит активируются один раз при старте стратегии.
using System;
using System.Collections.Generic;

using Ecng.Common;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Strategy based on Hull Trend OSMA indicator.
/// Opens long when oscillator rises twice in a row, short when it falls twice in a row.
/// </summary>
public class HullTrendOsmaStrategy : Strategy
{
	private readonly StrategyParam<int> _hullPeriod;
	private readonly StrategyParam<int> _signalPeriod;
	private readonly StrategyParam<decimal> _takeProfit;
	private readonly StrategyParam<decimal> _stopLoss;
	private readonly StrategyParam<DataType> _candleType;

	private decimal? _prev1;
	private decimal? _prev2;
	private Order _pending;

	public int HullPeriod { get => _hullPeriod.Value; set => _hullPeriod.Value = value; }
	public int SignalPeriod { get => _signalPeriod.Value; set => _signalPeriod.Value = value; }
	public decimal TakeProfit { get => _takeProfit.Value; set => _takeProfit.Value = value; }
	public decimal StopLoss { get => _stopLoss.Value; set => _stopLoss.Value = value; }
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }

	public HullTrendOsmaStrategy()
	{
		_hullPeriod = Param(nameof(HullPeriod), 20)
			.SetDisplay("Hull Period", "Period for Hull Moving Average", "Indicators");

		_signalPeriod = Param(nameof(SignalPeriod), 5)
			.SetDisplay("Signal Period", "Period for signal SMA", "Indicators");

		_takeProfit = Param(nameof(TakeProfit), 3m)
			.SetDisplay("Take Profit %", "Take profit percentage", "Risk");

		_stopLoss = Param(nameof(StopLoss), 2m)
			.SetDisplay("Stop Loss %", "Stop loss percentage", "Risk");

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(8).TimeFrame())
			.SetDisplay("Candle Type", "Type of candles to use", "General");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_prev1 = null;
		_prev2 = null;
		_pending = null;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		_pending = null;

		var hma = new HullMovingAverage { Length = HullPeriod };
		var signal = new SimpleMovingAverage { Length = SignalPeriod };

		var subscription = SubscribeCandles(CandleType);
		subscription.Bind(hma, (candle, hmaValue) =>
		{
			if (candle.State != CandleStates.Finished || !hma.IsFormed) return;
			var sig = signal.Process(hmaValue, candle.OpenTime, true);
			if (sig.IsFormed && !sig.IsEmpty) ProcessCandle(candle, hmaValue, sig.ToDecimal());
		}).Start();

		StartProtection(
			takeProfit: new Unit(TakeProfit, UnitTypes.Absolute),
			stopLoss: new Unit(StopLoss, UnitTypes.Absolute),
			useMarketOrders: true);

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawIndicator(area, hma);
			DrawIndicator(area, signal);
			DrawOwnTrades(area);
		}
	}

	private void ProcessCandle(ICandleMessage candle, decimal hmaValue, decimal signalValue)
	{
		if (candle.State != CandleStates.Finished)
			return;

		var osma = hmaValue - signalValue;

		if (_prev1 is null || _prev2 is null)
		{
			_prev2 = _prev1;
			_prev1 = osma;
			return;
		}

		var prev = _prev1.Value;
		var prevPrev = _prev2.Value;

		var isRising = prev > prevPrev && osma >= prev;
		var isFalling = prev < prevPrev && osma <= prev;

		if (IsFormedAndOnlineAndAllowTrading() && (_pending is null || _pending.State is OrderStates.Done or OrderStates.Failed))
		{
			if (isRising && Position <= 0m) _pending = BuyMarket(Volume - Math.Min(0m, Position));
			else if (isFalling && Position >= 0m) _pending = SellMarket(Volume + Math.Max(0m, Position));
		}

		_prev2 = _prev1;
		_prev1 = osma;
	}
}